SpringCloud笔记（三）微服务应用

<!--  SpringSession Redis支持  -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>
<!--  添加Redis的Starter  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

spring:
  session:
    # 存储类型修改为redis
    store-type: redis
  redis:
    # Redis服务器的信息，该咋写咋写
    host: 1.14.121.107

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-dependencies</artifactId>
    <version>2021.0.1</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    
    <!--  OAuth2.0依赖，不再内置了，所以得我们自己指定一下版本  -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2</artifactId>
        <version>2.2.5.RELEASE</version>
    </dependency>
</dependencies>

server:
  port: 8500
  servlet:
    #为了防止一会在服务之间跳转导致Cookie打架（因为所有服务地址都是localhost，都会存JSESSIONID）
    #这里修改一下context-path，这样保存的Cookie会使用指定的路径，就不会和其他服务打架了
    #但是注意之后的请求都得在最前面加上这个路径
    context-path: /sso

@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().authenticated()  //
                .and()
                .formLogin().permitAll();    //使用表单登录
    }
  
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        auth
                .inMemoryAuthentication()   //直接创建一个用户，懒得搞数据库了
                .passwordEncoder(encoder)
                .withUser("test").password(encoder.encode("123456")).roles("USER");
    }
  
    @Bean   //这里需要将AuthenticationManager注册为Bean，在OAuth配置中使用
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

@EnableAuthorizationServer   //开启验证服务器
@Configuration
public class OAuth2Configuration extends AuthorizationServerConfigurerAdapter {

    @Resource
    private AuthenticationManager manager;

    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

    /**
     * 这个方法是对客户端进行配置，一个验证服务器可以预设很多个客户端，
     * 之后这些指定的客户端就可以按照下面指定的方式进行验证
     * @param clients 客户端配置工具
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients
                .inMemory()   //这里我们直接硬编码创建，当然也可以像Security那样自定义或是使用JDBC从数据库读取
                .withClient("web")   //客户端名称，随便起就行
                .secret(encoder.encode("654321"))      //只与客户端分享的secret，随便写，但是注意要加密
                .autoApprove(false)    //自动审批，这里关闭，要的就是一会体验那种感觉
                .scopes("book", "user", "borrow")     //授权范围，这里我们使用全部all
                .authorizedGrantTypes("client_credentials", "password", "implicit", "authorization_code", "refresh_token");
                //授权模式，一共支持5种，除了之前我们介绍的四种之外，还有一个刷新Token的模式
                //这里我们直接把五种都写上，方便一会实验，当然各位也可以单独只写一种一个一个进行测试
                //现在我们指定的客户端就支持这五种类型的授权方式了
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) {
        security
                .passwordEncoder(encoder)    //编码器设定为BCryptPasswordEncoder
                .allowFormAuthenticationForClients()  //允许客户端使用表单验证，一会我们POST请求中会携带表单信息
                .checkTokenAccess("permitAll()");     //允许所有的Token查询请求
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        endpoints
                .authenticationManager(manager);
        //由于SpringSecurity新版本的一些底层改动，这里需要配置一下authenticationManager，才能正常使用password模式
    }
}

@Overridepublic void configure(ClientDetailsServiceConfigurer clients) throws Exception {    clients            .inMemory()            .withClient("web")            .secret(encoder.encode("654321"))            .autoApprove(false)            .scopes("book", "user", "borrow")            .redirectUris("http://localhost:8201/login")   //可以写多个，当有多个时需要在验证请求中指定使用哪个地址进行回调            .authorizedGrantTypes("client_credentials", "password", "implicit", "authorization_code", "refresh_token");}

@Bean@Overridepublic UserDetailsService userDetailsServiceBean() throws Exception {    return super.userDetailsServiceBean();}

@ResourceUserDetailsService service;@Overridepublic void configure(AuthorizationServerEndpointsConfigurer endpoints) {    endpoints            .userDetailsService(service)            .authenticationManager(manager);}

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-security</artifactId></dependency><dependency>    <groupId>org.springframework.cloud</groupId>    <artifactId>spring-cloud-starter-oauth2</artifactId>    <version>2.2.5.RELEASE</version></dependency>

@EnableOAuth2Sso@SpringBootApplicationpublic class BookApplication {    public static void main(String[] args) {        SpringApplication.run(BookApplication.class, args);    }}

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@EnableOAuth2Client@EnableConfigurationProperties({OAuth2SsoProperties.class})@Import({OAuth2SsoDefaultConfiguration.class, OAuth2SsoCustomConfiguration.class, ResourceServerTokenServicesConfiguration.class})public @interface EnableOAuth2Sso {}

@Configuration@Conditional({NeedsWebSecurityCondition.class})public class OAuth2SsoDefaultConfiguration extends WebSecurityConfigurerAdapter {    //直接继承的WebSecurityConfigurerAdapter，帮我们把验证设置都写好了    private final ApplicationContext applicationContext;    public OAuth2SsoDefaultConfiguration(ApplicationContext applicationContext) {        this.applicationContext = applicationContext;    }

security:  oauth2:    client:      #不多说了      client-id: web      client-secret: 654321      #Token获取地址      access-token-uri: http://localhost:8500/sso/oauth/token      #验证页面地址      user-authorization-uri: http://localhost:8500/sso/oauth/authorize    resource:      #Token信息获取和校验地址      token-info-uri: http://localhost:8500/sso/oauth/check_token

@RequestMapping("/book/{bid}")Book findBookById(@PathVariable("bid") int bid){    //通过SecurityContextHolder将用户信息取出    SecurityContext context = SecurityContextHolder.getContext();    System.out.println(context.getAuthentication());    return service.getBookById(bid);}

@Overridepublic void configure(ClientDetailsServiceConfigurer clients) throws Exception {    clients            .inMemory()            .withClient("web")            .secret(encoder.encode("654321"))            .autoApprove(true)   //这里把自动审批开了，就不用再去手动选同意了            .scopes("book", "user", "borrow")            .redirectUris("http://localhost:8101/login", "http://localhost:8201/login", "http://localhost:8301/login")            .authorizedGrantTypes("client_credentials", "password", "implicit", "authorization_code", "refresh_token");}

@EnableResourceServer@SpringBootApplicationpublic class BookApplication {    public static void main(String[] args) {        SpringApplication.run(BookApplication.class, args);    }}

security:  oauth2:    client:     #基操      client-id: web      client-secret: 654321    resource:     #因为资源服务器得验证你的Token是否有访问此资源的权限以及用户信息，所以只需要一个验证地址      token-info-uri: http://localhost:8500/sso/oauth/check_token

@Configurationpublic class ResourceConfiguration extends ResourceServerConfigurerAdapter { //继承此类进行高度自定义    @Override    public void configure(HttpSecurity http) throws Exception {  //这里也有HttpSecurity对象，方便我们配置SpringSecurity        http                .authorizeRequests()                .anyRequest().access("#oauth2.hasScope('lbwnb')");  //添加自定义规则                //Token必须要有我们自定义scope授权才可以访问此资源    }}

@Configurationpublic class WebConfiguration {    @Resource    OAuth2ClientContext context;    @Bean    public OAuth2RestTemplate restTemplate(){        return new OAuth2RestTemplate(new ClientCredentialsResourceDetails(), context);    }}

@Servicepublic class BorrowServiceImpl implements BorrowService {    @Resource    BorrowMapper mapper;    @Resource    OAuth2RestTemplate template;    @Override    public UserBorrowDetail getUserBorrowDetailByUid(int uid) {        List<Borrow> borrow = mapper.getBorrowsByUid(uid);        User user = template.getForObject("http://localhost:8101/user/"+uid, User.class);        //获取每一本书的详细信息        List<Book> bookList = borrow                .stream()                .map(b -> template.getForObject("http://localhost:8201/book/"+b.getBid(), Book.class))                .collect(Collectors.toList());        return new UserBorrowDetail(user, bookList);    }}

<dependency>    <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-alibaba-dependencies</artifactId>    <version>2021.0.1.0</version>    <type>pom</type>    <scope>import</scope></dependency>

<dependency>    <groupId>com.alibaba.cloud</groupId>    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId></dependency><dependency>    <groupId>org.springframework.cloud</groupId>    <artifactId>spring-cloud-starter-loadbalancer</artifactId></dependency>

@Configurationpublic class WebConfiguration {    @Resource    OAuth2ClientContext context;    @LoadBalanced   //和RestTemplate一样直接添加注解就行了    @Bean    public OAuth2RestTemplate restTemplate(){        return new OAuth2RestTemplate(new ClientCredentialsResourceDetails(), context);    }}

@FeignClient("user-service")public interface UserClient {        @RequestMapping("/user/{uid}")    User getUserById(@PathVariable("uid") int uid);}

@FeignClient("book-service")public interface BookClient {    @RequestMapping("/book/{bid}")    Book getBookById(@PathVariable("bid") int bid);}

feign:  oauth2:   #开启Oauth支持，这样就会在请求头中携带Token了    enabled: true    #同时开启负载均衡支持    load-balanced: true

public void test(){    String str = "你们可能不知道只用20万赢到578万是什么概念";    //Base64不只是可以对字符串进行编码，任何byte[]数据都可以，编码结果可以是byte[]，也可以是字符串    String encodeStr = Base64.getEncoder().encodeToString(str.getBytes());    System.out.println("Base64编码后的字符串："+encodeStr);    System.out.println("解码后的字符串："+new String(Base64.getDecoder().decode(encodeStr)));}

@Beanpublic JwtAccessTokenConverter tokenConverter(){  //Token转换器，将其转换为JWT    JwtAccessTokenConverter converter = new JwtAccessTokenConverter();    converter.setSigningKey("lbwnb");   //这个是对称密钥，一会资源服务器那边也要指定为这个    return converter;}@Beanpublic TokenStore tokenStore(JwtAccessTokenConverter converter){  //Token存储方式现在改为JWT存储    return new JwtTokenStore(converter);  //传入刚刚定义好的转换器}

@ResourceTokenStore store;@ResourceJwtAccessTokenConverter converter;private AuthorizationServerTokenServices serverTokenServices(){  //这里对AuthorizationServerTokenServices进行一下配置    DefaultTokenServices services = new DefaultTokenServices();    services.setSupportRefreshToken(true);   //允许Token刷新    services.setTokenStore(store);   //添加刚刚的TokenStore    services.setTokenEnhancer(converter);   //添加Token增强，其实就是JwtAccessTokenConverter，增强是添加一些自定义的数据到JWT中    return services;}@Overridepublic void configure(AuthorizationServerEndpointsConfigurer endpoints) {    endpoints            .tokenServices(serverTokenServices())   //设定为刚刚配置好的AuthorizationServerTokenServices            .userDetailsService(service)            .authenticationManager(manager);}

security:  oauth2:    resource:      jwt:        key-value: lbwnb #注意这里要跟验证服务器的密钥一致，这样算出来的签名才会一致

# Accept connections on the specified port, default is 6379 (IANA #815344).# If port 0 is specified Redis will not listen on a TCP socket.port 6001

replicaof 127.0.0.1 6001

sentinel monitor lbwnb 127.0.0.1 6001 1

sentinel monitor lbwnb 192.168.0.8 6001 2

<dependencies>    <dependency>        <groupId>redis.clients</groupId>        <artifactId>jedis</artifactId>        <version>4.2.1</version>    </dependency></dependencies>

public class Main {    public static void main(String[] args) {        //这里我们直接使用JedisSentinelPool来获取Master节点        //需要把三个哨兵的地址都填入        try (JedisSentinelPool pool = new JedisSentinelPool("lbwnb",                new HashSet<>(Arrays.asList("192.168.0.8:26741", "192.168.0.8:26740", "192.168.0.8:26739")))) {            Jedis jedis = pool.getResource();   //直接询问并得到Jedis对象，这就是连接的Master节点            jedis.set("test", "114514");    //直接写入即可，实际上就是向Master节点写入            Jedis jedis2 = pool.getResource();   //再次获取            System.out.println(jedis2.get("test"));   //读取操作        } catch (Exception e) {            e.printStackTrace();        }    }}

# Normal Redis instances can't be part of a Redis Cluster; only nodes that are# started as cluster nodes can. In order to start a Redis instance as a# cluster node enable the cluster support uncommenting the following:#cluster-enabled yes

public class Main {    public static void main(String[] args) {        //和客户端一样，随便连一个就行，也可以多写几个，构造方法有很多种可以选择        try(JedisCluster cluster = new JedisCluster(new HostAndPort("192.168.0.8", 6003))){            System.out.println("集群实例数量："+cluster.getClusterNodes().size());            cluster.set("a", "yyds");            System.out.println(cluster.get("a"));        }    }}

@Overridepublic boolean doBorrow(int uid, int bid) {    //1. 判断图书和用户是否都支持借阅，如果此时来了10个线程，都进来了，那么都能够判断为可以借阅    if(bookClient.bookRemain(bid) < 1)        throw new RuntimeException("图书数量不足");    if(userClient.userRemain(uid) < 1)        throw new RuntimeException("用户借阅量不足");    //2. 首先将图书的数量-1，由于上面10个线程同时进来，同时判断可以借阅，那么这个10个线程就同时将图书数量-1，那库存岂不是直接变成负数了？？？    if(!bookClient.bookBorrow(bid))        throw new RuntimeException("在借阅图书时出现错误！");    ...}

setnx key value

set a 666 EX 5 NX

<dependency>    <groupId>org.redisson</groupId>    <artifactId>redisson</artifactId>    <version>3.17.0</version></dependency><dependency>    <groupId>io.netty</groupId>    <artifactId>netty-all</artifactId>    <version>4.1.75.Final</version></dependency>

public static void main(String[] args) {    for (int i = 0; i < 10; i++) {        new Thread(() -> {            try(Jedis jedis = new Jedis("192.168.0.10", 6379)){                for (int j = 0; j < 100; j++) {   //每个客户端获取a然后增加a的值再写回去，如果不加锁那么肯定会出问题                    int a = Integer.parseInt(jedis.get("a")) + 1;                    jedis.set("a", a+"");                }            }        }).start();    }}

public static void main(String[] args) {    Config config = new Config();    config.useSingleServer().setAddress("redis://192.168.0.10:6379");   //配置连接的Redis服务器，也可以指定集群    RedissonClient client =  Redisson.create(config);   //创建RedissonClient客户端    for (int i = 0; i < 10; i++) {        new Thread(() -> {            try(Jedis jedis = new Jedis("192.168.0.10", 6379)){                RLock lock = client.getLock("testLock");    //指定锁的名称，拿到锁对象                for (int j = 0; j < 100; j++) {                    lock.lock();    //加锁                    int a = Integer.parseInt(jedis.get("a")) + 1;                    jedis.set("a", a+"");                    lock.unlock();   //解锁                }            }            System.out.println("结束！");        }).start();    }}

CREATE USER test identified with mysql_native_password by '123456';

sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

# If MySQL is running as a replication slave, this should be# changed. Ref https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_tmpdir# tmpdir                = /tmp## Instead of skip-networking the default is now to listen only on# localhost which is more compatible and is not less secure.# bind-address          = 127.0.0.1    这里注释掉就行

sudo systemctl restart mysql.service

grant replication slave on *.* to test;FLUSH PRIVILEGES;

# The following can be used as easy to replay backup logs or for replication.# note: if you are setting up a replication slave, see README.Debian about#       other settings you may need to change.# 这里需要将server-id配置为其他的值（默认是1）所有Mysql主从实例的id必须唯一，不能打架，不然一会开启会失败server-id               = 2

change replication source to SOURCE_HOST='192.168.0.8',SOURCE_USER='test',SOURCE_PASSWORD='123456',SOURCE_LOG_FILE='binlog.000004',SOURCE_LOG_POS=591;

start replica;

show replica status\G;

use yyds;create table test  (  `id` int primary key,  `name` varchar(255) NULL,  `passwd` varchar(255) NULL);

<dependencies>    <!--  ShardingJDBC依赖，那必须安排最新版啊，希望你们看视频的时候还是5.X版本  -->    <dependency>        <groupId>org.apache.shardingsphere</groupId>        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>        <version>5.1.0</version>    </dependency>      <dependency>        <groupId>org.mybatis.spring.boot</groupId>        <artifactId>mybatis-spring-boot-starter</artifactId>        <version>2.2.2</version>    </dependency>    <dependency>        <groupId>org.projectlombok</groupId>        <artifactId>lombok</artifactId>        <optional>true</optional>    </dependency>    <dependency>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-test</artifactId>        <scope>test</scope>    </dependency></dependencies>

stop replica;

update user set authentication_string='' where user='root';update user set host = '%' where user = 'root';alter user root identified with mysql_native_password by '123456';FLUSH PRIVILEGES;

spring:  shardingsphere:    datasource:      # 有几个数据就配几个，这里是名称，按照下面的格式，名称+数字的形式      names: db0,db1      # 为每个数据源单独进行配置      db0:       # 数据源实现类，这里使用默认的HikariDataSource        type: com.zaxxer.hikari.HikariDataSource        # 数据库驱动        driver-class-name: com.mysql.cj.jdbc.Driver        # 不用我多说了吧        jdbc-url: jdbc:mysql://192.168.0.8:3306/yyds        username: root        password: 123456      db1:        type: com.zaxxer.hikari.HikariDataSource        driver-class-name: com.mysql.cj.jdbc.Driver        jdbc-url: jdbc:mysql://192.168.0.13:3306/yyds        username: root        password: 123456

@Data@AllArgsConstructorpublic class User {    int id;    String name;    String passwd;}

@Mapperpublic interface UserMapper {    @Select("select * from test where id = #{id}")    User getUserById(int id);    @Insert("insert into test(id, name, passwd) values(#{id}, #{name}, #{passwd})")    int addUser(User user);}

spring:  shardingsphere:    rules:      sharding:        tables:          #这里填写表名称，程序中对这张表的所有操作，都会采用下面的路由方案         #比如我们上面Mybatis就是对test表进行操作，所以会走下面的路由方案          test:           #这里填写实际的路由节点，比如现在我们要分两个库，那么就可以把两个库都写上，以及对应的表            #也可以使用表达式，比如下面的可以简写为 db$->{0..1}.test            actual-data-nodes: db0.test,db1.test            #这里是分库策略配置            database-strategy:             #这里选择标准策略，也可以配置复杂策略，基于多个键进行分片              standard:                #参与分片运算的字段，下面的算法会根据这里提供的字段进行运算                sharding-column: id                #这里填写我们下面自定义的算法名称                sharding-algorithm-name: my-alg        sharding-algorithms:         #自定义一个新的算法，名称随意          my-alg:            #算法类型，官方内置了很多种，这里演示最简单的一种            type: MOD            props:              sharding-count: 2    props:     #开启日志，一会方便我们观察      sql-show: true

@SpringBootTestclass ShardingJdbcTestApplicationTests {    @Resource    UserMapper mapper;    @Test    void contextLoads() {        for (int i = 0; i < 10; i++) {            //这里ID自动生成1-10，然后插入数据库            mapper.addUser(new User(i, "xxx", "ccc"));           }    }}

create table test_0  (  `id` int primary key,  `name` varchar(255) NULL,  `passwd` varchar(255) NULL);create table test_1  (  `id` int primary key,  `name` varchar(255) NULL,  `passwd` varchar(255) NULL);

spring:  shardingsphere:    rules:      sharding:        tables:          test:            actual-data-nodes: db0.test_$->{0..1}            #现在我们来配置一下分表策略，注意这里是table-strategy上面是database-strategy            table-strategy:             #基本都跟之前是一样的              standard:                sharding-column: id                sharding-algorithm-name: my-alg        sharding-algorithms:          my-alg:           #这里我们演示一下INLINE方式，我们可以自行编写表达式来决定            type: INLINE            props:              #比如我们还是希望进行模2计算得到数据该去的表             #只需要给一个最终的表名称就行了test_，后面的数字是表达式取模算出的              #实际上这样写和MOD模式一模一样              algorithm-expression: test_$->{id % 2}              #没错，查询也会根据分片策略来进行，但是如果我们使用的是范围查询，那么依然会进行全量查询              #这个我们后面紧接着会讲，这里先写上吧              allow-range-query-with-inline-sharding: false

@SpringBootTestclass ShardingJdbcTestApplicationTests {    @Resource    UserMapper mapper;    @Test    void contextLoads() {        System.out.println(mapper.getUserById(0));        System.out.println(mapper.getUserById(1));    }}

@Select("select * from test where id between #{start} and #{end}")List<User> getUsersByIdRange(int start, int end);

@SpringBootTestclass ShardingJdbcTestApplicationTests {    @Resource    UserMapper mapper;    @Test    void contextLoads() {        System.out.println(mapper.getUsersByIdRange(3, 5));    }}

allow-range-query-with-inline-sharding: true

public static void main(String[] args) {    String uuid = UUID.randomUUID().toString();    System.out.println(uuid);}

ALTER TABLE `yyds`.`test` MODIFY COLUMN `id` bigint NOT NULL FIRST;

@Insert("insert into test(name, passwd) values(#{name}, #{passwd})")int addUser(User user);

spring:  shardingsphere:    datasource:      sharding:        tables:          test:            actual-data-nodes: db0.test,db1.test            #这里还是使用分库策略            database-strategy:              standard:                sharding-column: id                sharding-algorithm-name: my-alg            #这里使用自定义的主键生成策略            key-generate-strategy:              column: id              key-generator-name: my-gen        key-generators:          #这里写我们自定义的主键生成算法          my-gen:           #使用雪花算法            type: SNOWFLAKE            props:              #工作机器ID，保证唯一就行              worker-id: 666        sharding-algorithms:          my-alg:            type: MOD            props:              sharding-count: 2

@SpringBootTestclass ShardingJdbcTestApplicationTests {    @Resource    UserMapper mapper;    @Test    void contextLoads() {        for (int i = 0; i < 20; i++) {            mapper.addUser(new User("aaa", "bbb"));        }    }}

drop table test;

read-only    = 1

sudo systemctl restart mysql.service

change replication source to SOURCE_HOST='192.168.0.13',SOURCE_USER='test',SOURCE_PASSWORD='123456',SOURCE_LOG_FILE='binlog.000007',SOURCE_LOG_POS=19845;start replica;

create table test  (  `id` bigint primary key,  `name` varchar(255) NULL,  `passwd` varchar(255) NULL);

spring:  shardingsphere:    rules:      #配置读写分离      readwrite-splitting:        data-sources:          #名称随便写          user-db:            #使用静态类型，动态Dynamic类型可以自动发现auto-aware-data-source-name，这里不演示            type: Static            props:              #配置写库（只能一个）              write-data-source-name: db0              #配置从库（多个，逗号隔开）              read-data-source-names: db1              #负载均衡策略，可以自定义              load-balancer-name: my-load        load-balancers:          #自定义的负载均衡策略          my-load:            type: ROUND_ROBIN

@SpringBootTestclass ShardingJdbcTestApplicationTests {    @Resource    UserMapper mapper;    @Test    void contextLoads() {        mapper.addUser(new User(10, "aaa", "bbb"));        System.out.println(mapper.getUserById(10));    }}