MyCat执行原理分析与初始Sharding-Jdbc进行读写分离读取master数据库-CFANZ编程社区

http://localhost:9002/findUser

application.yml 配置信息

server:
  port: 9002
mybatis-plus:
#  mapper-locations: classpath*:/mapper/*.xml
  global-config:
    db-config:
      column-underline: true
#shardingjdbc配置      
sharding:
  jdbc:
    data-sources:
     ###配置第一个从数据库
      ds_slave_0:
        password: 123456
        jdbc-url: jdbc:mysql://192.168.184.128:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
        driver-class-name: com.mysql.jdbc.Driver
        username: root
      ###主数据库配置  
      ds_master:
        password: 123456
        jdbc-url: jdbc:mysql://192.168.184.129:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
        driver-class-name: com.mysql.jdbc.Driver
        username: root
    ###配置读写分离    application.yml
    master-slave-rule:
    ###配置从库选择策略，提供轮询与随机，这里选择用轮询
      load-balance-algorithm-type: round_robin
      ####指定从数据库
      slave-data-source-names: ds_slave_0
      name: ds_ms
      ####指定主数据库
      master-data-source-name: ds_master

读取ds_master主数据源和读写分离配置ShardingDataSourceConfig

import java.sql.SQLException;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.google.common.collect.Maps;

import io.shardingjdbc.core.api.MasterSlaveDataSourceFactory;
import lombok.extern.log4j.Log4j2;

@Configuration
@EnableConfigurationProperties(ShardingMasterSlaveConfig.class)
@Log4j2
// 读取ds_master主数据源和读写分离配置
@ConditionalOnProperty({ "sharding.jdbc.data-sources.ds_master.jdbc-url",
    "sharding.jdbc.master-slave-rule.master-data-source-name" })
public class ShardingDataSourceConfig {

  @Autowired
  private ShardingMasterSlaveConfig shardingMasterSlaveConfig;

  @Bean
  public DataSource masterSlaveDataSource() throws SQLException {
    final Map<String, DataSource> dataSourceMap = Maps.newHashMap();
    dataSourceMap.putAll(shardingMasterSlaveConfig.getDataSources());
    final Map<String, Object> newHashMap = Maps.newHashMap();
    // 创建 MasterSlave数据源
    DataSource dataSource = MasterSlaveDataSourceFactory.createDataSource(dataSourceMap,
        shardingMasterSlaveConfig.getMasterSlaveRule(), newHashMap);
    log.info("masterSlaveDataSource config complete");
    return dataSource;
  }

}

ShardingMasterSlaveConfig配置多个数据源

import java.util.HashMap;
import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;

import com.zaxxer.hikari.HikariDataSource;

import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
import lombok.Data;

@Data
@ConfigurationProperties(prefix = "sharding.jdbc")
public class ShardingMasterSlaveConfig {

  // 存放本地多个数据源
  private Map<String, HikariDataSource> dataSources = new HashMap<>();

  private MasterSlaveRuleConfiguration masterSlaveRule;
}

UserController

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.mayikt.entity.UserEntity;
import com.mayikt.service.UserService;

@RestController
public class UserController {

  @Autowired
  private UserService userService;

  @RequestMapping("/findUser")
  public List<UserEntity> findUser() {
    return userService.findUser();
  }

  @RequestMapping("/insertUser")
  public List<UserEntity> insertUser(String userName) {
    return userService.insertUser(userName);
  }
  @RequestMapping("/insert")
  public List<UserEntity> insert () {
    UserEntity  user=new UserEntity()  ;
    for(int  i=1;i<121;i++) {
  
      user.setId(i);
      user.setName("name"+i);
      user.setUserName("userName"+i);
      userService.insert(user);
    }
    return userService.insert(user);
  }
}

UserEntity实体类学习

public class UserEntity {

  private String userName;
   
  private int id;
  private String name;
  public String getUserName() {
    return userName;
  }
  public void setUserName(String userName) {
    this.userName = userName;
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }


}

UserMapper 逻辑处理类

import java.util.List;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import com.mayikt.entity.UserEntity;

public interface UserMapper {
  @Select("SELECT * FROM  t_user ")
  public List<UserEntity> findUser();

  @Select("insert into t_user(id, userName,name) values (2,#{userName},#{userName}); ")
  @Options(useGeneratedKeys = true, keyProperty = "id")
  public List<UserEntity> insertUser(@Param("userName") String userName);
  
  @Select("insert into t_user(id, userName,name) values (#{id},#{userName},#{userName}); ")
  @Options(useGeneratedKeys = true, keyProperty = "id")
  public List<UserEntity> insert (UserEntity userEntity);
  
  
  
}

UserService 服务层进行逻辑处理

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.mayikt.entity.UserEntity;
import com.mayikt.mapper.UserMapper;

@Service
public class UserService {
  @Autowired
  private UserMapper userMapper;

  public List<UserEntity> findUser() {
    return userMapper.findUser();
  }

  public List<UserEntity> insertUser(String userName) {
    return userMapper.insertUser(userName);
  }
  public List<UserEntity> insert(UserEntity userName) {
    return userMapper.insert(userName);
  }


}

SpringBoot逻辑主类

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.mapper")
public class AppMybatis {

  public static void main(String[] args) {
    SpringApplication.run(AppMybatis.class, args);
  
  }

}

pom.xml的配置导入类型

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com</groupId>
  <artifactId>sharding-jdbc</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.3.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
  </parent>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

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

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.0-beta</version>
    </dependency>
    <dependency>
      <groupId>io.shardingjdbc</groupId>
      <artifactId>sharding-jdbc-core</artifactId>
      <version>2.0.3</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>

  </build>

</project>