第十四篇：Spring Boot+MyBatis配置多數據源

說起多數據源，一般都來用來解決主從模式或者業務比較複雜需要連接不同的分庫來支持業務。本篇文章主要講解後者的模式，利用AOP動態切換來達到項目訪問不同數據源。

構架工程

創建一個springboot工程，在其pom文件加入：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.29</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

禁用默認數據源

首先要將Spring Boot自帶的DataSourceAutoConfiguration禁用，因爲它會讀取application.properties文件的spring.datasource.*屬性並自動配置單數據源。在@SpringBootApplication註解中添加exclude屬性即可

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

配置多數據源連接信息

spring:
  datasource:
    #連接池設置
    type: com.alibaba.druid.pool.DruidDataSource
    initialSize: 1
    minIdle: 1
    maxIdle: 2
    maxActive: 5
    #主數據源
    ds-main:
      url: jdbc:mysql://localhost:3306/multidb1?&useUnicode=true&characterEncoding=utf-8&useSSL=true
      username: root
      password: root
      driverClassName: com.mysql.jdbc.Driver
    #額外數據源1
    ds-1:
      url: jdbc:mysql://localhost:3306/multidb2?&useUnicode=true&characterEncoding=utf-8&useSSL=true
      username: root
      password: root
      driverClassName: com.mysql.jdbc.Driver
mybatis:
  mapper-locations: classpath*:mapper/*.xml
  type-aliases-package: com.chenjie.springboot.learn.entity

創建數據源

由於我們禁掉了自動數據源配置，因些下一步就需要手動將這些數據源創建出來：

@Configuration
public class DataSourceConfig {
    //數據源1
    @Bean(name = "datasource1")
    @ConfigurationProperties(prefix = "spring.datasource.ds-main") // application.properteis中對應屬性的前綴
    public DataSource dataSource1() {
        return DataSourceBuilder.create().build();
    }

    //數據源2
    @Bean(name = "datasource2")
    @ConfigurationProperties(prefix = "spring.datasource.ds-1") // application.properteis中對應屬性的前綴
    public DataSource dataSource2() {
        return DataSourceBuilder.create().build();
    }
}

動態數據源

使用動態數據源的初衷，是能在應用層做到讀寫分離，即在程序代碼中控制不同的查詢方法去連接不同的庫。除了這種方法以外，數據庫中間件也是個不錯的選擇，它的優點是數據庫集羣對應用來說只暴露爲單庫，不需要切換數據源的代碼邏輯。我們通過自定義註解 + AOP的方式實現數據源動態切換。首先定義一個DataSourceContextHolder , 用於保存當前線程使用的數據源名：

public class DataSourceContextHolder {
    private static final Logger logger = LoggerFactory.getLogger(DataSourceContextHolder.class);
    /**
     * 默認數據源
     */
    public static final String DEFAULT_DS = "datasource1";

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    // 設置數據源名
    public static void setDB(String dbType) {
        logger.info("切換到{"+dbType+"}數據源");
        contextHolder.set(dbType);
    }

    // 獲取數據源名
    public static String getDB() {
        return (contextHolder.get());
    }

    // 清除數據源名
    public static void clearDB() {
        contextHolder.remove();
    }
}

然後自定義一個javax.sql.DataSource接口的實現，這裏只需要繼承Spring爲我們預先實現好的父類AbstractRoutingDataSource即可：

public class DynamicDataSource extends AbstractRoutingDataSource {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Override
    protected Object determineCurrentLookupKey() {
        logger.info("數據源爲"+DataSourceContextHolder.getDB());
        return DataSourceContextHolder.getDB();
    }
}

創建動態數據源：
在DataSourceConfig 中添加如下代碼

/**
* 動態數據源: 通過AOP在不同數據源之間動態切換
* @return
*/
@Primary
@Bean(name = "dynamicDataSource")
public DataSource dynamicDataSource() {
   DynamicDataSource dynamicDataSource = new DynamicDataSource();
   // 默認數據源
   dynamicDataSource.setDefaultTargetDataSource(dataSource1());
   // 配置多數據源
   Map<Object, Object> dsMap = new HashMap();
   dsMap.put("datasource1", dataSource1());
   dsMap.put("datasource2", dataSource2());

   dynamicDataSource.setTargetDataSources(dsMap);
   return dynamicDataSource;
}

/**
* 配置@Transactional註解事物
* @return
*/
@Bean
public PlatformTransactionManager transactionManager() {
   return new DataSourceTransactionManager(dynamicDataSource());
}

自定義註釋@DS用於在編碼時指定方法使用哪個數據源：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface DS {
    String value() default "datasource1";
}

編寫AOP切面，實現切換邏輯：

@Aspect
@Component
public class DynamicDataSourceAspect {

    @Before("@annotation(DS)")
    public void beforeSwitchDS(JoinPoint point){
        //獲得當前訪問的class
        Class<?> className = point.getTarget().getClass();
        //獲得訪問的方法名
        String methodName = point.getSignature().getName();
        //得到方法的參數的類型
        Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
        String dataSource = DataSourceContextHolder.DEFAULT_DS;
        try {
            // 得到訪問的方法對象
            Method method = className.getMethod(methodName, argClass);
            // 判斷是否存在@DS註解
            if (method.isAnnotationPresent(DS.class)) {
                DS annotation = method.getAnnotation(DS.class);
                // 取出註解中的數據源名
                dataSource = annotation.value();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 切換數據源
        DataSourceContextHolder.setDB(dataSource);
    }

    @After("@annotation(DS)")
    public void afterSwitchDS(JoinPoint point){
        DataSourceContextHolder.clearDB();
    }
}

完成上述配置後，在先前SqlSessionFactory配置中指定使用DynamicDataSource就可以在Service中愉快的切換數據源了。

Service

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

    //使用數據源1查詢
    @DS("datasource1")
    public List<User> findUserList1(){
        return userMapper.findUserList();
    }
    //使用數據源2查詢
    @DS("datasource2")
    public List<User> findUserList2(){
        return userMapper.findUserList();
    }


    @DS("datasource1")
    public User findUser1(int id) {
        return userMapper.findUser(id);
    }
    @DS("datasource2")
    public User findUser2(int id){
        return userMapper.findUser(id);
    }

    @DS("datasource1")
    public int add1(User user){
        return userMapper.add(user);
    }
    @DS("datasource2")
    public int add2(User user){
       return userMapper.add(user);
    }
    @DS("datasource1")
    public int delete1(int id){
        return userMapper.delete(id);
    }
    @DS("datasource2")
    public int delete2(int id){
        return userMapper.delete(id);
    }
    @DS("datasource1")
    public int update1(User user){
        return userMapper.update(user);
    }
    @DS("datasource2")
    public int update2(User user){
        return userMapper.update(user);
    }
}

Controller

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping(value = "/list")
    public List<User> findUserList() {
        return userService.findUserList1();
    }

    @GetMapping(value = "/{id}")
    public User findUser(@PathVariable("id") int id) {
        return userService.findUser1(id);
    }

    @PutMapping(value = "/{id}")
    public String updateAccount(@PathVariable("id") int id, @RequestParam(value = "name", required = true) String name,
                                @RequestParam(value = "age", required = true) int age) {
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAge(age);
        if (0 < userService.update1(user)) {
            return "success";
        } else {
            return "fail";
        }
    }

    @DeleteMapping(value = "/{id}")
    public String delete(@PathVariable(value = "id") int id) {
        if (0 < userService.delete1(id)) {
            return "success";
        } else {
            return "fail";
        }
    }

    @PostMapping(value = "/add")
    public String postAccount(@RequestParam(value = "id") int id, @RequestParam(value = "name") String name,
                              @RequestParam(value = "age") int age) {
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAge(age);
        if (0 < userService.add1(user)) {
            return "success";
        } else {
            return "fail";
        }
    }

    @GetMapping(value = "/db2/list")
    public List<User> findUserList2() {
        return userService.findUserList2();
    }

    @GetMapping(value = "/db2/{id}")
    public User findUser2(@PathVariable("id") int id) {
        return userService.findUser2(id);
    }

    @PutMapping(value = "/db2/{id}")
    public String updateAccount2(@PathVariable("id") int id, @RequestParam(value = "name", required = true) String name,
                                @RequestParam(value = "age", required = true) int age) {
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAge(age);
        if (0 < userService.update2(user)) {
            return "success";
        } else {
            return "fail";
        }
    }

    @DeleteMapping(value = "/db2/{id}")
    public String delete2(@PathVariable(value = "id") int id) {
        if (0 < userService.delete2(id)) {
            return "success";
        } else {
            return "fail";
        }
    }

    @PostMapping(value = "/db2/add")
    public String postAccount2(@RequestParam(value = "id") int id, @RequestParam(value = "name") String name,
                              @RequestParam(value = "age") int age) {
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAge(age);
        if (0 < userService.add2(user)) {
            return "success";
        } else {
            return "fail";
        }
    }
}

測試

數據源切換成功

源碼下載：https://github.com/chenjary/SpringBoot