首先,许多项目都有主库与从库,有的主库后面甚至会有很多个从库,主从库之间的通常同步也很快,这为数据库切库提供了一个基础,因为可以去不同的数据库查询,得到相同的结果(如果不同的数据库是完全不同的,这个不在我们这篇文章讨论的范围之内,那个属于让项目支持多个数据源)
其次,随着项目越来越大、操作的用户越来越多,对数据库的请求操作越来越多,很容易想到的是将读写请求分开,将写请求交给主库处理,读请求直接从某个从库读取。这样可以极大的减少大量对主库的请求,提升主库的性能。
接下来具体说一下如何通过自定义注解完成切库(代码使用springboot实现):
第一步、定义我们自己的切库注解类自定义注解有几点需要注意:
1)@Target 是作用的目标,接口、方法、类、字段、包等等,具体看:ElementType
2)@Retention 是注解存在的范围,RUNTIME代表的是注解会在class字节码文件中存在,在运行时可以通过反射获取到,具体看:RetentionPolicy
3)允许的变量,通常都要给定默认值,比如我们使用一个service时,可以@Service,也可以@Service("xxxx")
@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.METHOD
})
public @interface RoutingDataSource {
String value() default DataSources.MASTER_DB;
}
第二步、定义需要使用的数据库及配置
1、数据库配置:application.properties,这里要注意不同db的前缀区别
## datasource master #
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/master?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=466420182
## datasource slave #
spring.datasourceSlave.type=com.alibaba.druid.pool.DruidDataSource
spring.datasourceSlave.driver-class-name=com.mysql.jdbc.Driver
spring.datasourceSlave.url=jdbc:mysql://localhost:3306/slave?characterEncoding=UTF-8
spring.datasourceSlave.username=root
spring.datasourceSlave.password=466420182
2、定义支持的数据源id:
public interface DataSources {
String MASTER_DB = "masterDB";
String SLAVE_DB = "slaveDB";
}
3、定义数据库实体类并配置为多数据源的形式
这里不要忽略了通过 MapperScan 指定需要扫描的mybatis的接口类
@Configuration
public class DatasourceConfig {
//destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用.
@Bean(destroyMethod = "close", name = DataSources.MASTER_DB)
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}
@Bean(destroyMethod = "close", name = DataSources.SLAVE_DB)
@ConfigurationProperties(prefix = "spring.datasourceSlave")
public DataSource dataSourceSlave() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}
}
4、配置成动态数据源:
@Configuration
@MapperScan(basePackages = {"com.xxx.dao"}) // 这里需要替换为实际的路径
public class MybatisConfig {
@Autowired
@Qualifier(Datasources.MASTER_DB)
private DataSource masterDB;
@Autowired
@Qualifier(DataSources.SLAVE_DB)
private DataSource slaveDB;
/**
* 动态数据源
*/
@Bean(name = "dynamicDataSource")
public DataSource dynamicDataSource() {
DynamicDataSource dynamicDataSource = new DynamicDataSource();
// 默认数据源
dynamicDataSource.setDefaultTargetDataSource(masterDB);
// 配置多数据源
Map<Object, Object> dsMap = Maps.newHashMap();
dsMap.put(DataSources.MASTER_DB, masterDB);
dsMap.put(DataSources.SLAVE_DB, slaveDB);
dynamicDataSource.setTargetDataSources(dsMap);
return dynamicDataSource;
}
@Bean
@ConfigurationProperties(prefix = "mybatis")
public SqlSessionFactoryBean sqlSessionFactoryBean() {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
// 配置数据源,此处配置为关键配置,如果没有将 dynamicDataSource 作为数据源则不能实现切换
sqlSessionFactoryBean.setDataSource(dynamicDataSource());
return sqlSessionFactoryBean;
}
}
第三步、使用ThreadLocal安全的管理当前进程使用的数据源连接
@Slf4j
public class DataSourceContextHolder {
/**
* 默认数据源
*/
public static final String DEFAULT_DATASOURCE = DataSources.MASTER_DB;
private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
// 设置数据源名
public static void setDB(String dbType) {
log.debug("切换到{}数据源", dbType);
contextHolder.set(dbType);
}
// 获取数据源名
public static String getDB() {
return (contextHolder.get());
}
// 清除数据源名
public static void clearDB() {
contextHolder.remove();
}
}
第四步、通过编写切面,对所有我们自定义切库注解的方法进行拦截,动态的选择数据源
这里是为下一步提供铺垫,动态调整DataSourceContextHolder里存储的值,使用threadLocal来管理是为了避免多线程之间互相影响。
自定义注解,核心的处理就是写处理这个注解的逻辑,然后通过指定的拦截方案根据当前的数据做一些动态的处理。比如Spring提供的@Controller、@Service等注解,都是需要我们在配置文件里配置好需要扫描的路径,然后项目启动时,spring根据配置去指定路径读取这些配置,然后这些类才可以被spring进行管理。
这里不要忽略了默认数据源要选择主库,如果切库出现什么问题,比如配置错误等,可以保证访问主库来得到正确的结果;另外,请求完了不要忘记调用提供的clearDB的操作,防止threadLocal误用带来的内存泄露。
@Aspect
@Component
@Slf4j
public class DynamicDataSourceAspect {
@Before("@annotation(RoutingDataSource)")
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_DATASOURCE;
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(RoutingDataSource.class)) {
RoutingDataSource annotation = method.getAnnotation(RoutingDataSource.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
log.error("routing datasource exception, " + methodName, e);
}
// 切换数据源
DataSourceContextHolder.setDB(dataSource);
}
@After("@annotation(RoutingDataSource)")
public void afterSwitchDS(JoinPoint point){
DataSourceContextHolder.clearDB();
}
}
第五步、动态的取出我们在切面里设置的数据源的字符串即可
这里需要把原理介绍一下,在连接数据库时其实是先选择一个配置好的spring管理的datasource的id,就是我们之前在 DatasourceConfig 类里定义的Datasource实体类的id:masterDB 和 slaveDB。然后根据id去spring的上下文选择配置,进行数据库连接。有兴趣的可以看一下源码。
@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
log.debug("数据源为{}", DataSourceContextHolder.getDB());
return DataSourceContextHolder.getDB();
}
}
第六步、取消自动配置数据源,使用我们这里定义的数据源配置
在SpringBoot启动类上通常直接使用@SpringBootApplication就可以了,这里需要调整为:
@SpringBootApplication(exclude = {
DataSourceAutoConfiguration.class
})
使用
如何使用呢,我们简单演示一下:
@Service
public class DataSourceRoutingService {
@Resource
private SysUserMapper sysUserMapper;
@RoutingDataSource(DataSources.MASTER_DB) // 这个注解这时是可以省略,因为默认就是访问主库
public SysUser test1(int id) {
return sysUserMapper.selectByPrimaryKey(id);
}
@RoutingDataSource(DataSources.SLAVE_DB)
public SysUser test2(int id) {
return sysUserMapper.selectByPrimaryKey(id);
}
}
如此,数据库切库就OK了。如果你的系统已经有主库、从库之分了,那么赶紧在你的系统里利用起来吧。
扩展这里呢,还可以支持多个扩展。比如现在一个主库后面有多个从库,在切面拿到需要切换从库时,还可以选择随机选择一个,或者根据类名、方法名或业务配置等选择某一个从库,这样不但可以分担每个从库的压力,也可以有针对性的让指定的读请求打到指定的从库上。如果有多个主库,也可以有更多的选择~
一些其他方面的注意
//指定aop事务执行顺序,已保证在切换数据源的后面
@EnableTransactionManagement(order = 2)
//排除数据源自动配置
@SpringBootApplication(exclude = {
DataSourceAutoConfiguration.class
})
---------------------
/**
* 动态数据源AOP切面
*/
@Aspect
@Order(1)
@Component
public class DynamicDataSourceAspect {
@Around("execution(* com.hunter.nocardpay.*.service..*(..))")
public Object switchDS(ProceedingJoinPoint point) throws Throwable {
Class<?> className = point.getTarget().getClass();
String dataSource = DataSourceConsts.DEFAULT;
if (className.isAnnotationPresent(DS.class)) {
DS ds = className.getAnnotation(DS.class);
dataSource = ds.value();
}else{
// 得到访问的方法对象
String methodName = point.getSignature().getName();
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DS.class)) {
DS annotation = method.getAnnotation(DS.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
}
// 切换数据源
DataSourceContextHolder.setDB(dataSource);
try {
return point.proceed();
} finally {
DataSourceContextHolder.clearDB();
}
}
}
---------------------
---------------------
@Configuration
public class DynamicDataSourceConfiguration {
@Bean(name = "masterDataSource")
@ConfigurationProperties(prefix = "spring.datasource.druid.master")
public DataSource masterDataSource(){
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
dataSource.setName("masterDataSource");
return dataSource;
}
@Bean(name = "slaveDataSource")
@ConfigurationProperties(prefix = "spring.datasource.druid.slave")
public DataSource slaveDataSource(){
DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
dataSource.setName("slaveDataSource");
return dataSource;
}
/**
* 动态数据源: 通过AOP在不同数据源之间动态切换
* @return
*/
@Bean(name = "dynamicDataSource")
public DataSource dataSource() {
DynamicDataSource dynamicDataSource = new DynamicDataSource();
// 默认数据源
dynamicDataSource.setDefaultTargetDataSource(dataSourceOne());
// 配置多数据源
Map<Object, Object> dsMap = new HashMap(2);
dsMap.put("masterDataSource", masterDataSource());
dsMap.put("slaveDataSource", slaveDataSource());
dynamicDataSource.setTargetDataSources(dsMap);
return dynamicDataSource;
}
@Bean
public PlatformTransactionManager txManager(DataSource dynamicDataSource) {
return new DataSourceTransactionManager(dynamicDataSource);
}
@Bean
@ConfigurationProperties(prefix = "mybatis")
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dynamicDataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dynamicDataSource);
return sqlSessionFactoryBean;
}
@Bean
public SqlSessionFactory sqlSessionFactory(SqlSessionFactoryBean sqlSessionFactoryBean) throws Exception {
return sqlSessionFactoryBean.getObject();
}
@Bean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) throws Exception {
SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory); // 使用上面配置的Factory
return template;
}
}
---------------------
读库进行负载均衡
public class RoutingDataSource extends AbstractRoutingDataSource {
private AtomicInteger count = new AtomicInteger(0);
private int readsize;
public RoutingDataSource(int readsize) {
this.readsize = readsize;
}
@Override
protected Object determineCurrentLookupKey() {
String typeKey = DataSourceContextHolder.getJdbcType();
if (typeKey == null) {
logger.error("无法确定数据源");
}
if (typeKey.equals(DataSourceType.WRITE.getType())) {
return DataSourceType.WRITE.getType();
}
//读库进行负载均衡
int a = count.getAndAdd(1);
int lookupkey = a % readsize;
return lookupkey;
}
}
---------------------
public enum DataSourceType {
READ("read", "读库"), WRITE("write", "写库");
private String type;
private String name;
DataSourceType(String type, String name) {
this.type = type;
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
---------------------
@Aspect
@Component
@Order(1)
public class DataSourceAspect {
Logger logger = LoggerFactory.getLogger(getClass());
@Before("execution(* com.qiang..*.*ServiceImpl.find*(..)) " +
"|| execution(* com.qiang..*.*ServiceImpl.count*(..))" +
"|| execution(* com.qiang..*.*ServiceImpl.sel*(..))" +
"|| execution(* com.qiang..*.*ServiceImpl.get*(..))"
)
public void setReadDataSourceType() {
logger.debug("拦截[read]方法");
DataSourceContextHolder.read();
}
@Before("execution(* com.qiang..*.*ServiceImpl.insert*(..)) " +
"|| execution(* com.qiang..*.*ServiceImpl.save*(..))" +
"|| execution(* com.qiang..*.*ServiceImpl.update*(..))" +
"|| execution(* com.qiang..*.*ServiceImpl.set*(..))" +
"|| execution(* com.qiang..*.*ServiceImpl.del*(..))")
public void setWriteDataSourceType() {
logger.debug("拦截[write]操作");
DataSourceContextHolder.write();
}
}
---------------------