<dependencies>
 
        <!--SpringBoot集成Aop起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
 
        <!--SpringBoot集成WEB起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <!--mybatis集成SpringBoot起步依賴-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
 
        <!--MySQL驅(qū)動(dòng)-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
 
        <!--SpringBoot單元測(cè)試依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
 
 </dependencies>

spring:
  datasource:
      #主數(shù)據(jù)源
      master:
        name: test
        jdbc-url: jdbc:mysql://xxxxxx:3306/test?allowMultiQueries=true&useSSL=false&useUnicode=true&characterEncoding=utf-8
        username: root
        password: xxxxxx
        driver-class-name: com.mysql.cj.jdbc.Driver
        hikari:
          maximum-pool-size: 20
          max-lifetime: 30000
          idle-timeout: 30000
          data-source-properties:
            prepStmtCacheSize: 250
            prepStmtCacheSqlLimit: 2048
            cachePrepStmts: true
            useServerPrepStmts: true
      #從數(shù)據(jù)源
      slave:
        name: test
        jdbc-url: jdbc:mysql://xxxxxx:3306/test?allowMultiQueries=true&useSSL=false&useUnicode=true&characterEncoding=utf-8
        username: root
        password: xxxxxx
        driver-class-name: com.mysql.cj.jdbc.Driver
        hikari:
          maximum-pool-size: 20
          max-lifetime: 30000
          idle-timeout: 30000
          data-source-properties:
            prepStmtCacheSize: 250
            prepStmtCacheSqlLimit: 2048
            cachePrepStmts: true
            useServerPrepStmts: true
 
#MyBatis：
# mapper-locations: classpath:mapper/*.xml
#  type-aliases-package: com.hs.demo.entity

package com.hs.demo.config;
 
/**
 * Enum類，定義主庫(kù)從庫(kù)兩個(gè)數(shù)據(jù)源
 */
public enum DBTypeEnum {
 
    MASTER, SLAVE;
}

package com.hs.demo.config;
 
/**
 *ThreadLocal定義數(shù)據(jù)源切換，通過(guò)ThreadLocal將數(shù)據(jù)源綁定到每個(gè)線程上下文中
 */
public class DBContextHolder {
 
    /**
     * ThreadLocal 不是 Thread，是一個(gè)線程內(nèi)部的數(shù)據(jù)存儲(chǔ)類，通過(guò)它可以在指定的線程中存儲(chǔ)數(shù)據(jù)，對(duì)數(shù)據(jù)存儲(chǔ)后，只有在線程中才可以獲取到存儲(chǔ)的數(shù)據(jù)，對(duì)于其他線程來(lái)說(shuō)是無(wú)法獲取到數(shù)據(jù)。
     * 大致意思就是ThreadLocal提供了線程內(nèi)存儲(chǔ)變量的能力，這些變量不同之處在于每一個(gè)線程讀取的變量是對(duì)應(yīng)的互相獨(dú)立的，通過(guò)get和set方法就可以得到當(dāng)前線程對(duì)應(yīng)的值。
     */
    private static final ThreadLocal<DBTypeEnum> contextHolder = new ThreadLocal<>();
 
    public static void set(DBTypeEnum dbTypeEnum){
        contextHolder.set(dbTypeEnum);
    }
 
    public static DBTypeEnum get() {
        return contextHolder.get();
    }
 
    public static void master() {
        set(DBTypeEnum.MASTER);
        System.out.println("--------以下操作為master（寫操作）--------");
    }
 
    public static void slave() {
        set(DBTypeEnum.SLAVE);
        System.out.println("--------以下操作為slave（讀操作）--------");
    }
 
    public static void clear() {
        contextHolder.remove();
    }
}

package com.hs.demo.config;
 
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.lang.Nullable;
 
/**
 *  重寫路由選擇類：獲取當(dāng)前線程上綁定的路由key
 */
public class MyRoutingDataSource extends AbstractRoutingDataSource {
 
    /**
     * determineCurrentLookupKey()方法決定使用哪個(gè)數(shù)據(jù)源、
     * 根據(jù)Key獲取數(shù)據(jù)源的信息，上層抽象函數(shù)的鉤子
     */
    @Nullable
    @Override
    protected Object determineCurrentLookupKey() {
        return DBContextHolder.get();
    }
}

package com.hs.demo.config;
 
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
 
/**
 * 增加了 DataSourceConfig 這個(gè)配置文件之后,需要添加Hikari連接池，單數(shù)據(jù)源自動(dòng)裝載時(shí)不會(huì)出這 
 * 樣的問(wèn)題
 *
 * @Configuration 注解，表明這就是一個(gè)配置類,指示一個(gè)類聲明一個(gè)或者多個(gè)@Bean 聲明的方法并且由Spring容器統(tǒng)一管理，以便在運(yùn)行時(shí)為這些bean生成bean的定義和服務(wù)請(qǐng)求的類。
 */
@Configuration
public class DataSourceConfig {
 
    /**
     * 注入主庫(kù)數(shù)據(jù)源
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
 
        return DataSourceBuilder.create().build();
 
        //DataSourceProperties properties放在方法參數(shù)里
//        return DataSourceBuilder.create(properties.getClassLoader())
//                .type(HikariDataSource.class)
//                .driverClassName(properties.getDriverClassName())
//                .url(properties.getUrl())
//                .username(properties.getUsername())
//                .password(properties.getPassword())
//                .build();
    }
 
    /**
     * 注入從庫(kù)數(shù)據(jù)源
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
 
        return DataSourceBuilder.create().build();
    }
 
 
    /**
     * 配置選擇數(shù)據(jù)源
     * @param masterDataSource
     * @param slaveDataSource
     * @return DataSource
     */
    @Bean
    public DataSource myRoutingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slaveDataSource") DataSource slaveDataSource)
    {
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put(DBTypeEnum.MASTER, masterDataSource);
        targetDataSource.put(DBTypeEnum.SLAVE, slaveDataSource);
 
        MyRoutingDataSource myRoutingDataSource = new MyRoutingDataSource();
        //找不到用默認(rèn)數(shù)據(jù)源
        myRoutingDataSource.setDefaultTargetDataSource(masterDataSource);
        //可選擇目標(biāo)數(shù)據(jù)源
        myRoutingDataSource.setTargetDataSources(targetDataSource);
 
        return myRoutingDataSource; 
    }
}

package com.hs.demo.config;
 
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.annotation.Resource;
import javax.sql.DataSource;
 
/**
 * 配置Mybatis指定數(shù)據(jù)源:SqlSessionFactory和事務(wù)管理器
 */
@Configuration
@EnableTransactionManagement
public class MyBatisConfig {
 
    /**
     * 注入自己重寫的數(shù)據(jù)源
     */
    @Resource(name = "myRoutingDataSource")
    private DataSource myRoutingDataSource;
 
    /**
     * 配置SqlSessionFactory
     * @return SqlSessionFactory
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception
    {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(myRoutingDataSource);
 
        //ResourcePatternResolver(資源查找器)定義了getResources來(lái)查找資源
        //PathMatchingResourcePatternResolver提供了以classpath開(kāi)頭的通配符方式查詢,否則會(huì)調(diào)用ResourceLoader的getResource方法來(lái)查找
//        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
//        sqlSessionFactoryBean.setMapperLocations(resolver.getResources(mapperLocation));
 
        return sqlSessionFactoryBean.getObject();
    }
 
 
    /**
     * 事務(wù)管理器，不寫則事務(wù)不生效：事務(wù)需要知道當(dāng)前使用的是哪個(gè)數(shù)據(jù)源才能進(jìn)行事務(wù)處理
     */
    @Bean
    public PlatformTransactionManager platformTransactionManager() {
        return new DataSourceTransactionManager(myRoutingDataSource);
    }
 
//    /**
//     * 當(dāng)自定義數(shù)據(jù)源，用戶必須覆蓋SqlSessionTemplate,開(kāi)啟BATCH處理模式
//     *
//     * @param sqlSessionFactory
//     * @return
//     */
//    @Bean
//    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
//        return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
//    }
 
}

package com.hs.demo.config;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
 
/**
 * 默認(rèn)情況下，所有的查詢都走從庫(kù)，插入/修改/刪除走主庫(kù)。我們通過(guò)方法名來(lái)區(qū)分操作類型（CRUD）
 *
 * 切面不能建立在DAO層，事務(wù)是在service開(kāi)啟的，到dao層再切換數(shù)據(jù)源，那事務(wù)就廢了
 *
 */
@Aspect
@Component
public class DataSourceAop {
 
    /**
     * 第一個(gè)”*“符號(hào)	表示返回值的類型任意；
     * com.sample.service.impl	AOP所切的服務(wù)的包名，即，我們的業(yè)務(wù)部分
     * 包名后面的”..“	表示當(dāng)前包及子包
     * 第二個(gè)”*“	表示類名，*即所有類。此處可以自定義，下文有舉例
     * .*(..)	表示任何方法名，括號(hào)表示參數(shù)，兩個(gè)點(diǎn)表示任何參數(shù)類型
     */
    @Pointcut("!@annotation(com.hs.demo.config.Master) " +
            "&& (execution(* com.hs.demo.service.*.select*(..)) " +
            "|| execution(* com.hs.demo.service..*.find*(..)))")
    public void readPointcut() {
 
    }
 
    @Pointcut("@annotation(com.hs.demo.config.Master) " +
            "|| execution(* com.hs.demo.service..*.save*(..)) " +
            "|| execution(* com.hs.demo.service..*.add*(..)) " +
            "|| execution(* com.hs.demo.service..*.insert*(..)) " +
            "|| execution(* com.hs.demo.service..*.update*(..)) " +
            "|| execution(* com.hs.demo.service..*.edit*(..)) " +
            "|| execution(* com.hs.demo..*.delete*(..)) " +
            "|| execution(* com.hs.demo..*.remove*(..))")
    public void writePointcut() {
 
    }
 
    @Before("readPointcut()")
    public void read(JoinPoint jp) {
 
        //獲取當(dāng)前的方法信息
        MethodSignature methodSignature = (MethodSignature) jp.getSignature();
        Method method = methodSignature.getMethod();
 
        //判斷方法上是否存在注解@Master
        boolean present = method.isAnnotationPresent(Master.class);
        if (!present)
        {
            //如果不存在，默認(rèn)走從庫(kù)讀
            DBContextHolder.slave();
        }
        else
        {
            //如果存在，走主庫(kù)讀
            DBContextHolder.master();
        }
 
    }
 
    @Before("writePointcut()")
    public void write() {
        DBContextHolder.master();
    }
 
 
    /**
     * 另一種寫法：if...else...  判斷哪些需要讀從數(shù)據(jù)庫(kù)，其余的走主數(shù)據(jù)庫(kù)
     */
//    @Before("execution(* com.cjs.example.service.impl.*.*(..))")
//    public void before(JoinPoint jp) {
//        String methodName = jp.getSignature().getName();
//
//        if (StringUtils.startsWithAny(methodName, "get", "select", "find")) {
//            DBContextHolder.slave();
//        }else {
//            DBContextHolder.master();
//        }
//    }
 
}

package com.hs.demo.config;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 有時(shí)候主從延遲，需要強(qiáng)制讀主庫(kù)的注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Master
{
    //設(shè)置數(shù)據(jù)源類型
   //String value();
}

package com.hs.demo.entity;
 
import lombok.Data;
 
/**
 * @author heshi
 * @date 2021/10/20 15:14
 */
 
@Data
public class UserEntity {
 
    private Integer user_id;
    private String account;
    private String nickname;
    private String password;
    private String headimage_url;
    private String introduce;
}

package com.hs.demo.mapper;
 
import com.hs.demo.entity.UserEntity;
import org.apache.ibatis.annotations.*;
 
import java.util.List;
 
/**
 * Spring通過(guò)@Mapper注解實(shí)現(xiàn)動(dòng)態(tài)代理，mybatis會(huì)自動(dòng)創(chuàng)建Dao接口的實(shí)現(xiàn)類代理對(duì)象注入IOC容器進(jìn)行管理，這樣就不用編寫Dao層的實(shí)現(xiàn)類
 *
 */
@Mapper
public interface UserMapper {
 
    @Select("SELECT * FROM user")  //使用@Select、@Insert等注解方式來(lái)實(shí)現(xiàn)對(duì)應(yīng)的持久化操作，使得我們可以不配置XML格式的Mapper文件
    List<UserEntity> findAll();
 
    @Insert("insert into user(account,nickname,password) values(#{account}, #{nickname}, #{password})")
    int insert(UserEntity user);
 
    @Update("UPDATE user SET account=#{account},nickname=#{nickname} WHERE id =#{id}")
    void update(UserEntity user);
 
    @Delete("DELETE FROM user WHERE id =#{id}")
    void delete(Long id);
}

package com.hs.demo.service;
 
import com.hs.demo.entity.UserEntity;
import com.hs.demo.mapper.UserMapper;
import com.hs.demo.mysql.Master;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
 
/**
 * @author heshi
 * @date 2021/10/21 10:36
 */
 
@Service
public class UserService {
 
    @Autowired
    UserMapper userMapper;
 
//    @Master
    public List<UserEntity> findAll()
    {
        List<UserEntity> userEntities = userMapper.findAll();
        return userEntities;
    }
 
    public int insertUser(UserEntity user)
    {
        int i = userMapper.insert(user);
        return i;
    }
 
//    void update(UserEntity user);
//
//    void delete(Long id);
 
}

package com.hs.demo.controller;
 
import com.hs.demo.entity.UserEntity;
import com.hs.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
@RestController
public class UserController
{
    @Autowired
    UserService userService;
 
    @RequestMapping("/listUser")
    public List<UserEntity>  listUser()
    {
        List<UserEntity> users = userService.findAll();
        return users;
    }
 
    @RequestMapping("/insertUser")
    public void insertUser()
    {
       UserEntity userEntity = new UserEntity();
       userEntity.setAccount("22222");
       userEntity.setNickname("hshshs");
       userEntity.setPassword("123");
       userService.insertUser(userEntity);
    }
}