导航：首页 > 互联网科技 >

mysql 中怎么区分读写分离数据源

发表于：2025-02-03 作者：千家信息网编辑

千家信息网最后更新 2025年02月03日，mysql 中怎么区分读写分离数据源，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。AOP中的@Aspect用法，用于监控程序的执行方

千家信息网最后更新 2025年02月03日mysql 中怎么区分读写分离数据源

mysql 中怎么区分读写分离数据源，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

AOP中的@Aspect用法，用于监控程序的执行方法

Spring使用的AOP注解分为三个层次：

前提条件是在xml中放开了

1、@Aspect放在类头上，把这个类作为一个切面。

2、 @Pointcut放在方法头上，定义一个可被别的方法引用的切入点表达式。

3、5种通知。

3.1、@Before，前置通知，放在方法头上。

3.2、@After，后置【finally】通知，放在方法头上。

3.3、@AfterReturning，后置【try】通知，放在方法头上，使用returning来引用方法返回值。

3.4、@AfterThrowing，后置【catch】通知，放在方法头上，使用throwing来引用抛出的异常。

3.5、@Around，环绕通知，放在方法头上，这个方法要决定真实的方法是否执行，而且必须有返回值。

@Component
@Aspect
public class LogAspect {
/**
* 定义Pointcut，Pointcut的名称就是simplePointcut，此方法不能有返回值，该方法只是一个标示
*/
@Pointcut("execution(public * com.service.impl..*.*(..))")
public void recordLog() {
}
@AfterReturning(pointcut = "recordLog()")
public void simpleAdvice() {
LogUtil.info("AOP后处理成功 ");
}
@Around("recordLog()")
public Object aroundLogCalls(ProceedingJoinPoint jp) throws Throwable {
LogUtil.info("正常运行");
return jp.proceed();
}
@Before("recordLog()")
public void before(JoinPoint jp) {
String className = jp.getThis().toString();
String methodName = jp.getSignature().getName(); // 获得方法名
LogUtil.info("位于：" + className + "调用" + methodName + "()方法-开始！");
Object[] args = jp.getArgs(); // 获得参数列表
if (args.length <= 0) {
LogUtil.info("====" + methodName + "方法没有参数");
} else {
for (int i = 0; i < args.length; i++) {
LogUtil.info("====参数 " + (i + 1) + "：" + args[i]);
}
}
LogUtil.info("=====================================");
}
@AfterThrowing("recordLog()")
public void catchInfo() {
LogUtil.info("异常信息");
}
@After("recordLog()")
public void after(JoinPoint jp) {
LogUtil.info("" + jp.getSignature().getName() + "()方法-结束！");
LogUtil.info("=====================================");
}
}

细节介绍：

@AspectJ的详细用法
在spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：

一些常见的切入点的例子
execution(public * * (. .)) 任意公共方法被执行时，执行切入点函数。
execution( * set* (. .)) 任何以一个"set"开始的方法被执行时，执行切入点函数。
execution( * com.demo.service.AccountService.* (. .)) 当接口AccountService 中的任意方法被执行时，执行切入点函数。
execution( * com.demo.service.. (. .)) 当service 包中的任意方法被执行时，执行切入点函数。 within(com.demo.service.) 在service 包里的任意连接点。 within(com.demo.service. .) 在service 包或子包的任意连接点。
this(com.demo.service.AccountService) 实现了AccountService 接口的代理对象的任意连接点。
target(com.demo.service.AccountService) 实现了AccountService 接口的目标对象的任意连接点。
args(Java.io.Serializable) 任何一个只接受一个参数，且在运行时传入参数实现了 Serializable 接口的连接点
增强的方式：
@Before：方法前执行
@AfterReturning：运行方法后执行
@AfterThrowing：Throw后执行
@After：无论方法以何种方式结束，都会执行（类似于finally）
@Around：环绕执行

======================================mysql读写分离数据源配置================================

前文中 mysql3009是主库可以写入操作而mysql3008只能进行读取操作

本文利用 AbstractRoutingDatasource实现业务代码中动态的选择读取或写入操作的数据源

pom.xml

org.springframework.boot
spring-boot-starter-parent
2.0.1.RELEASE

org.springframework.boot
spring-boot-starter-aop

org.springframework.boot
spring-boot-starter-web

org.mybatis.spring.boot
mybatis-spring-boot-starter
1.3.2

mysql
mysql-connector-java
runtime

org.springframework.boot
spring-boot-starter-test
test

com.alibaba
druid
1.0.23

org.springframework.boot
spring-boot-maven-plugin

1创建读写数据源
配置application.yml

spring:
datasource:
update:
jdbc-url: jdbc:mysql://192.168.43.66:8066/mycat_testdb
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
select:
jdbc-url: jdbc:mysql://192.168.43.66:8066/mycat_testdb
driver-class-name: com.mysql.jdbc.Driver
username: user
password: user
type: com.alibaba.druid.pool.DruidDataSource
其中 jdbc-url为mycat配置的虚拟数据库

用户root有写入权限 user为只读权限详细参照mycat的server.xml文件配置

DatasourceConfig

@Configuration
public class DatasourceConfig {

@Bean
@ConfigurationProperties(prefix="spring.datasource.select")
public DataSource selectDataSource(){
return DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties(prefix="spring.datasource.update")
public DataSource updateDataSource(){
return DataSourceBuilder.create().build();
}
}
DataSourceContextHolder 用于获取当前线程数据源并设置

@Component
public class DataSourceContextHolder {

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

// 设置数据源类型
public static void setDbType(String dbType) {
contextHolder.set(dbType);
}

public static String getDbType() {
return contextHolder.get();
}

public static void clearDbType() {
contextHolder.remove();
}

}
2将数据源注册到AbstractRoutingDataSource
@Primary
@Component
public class DynamicDatasource extends AbstractRoutingDataSource{
@Autowired
@Qualifier("selectDataSource")
private DataSource selectDataSource;
@Autowired
@Qualifier("updateDataSource")
private DataSource updateDataSource;

@Override
protected Object determineCurrentLookupKey() {
String dbType = DataSourceContextHolder.getDbType();
System.out.println("当前数据源类型是："+dbType);
return dbType;
}

/**
* 配置数据源信息
*/
@Override
public void afterPropertiesSet() {
Map map = new HashMap<>();
map.put("selectDataSource", selectDataSource);
map.put("updateDataSource", updateDataSource);
setTargetDataSources(map);
setDefaultTargetDataSource(updateDataSource);
super.afterPropertiesSet();
}

}
注意注入读写数据源时要使用@qualifier注解指定注入数据源不然会报错同时类上要加上@primary 首选加载此类

3AOP拦截业务逻辑方法，通过方法名前缀判断是读还是写操作
@Aspect
@Component
public class DataSourceAop {

@Pointcut("execution(* com.xuxu.service.*.*(..))")
public void cutPoint(){

}

@Before("cutPoint()")
public void process(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
if (methodName.startsWith("get") || methodName.startsWith("count") || methodName.startsWith("find")
|| methodName.startsWith("list") || methodName.startsWith("select") || methodName.startsWith("check")) {
DataSourceContextHolder.setDbType("selectDataSource");
} else {
// 切换dataSource
DataSourceContextHolder.setDbType("updateDataSource");
}

}
}

测试
mapper
@Mapper
public interface UserMapper {

@Insert("insert into test (id) values(#{id})")
public int insert(@Param("id") Integer id);

@Select("select * from test")
public List getAll();

@Update("update test set id=#{id} where id=#{targetId}")
public int update(@Param("targetId") Integer targetId,@Param("id") Integer id);
}
service
@Service
public class TestDatasourceService {
@Autowired
private UserMapper userMapper;

public int insert(Integer id){
return userMapper.insert(id);
}

public List getAll(){
return userMapper.getAll();
}

public int update(Integer targetId,Integer id){
return userMapper.update(targetId, id);
}
}
controller
@RestController
public class TestDatasourceController {
@Autowired
private TestDatasourceService testService;

@RequestMapping("/insert/{id}")
public int insert(@PathVariable Integer id){
return testService.insert(id);
}
@RequestMapping("/get")
public List getAll(){
return testService.getAll();
}
@RequestMapping("/update")
public int update(Integer targetId,Integer id){
return testService.update(targetId, id);
}
}