[[389704]]

環境：springboot2.2.6RELEASE

實現目標：一寫多讀，讀可以任意配置多個，默認都是從寫庫中進行操作，只有符合條件的方法(指定的目標方法或者標有指定注解的方法才會從讀庫中操作)。獨立打成一個jar包放入本地倉庫。

實現原理：通過aop。

1.pom.xml配置文件

<dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter</artifactId> 
</dependency> 
<dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-data-jpa</artifactId> 
</dependency> 
<dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-configuration-processor</artifactId> 
            <optional>true</optional> 
</dependency> 

 2.application.yml配置文件

pack: 
  datasource: 
    pointcut: execution(public * net.greatsoft.service.base.*.*(..)) || execution(public * net.greatsoft.service.xxx.*.*(..)) 
    master: 
      driverClassName: oracle.jdbc.driver.OracleDriver 
      jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
      username: test 
      password: test 
      minimumIdle: 10 
      maximumPoolSize: 200 
      autoCommit: true 
      idleTimeout: 30000 
      poolName: MbookHikariCP 
      maxLifetime: 1800000 
      connectionTimeout: 30000 
      connectionTestQuery: SELECT 1 FROM DUAL   
    slaves: 
      - driverClassName: oracle.jdbc.driver.OracleDriver 
        jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
        username: dc 
        password: dc 
        minimumIdle: 10 
        maximumPoolSize: 200 
        autoCommit: true 
        idleTimeout: 30000 
        poolName: MbookHikariCP 
        maxLifetime: 1800000 
        connectionTimeout: 30000 
        connectionTestQuery: SELECT 1 FROM DUAL 
      - driverClassName: oracle.jdbc.driver.OracleDriver 
        jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
        username: empi 
        password: empi 
        minimumIdle: 10 
        maximumPoolSize: 200 
        autoCommit: true 
        idleTimeout: 30000 
        poolName: MbookHikariCP 
        maxLifetime: 1800000 
        connectionTimeout: 30000 
        connectionTestQuery: SELECT 1 FROM DUAL 

 pointcut：定義切點，那些方法是需要攔截(從讀庫中操作)。

master：寫庫配置。

slaves：讀庫配置(List集合)。

3.屬性配置類

@Component 
@ConfigurationProperties(prefix = "pack.datasource") 
public class RWDataSourceProperties { 
     
    private String pointcut ; 
    private HikariConfig master ; 
    private List<HikariConfig> slaves = new ArrayList<>(); 
     
} 

 4.讀寫配置類

public class RWConfig  { 
     
    private static Logger logger = LoggerFactory.getLogger(RWConfig.class) ; 
 
    @Bean 
    public HikariDataSource masterDataSource(RWDataSourceProperties rwDataSourceProperties) { 
        return new HikariDataSource(rwDataSourceProperties.getMaster()) ; 
    } 
     
    @Bean 
    public List<HikariDataSource> slaveDataSources(RWDataSourceProperties rwDataSourceProperties) { 
        List<HikariDataSource> lists = new ArrayList<>() ; 
        for(HikariConfig config : rwDataSourceProperties.getSlaves()) { 
            lists.add(new HikariDataSource(config)) ; 
        } 
        return lists ; 
    } 
     
    @Bean 
  @Primary 
    @DependsOn({"masterDataSource", "slaveDataSources"}) 
    public AbstractRoutingDataSource routingDataSource(@Qualifier("masterDataSource")DataSource masterDataSource, 
            @Qualifier("slaveDataSources")List<HikariDataSource> slaveDataSources) { 
        BaseRoutingDataSource ds = new BaseRoutingDataSource() ; 
        Map<Object, Object> targetDataSources = new HashMap<>(2) ; 
        targetDataSources.put("master", masterDataSource) ; 
        for (int i = 0; i < slaveDataSources.size(); i++) { 
            targetDataSources.put("slave-" + i, slaveDataSources.get(i)) ; 
        } 
        ds.setDefaultTargetDataSource(masterDataSource) ; 
        ds.setTargetDataSources(targetDataSources) ; 
        return ds ; 
    } 
     
} 

 5.數據源路由

public class BaseRoutingDataSource extends AbstractRoutingDataSource { 
 
    @Resource 
    private DataSourceHolder holder; 
     
    @Override 
    protected Object determineCurrentLookupKey() { 
        return holder.get() ; 
    } 
     
} 

public class DataSourceHolder { 
     
    private ThreadLocal<Integer> context = new ThreadLocal<Integer>() { 
        @Override 
        protected Integer initialValue() { 
            return 0 ; 
        } 
    }; 
     
    @Resource 
    private BaseSlaveLoad slaveLoad ; 
     
    public String get() { 
        Integer type = context.get() ; 
        return type == null || type == 0 ? "master" : "slave-" + slaveLoad.load() ; 
    } 
     
    public void set(Integer type) { 
        context.set(type) ; 
    } 
     
} 

 通過aop動態設置context的內容值，0為從寫庫中操作，其它的都在讀庫中操作。

BaseSlaveLoad類為到底從那個讀庫中選取的一個算法類，默認實現使用的是輪詢算法。

public interface BaseSlaveLoad { 
 
    int load() ; 
     
} 

public abstract class AbstractSlaveLoad implements BaseSlaveLoad { 
 
    @Resource 
    protected List<HikariDataSource> slaveDataSources ; 
     
} 

 這里定義一個抽象類注入了讀庫列表，所有的實現類從該類中繼承即可。

public class PollingLoad extends AbstractSlaveLoad { 
     
    private int index = 0 ; 
    private int size = 1 ; 
     
    @PostConstruct 
    public void init() { 
        size = slaveDataSources.size() ; 
    } 
     
    @Override 
    public int load() { 
        int n = index ; 
        synchronized (this) { 
            index = (++index) % size ; 
        } 
        return n ; 
    } 
     
} 

 配置成Bean

@Bean 
    @ConditionalOnMissingBean 
    public BaseSlaveLoad slaveLoad() { 
        return new PollingLoad() ; 
    } 
     
    @Bean 
    public DataSourceHolder dataSourceHolder() { 
        return new DataSourceHolder() ; 
    } 

 6.數據源AOP

public class DataSourceAspect implements MethodInterceptor { 
 
    private DataSourceHolder holder ; 
     
    public DataSourceAspect(DataSourceHolder holder) { 
        this.holder = holder ; 
    } 
     
    @Override 
    public Object invoke(MethodInvocation invocation) throws Throwable { 
        Method method = invocation.getMethod() ; 
        String methodName = method.getName() ; 
        SlaveDB slaveDB = method.getAnnotation(SlaveDB.class) ; 
        if (slaveDB == null) { 
            slaveDB = method.getDeclaringClass().getAnnotation(SlaveDB.class) ; 
        } 
        if (methodName.startsWith("find")  
                || methodName.startsWith("get") 
                || methodName.startsWith("query") 
                || methodName.startsWith("select") 
                || methodName.startsWith("list") 
                || slaveDB != null) { 
            holder.set(1) ; 
        } else { 
            holder.set(0) ; 
        } 
        return invocation.proceed(); 
    } 
 
} 

 應該切點需要動態配置，所以這里采用spring aop的方式來配置

@Bean 
    public AspectJExpressionPointcutAdvisor logAdvisor(RWDataSourceProperties props, DataSourceHolder holder) { 
        AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor() ; 
        logger.info("執行表達式：{}", props.getPointcut()) ; 
        advisor.setExpression(props.getPointcut()) ; 
        advisor.setAdvice(new DataSourceAspect(holder)) ; 
        return advisor ; 
    } 

 7.Enable開啟功能

public class RWImportSelector implements ImportSelector { 
 
    @Override 
    public String[] selectImports(AnnotationMetadata importingClassMetadata) { 
        return new String[] {RWConfig.class.getName()} ; 
    } 
 
} 

 這里的RWConfig為我們上面的配置類

@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.TYPE) 
@Documented 
@Import({RWImportSelector.class}) 
public @interface EnableRW { 
} 

@Documented 
@Retention(RUNTIME) 
@Target({ TYPE, METHOD }) 
public @interface SlaveDB { 
} 

 有@SlaveDB的注解方法會類都會從讀庫中操作。

到此讀寫分離組件開發完成。

8.打包安裝到本地倉庫

mvn install -Dmaven.test.skip=true 

9.新建base-web項目

引入依賴

<dependency> 
            <groupId>com.pack</groupId> 
            <artifactId>xg-component-rw</artifactId> 
            <version>1.0.0</version> 
</dependency> 

 啟動類添加注解開啟讀寫分離功能

@SpringBootApplication 
@EnableRW 
public class BaseWebApplication { 
 
    public static void main(String[] args) { 
        SpringApplication.run(BaseWebApplication.class, args); 
    } 
 
} 

 測試：

第一次查詢：

第二次查詢：

為了區別兩個從庫設置不同的數據

這里是寫庫

完畢！！！