2. 程式人生 > 程式設計 >使用springboot aop來實現讀寫分離和事物配置

使用springboot aop來實現讀寫分離和事物配置

阿新 • • 發佈：2020-04-27

什麼事讀寫分離

讀寫分離，基本的原理是讓主資料庫處理事務性增、改、刪操作（INSERT、UPDATE、DELETE），而從資料庫處理SELECT查詢操作。資料庫複製被用來把事務性操作導致的變更同步到叢集中的從資料庫。

為什麼要實現讀寫分離

增加冗餘

增加了機器的處理能力

對於讀操作為主的應用，使用讀寫分離是最好的場景，因為可以確保寫的伺服器壓力更小，而讀又可以接受點時間上的延遲。

實現

本文介紹利用spring aop來動態切換資料來源來實現讀寫分離。

先建一個maven專案，匯入springBoot依賴。

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>1.5.2.RELEASE</version>
</parent>

<dependencies>
 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
 </dependency>
 <!--mybatis-->
 <dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>1.3.1</version>
 </dependency>
 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
 <!-- druid -->
 <dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>${druid.version}</version>
 </dependency>
 <!-- mysql connector-->
 <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>${mysql-connector.version}</version>
 </dependency>

 <!--test-->
 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
 </dependency>

</dependencies>

然後在配置檔案application.yml中自定義資料來源配置項

server:
 port: 8080
logging:
 level:
 org.springframework: INFO
 com.qiang: DEBUG
spring:
 output:
 ansi:
  enabled: always
 datasource:
 type: com.alibaba.druid.pool.DruidDataSource
 driver-class-name: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3306/db_area?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
 username: root
 password: root
 db:
 readsize: 2
 read0:
  type: com.alibaba.druid.pool.DruidDataSource
  driver-class-name: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://localhost:3306/db_area?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
  username: root
  password: root

 read1:
  type: com.alibaba.druid.pool.DruidDataSource
  driver-class-name: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://localhost:3306/db_area?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
  username: root
  password: root
 aop:
 auto: true
 proxy-target-class: true

配置Druid

package com.qiang.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

/**
 * @author gengqiang
 * @date 2018/5/3
 */
@Configuration
public class DruidConfig {

 private Logger logger = LoggerFactory.getLogger(DruidConfig.class

 /**
  * 主據源
  * @return
  */
 @Primary
 @Bean(name = "dataSource")
 @ConfigurationProperties(prefix = "spring.datasource")
 public DataSource dataSource() {
  return DataSourceBuilder.create().type(com.alibaba.druid.pool.DruidDataSource.class).build();

 }

 /**
  * 從資料來源1
  * @return
  */
 @Bean(name = "readDataSource0")
 @ConfigurationProperties(prefix = "spring.db.read0")
 public DataSource readDataSource0() {
  return DataSourceBuilder.create().type(com.alibaba.druid.pool.DruidDataSource.class).build();

 }
 /**
  * 從資料來源2
  * @return
  */
 @Bean(name = "readDataSource1")
 @ConfigurationProperties(prefix = "spring.db.read1")
 public DataSource readDataSource1() {
  return DataSourceBuilder.create().type(com.alibaba.druid.pool.DruidDataSource.class).build();

 }

}

配置Mybaits

package com.qiang.config;

import com.qiang.config.db.DataSourceType;
import com.qiang.config.db.RoutingDataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import javax.sql.DataSource;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author gengqiang
 * @date 2018/5/3
 */
@Configuration
@EnableTransactionManagement(order = 2)
@MapperScan(basePackages = {"com.qiang.demo.mapper"})
public class MybatisConfig implements TransactionManagementConfigurer,ApplicationContextAware {


 private static ApplicationContext context;


 /**
  * 寫庫資料來源
  */
 @Autowired
 private DataSource dataSource;

 /**
  * 讀資料來源數量
  */
 @Value("${spring.db.readsize}")
 private Integer readsize;
 /**
  * 資料來源路由代理
  *
  * @return
  */

 @Bean
 public AbstractRoutingDataSource routingDataSouceProxy() {
  RoutingDataSource proxy = new RoutingDataSource(readsize);
  Map<Object,Object> targetDataSources = new HashMap<>(readsize + 1);
  targetDataSources.put(DataSourceType.WRITE.getType(),dataSource);
  for (int i = 0; i < readsize; i++) {
   DataSource d = context.getBean("readDataSource" + i,DataSource.class);
   targetDataSources.put(i,d);
  }
  proxy.setDefaultTargetDataSource(dataSource);
  proxy.setTargetDataSources(targetDataSources);
  return proxy;
 }

 @Bean
 @ConditionalOnMissingBean
 public SqlSessionFactoryBean sqlSessionFactory() throws IOException {
  SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  bean.setDataSource(routingDataSouceProxy());
  bean.setVfs(SpringBootVFS.class);
  bean.setTypeAliasesPackage("com.qiang");
  Resource configResource = new ClassPathResource("/mybatis-config.xml");
  bean.setConfigLocation(configResource);
  ResourcePatternResolver mapperResource = new PathMatchingResourcePatternResolver();
  bean.setMapperLocations(mapperResource.getResources("classpath*:mapper/**/*.xml"));
  return bean;
 }

 @Override
 public PlatformTransactionManager annotationDrivenTransactionManager() {
  return new DataSourceTransactionManager(routingDataSouceProxy());
 }

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  if (context == null) {
   context = applicationContext;
  }
 }
}

其中實現資料來源切換的功能就是自定義一個類擴充套件AbstractRoutingDataSource抽象類，就是程式碼中的定義的RoutingDataSource，其實該相當於資料來源DataSourcer的路由中介，可以實現在專案執行時根據相應key值切換到對應的資料來源DataSource上。

RoutingDataSource.class

package com.qiang.config.db;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 資料來源路由
 *
 * @author gengqiang
 */
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;
 }

}

其中用到了2個輔助類

package com.qiang.config.db;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 全域性資料來源
 *
 * @author gengqiang
 */
public class DataSourceContextHolder {

 private static Logger logger = LoggerFactory.getLogger(DataSourceContextHolder.class);

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

 public static ThreadLocal<String> getLocal() {
  return local;
 }

 public static void read() {
  logger.debug("切換至[讀]資料來源");
  local.set(DataSourceType.READ.getType());
 }

 public static void write() {
  logger.debug("切換至[寫]資料來源");
  local.set(DataSourceType.WRITE.getType());
 }

 public static String getJdbcType() {
  return local.get();
 }

}
package com.qiang.config.db;

/**
 * @author gengqiang
 */
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;
 }
}

最後通過aop設定切面，攔截讀寫來動態的設定資料來源

package com.qiang.config.aop;

import com.qiang.config.db.DataSourceContextHolder;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 攔截資料庫讀寫
 *
 * @author gengqiang
 */

@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();
 }

}

主要的程式碼就寫好了，下面來測試一下是否讀寫分離。

寫一個測試類：

package com.qiang;

import com.qiang.demo.entity.Area;
import com.qiang.demo.service.AreaService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author gengqiang
 * @date 2018/5/4
 */

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestApplication {

 @Autowired
 private AreaService areaService;


 @Test
 public void test() {
  Area area = new Area();
  area.setDistrictId("0000");
  area.setName("test");
  area.setParentId(0);
  area.setLevel(1);
  areaService.insert(area);
 }

 @Test
 public void test2() {
  areaService.selectByPrimaryKey(1);
 }
}

其中第一個測試插入資料，第二個測試查詢。

第一測試結果：

使用springboot aop來實現讀寫分離和事物配置

第二個測結果：

使用springboot aop來實現讀寫分離和事物配置

從結果看出來第一個走的寫資料來源，就是主資料來源，第二個的走讀資料來源，就是從資料來源。

然後我們在測試一下事物，看遇到異常是否會滾。

測試：

 @Test
 public void contextLoads() throws Exception {
  try {
   areaService.insertBack();

  } catch (Exception e) {
//   e.printStackTrace();
  }
  System.out.println(areaService.count(new Area()));

 }

其中service：

@Override
@Transactional(rollbackFor = Exception.class)
public void insertBack() {
 Area area = new Area();
 area.setDistrictId("0000");
 area.setName("test");
 area.setParentId(0);
 area.setLevel(1);
 mapper.insert(area);
 throw new RuntimeException();
}

方法上加@Transactional，宣告一個事物。

使用springboot aop來實現讀寫分離和事物配置

看一下執行結果，雖然執行插入的時候，sql是運行了，但最後查詢的時候數量為0，說明會滾了。

配置事物

使用springboot aop來實現讀寫分離和事物配置

第一步需要加一個註解@EnableTransactionManagement，後面的引數是為了區分aop和事物執行的順序。

然後在需要會滾的方法上加一個註解@Transactional。

原始碼地址

以上這篇使用springboot aop來實現讀寫分離和事物配置就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援我們。

相關推薦

使用springboot aop來實現讀寫分離和事物配置

什麼事讀寫分離 讀寫分離，基本的原理是讓主資料庫處理事務性增、改、刪操作（INSERT、UPDATE、DELETE），而從資料庫處理SELECT查詢操作。資料庫複製被用來把事務性操作導致的變更同步到叢集中的從資料庫。

SpringBoot整合MyCat實現讀寫分離的方法

MyCat一個徹底開源的，面向企業應用開發的大資料庫叢集。基於阿里開源的Cobar產品而研發。能滿足資料庫資料大量儲存；提高了查詢效能。文章介紹如何實現MyCat連線MySQL實現主從分離，並整合SpringBoot實現讀寫分離。

基於springboot的mysql實現讀寫分離

前言: 首先思考一個問題:在高併發的場景中,關於資料庫都有哪些優化的手段？常用的有以下的實現方法:讀寫分離、加快取、主從架構叢集、分庫分表等，在網際網路應用中,大部分都是讀多寫少的場景,設定兩個庫,主庫和讀庫

SpringBoot-整合-MyCat-實現讀寫分離，老師講的真棒

SpringBoot-整合-MyCat-實現讀寫分離，老師講的真棒 *************************** 1. row ***************************

SpringBoot-整合-MyCat-實現讀寫分離，mongodb視訊教程

+----------------------------------+--------+ 4 rows in set (0.00 sec) #### 修改表儲存引擎 如果是slave資料庫的表是MyISAM，master資料庫的表是InnoDB。直接覆蓋master資料庫來同步資料的話，slave資料庫表

如何利用MHA+ProxySQL實現讀寫分離和負載均衡

摘要：本文分享一下“MHA+中介軟體ProxySQL”如何來實現讀寫分離+負載均衡的相關知識。

springboot實現讀寫分離

配置： application.yml spring: datasource: ####寫資料來源 update: jdbc-url: jdbc:mysql://192.168.100.150:8066/test

Springboot + Mysql8實現讀寫分離功能

在實際的生產環境中，為了確保資料庫的穩定性，我們一般會給資料庫配置雙機熱備機制，這樣在master資料庫崩潰後，slave資料庫可以立即切換成主資料庫，通過主從複製的方式將資料從主庫同步至從庫，在業務程式碼中編寫

Spring Boot 結合 aop 實現讀寫分離

前言 入職新公司到現在也有一個月了，完成了手頭的工作，前幾天終於有時間研究下公司舊專案的程式碼。在研究程式碼的過程中，發現專案裡用到了Spring Aop來實現資料庫的讀寫分離，本著自己愛學習(我自己都不信…)的性

二、Mybatis結合外掛實現讀寫分離（動態切換資料來源）、Aop切面使用註解實現動態資料來源配置

（一）使用Mybatis外掛 在繼承之上修改，使用Mybatis外掛（上一篇文章基礎上修改：一、springboot druid連線池實現多資料來源動態切換方式（繼承介面：AbstractRoutingDataSource） - 程式碼紅了一大片 - 部落格園 (

springboot + mybatis + Sharding-JDBC實現讀寫分離

一、引入maven依賴，具體版本大家可根據自己實際需要選擇，我這邊使用的是4.0.0-RC1版本

Mycat分散式資料庫架構解決方案--Mycat實現讀寫分離

echo編輯整理，歡迎轉載，轉載請宣告文章來源。歡迎新增echo微信(微訊號：t2421499075)交流學習。 百戰不敗，依不自稱常勝，百敗不頹，依能奮力前行。——這才是真正的堪稱強大！！！

利用MySQL主從配置實現讀寫分離減輕資料庫壓力

大型網站為了軟解大量的併發訪問，除了在網站實現分散式負載均衡，遠遠不夠。到了資料業務層、資料訪問層，如果還是傳統的資料結構，或者只是單單靠一臺伺服器扛，如此多的資料庫連線操作，資料庫必然會崩潰，資料丟

Django連線資料庫並實現讀寫分離過程解析

這篇文章主要介紹了Django連線資料庫並實現讀寫分離過程解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Django學習之完成資料庫主從複製、讀寫分離和一主多從情況下的使用辦法

1.首先配置多個數據庫，在settings配置檔案中配置以下內容： DATABASES = { \'default\': { #預設資料庫，配置多個mysql資料也是ok的，混用資料庫也是ok的

Mycat實現讀寫分離

Mycat是什麼？ Mycat 是資料庫中介軟體。主要是做資料分散式儲存，也有Atlas普通版的讀寫分離功能，其最重要還是分散式

Sharding-JDBC實現讀寫分離

參考資料：猿天地 https://mp.weixin.qq.com/s/kp2lJHpTMz4bDWkJYjVbOQ作者：尹吉歡 技術選型：SpringBoot +Sharding-JDBC +MyBatis

MySQL實現讀寫分離

一、MySQL讀寫分離 1.1 原理 讀寫分離就是隻在主伺服器上寫，只在從伺服器上讀

mysql實現讀寫分離、主從複製的配置方法

1. 測試環境 　　master：192.168.1.109 　　slave：192.168.1.118 2. 配置主伺服器 　　2.1修改 /etc/my.cnf 配置檔案，增加如下內容：

Mysql1 mysql主從同步，django實現讀寫分離

MySql主從同步(基於docker) 主從配置原理 # 1 主從同步的原理 mysql主從配置的流程大體如圖：