Un exemple d'analyse sur la façon dont Spring intègre mybatis pour réaliser la séparation de la lecture et de l'écriture de la base de données MySQL

Cet article présente Spring pour intégrer mybatis pour réaliser la séparation de la lecture et de l'écriture de la base de données MySQL à travers un exemple de code. Les amis qui en ont besoin peuvent s'y référer

Avant-propos<.>

Une fois que les utilisateurs du site Web atteignent une certaine taille, la base de données devient le goulot d'étranglement du site Web en raison d'une pression de charge excessive. Heureusement, la plupart des bases de données grand public actuelles offrent une fonction de secours maître-esclave. En configurant la relation maître-esclave entre deux bases de données, les mises à jour des données d'une base de données peuvent être synchronisées avec celles de l'autre serveur. Le site Web utilise cette fonction de la base de données pour réaliser la séparation de la lecture et de l'écriture de la base de données, améliorant ainsi la pression de charge de la base de données. Comme le montre la figure ci-dessous :

Lorsque le serveur d'application écrit des données, il accède à la base de données maître. La base de données maître synchronise les mises à jour des données avec la base de données esclave via le maître-esclave. mécanisme de réplication, de sorte que lorsque l'application Lorsque le serveur lit les données, elle puisse obtenir les données de la base de données. Afin de faciliter l'accès des programmes d'application à la base de données séparée en lecture-écriture, un module d'accès à la base de données spécial est généralement utilisé dans le serveur d'applications pour rendre la séparation en lecture-écriture de la base de données transparente pour l'application.

Ce blog vise à implémenter un "module spécial d'accès à la base de données" pour rendre la séparation de la lecture et de l'écriture de la base de données transparente pour l'application. De plus, pour la réplication maître-esclave de la base de données mysql, vous pouvez vous référer à mon installation et à la réplication maître-esclave de mysql5.7.18. Notez que la base de données doit implémenter la réplication maître-esclave avant que la base de données puisse être séparée de la lecture et de l'écriture. Par conséquent, si vous n'avez pas implémenté la réplication maître-esclave dans la base de données, n'oubliez pas d'implémenter d'abord la réplication maître-esclave dans la base de données

.

pour configurer la lecture et l'écriture Source de données (base de données maître-esclave)

 

mysqldb.properties

#主数据库数据源
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.0.4:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=123456
jdbc.initialSize=1
jdbc.minIdle=1
jdbc.maxActive=20
jdbc.maxWait=60000
jdbc.removeAbandoned=true
jdbc.removeAbandonedTimeout=180
jdbc.timeBetweenEvictionRunsMillis=60000
jdbc.minEvictableIdleTimeMillis=300000
jdbc.validationQuery=SELECT 1
jdbc.testWhileIdle=true
jdbc.testOnBorrow=false
jdbc.testOnReturn=false
#从数据库数据源
slave.jdbc.driverClassName=com.mysql.jdbc.Driver
slave.jdbc.url=jdbc:mysql://192.168.0.221:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false
slave.jdbc.username=root
slave.jdbc.password=123456
slave.jdbc.initialSize=1
slave.jdbc.minIdle=1
slave.jdbc.maxActive=20
slave.jdbc.maxWait=60000
slave.jdbc.removeAbandoned=true
slave.jdbc.removeAbandonedTimeout=180
slave.jdbc.timeBetweenEvictionRunsMillis=60000
slave.jdbc.minEvictableIdleTimeMillis=300000
slave.jdbc.validationQuery=SELECT 1
slave.jdbc.testWhileIdle=true
slave.jdbc.testOnBorrow=false
slave.jdbc.testOnReturn=false

Base de données maître et esclave N'oubliez pas de changer l'adresse par la vôtre, le numéro de compte et le mot de passe doivent également être modifiés par les vôtres, d'autres éléments de configuration peuvent être définis par vous-même, le cas échéant < ; 🎜>

mybatis-spring.xml

AOP réalise une commutation dynamique des sources de données

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx.xsd">
  <!-- master数据源 -->
  <bean id="masterDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <!-- 基本属性 url、user、password --> 
    <property name="driverClassName" value="${jdbc.driverClassName}" /> 
    <property name="url" value="${jdbc.url}" /> 
    <property name="username" value="${jdbc.username}" /> 
    <property name="password" value="${jdbc.password}" /> 
    <property name="initialSize" value="${jdbc.initialSize}" /> 
    <property name="minIdle" value="${jdbc.minIdle}" />  
    <property name="maxActive" value="${jdbc.maxActive}" /> 
    <property name="maxWait" value="${jdbc.maxWait}" />
    <!-- 超过时间限制是否回收 -->
    <property name="removeAbandoned" value="${jdbc.removeAbandoned}" />
    <!-- 超过时间限制多长； -->
    <property name="removeAbandonedTimeout" value="${jdbc.removeAbandonedTimeout}" />
    <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}" />
    <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}" />
    <!-- 用来检测连接是否有效的sql，要求是一个查询语句-->
    <property name="validationQuery" value="${jdbc.validationQuery}" />
    <!-- 申请连接的时候检测 -->
    <property name="testWhileIdle" value="${jdbc.testWhileIdle}" />
    <!-- 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
    <property name="testOnBorrow" value="${jdbc.testOnBorrow}" />
    <!-- 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
    <property name="testOnReturn" value="${jdbc.testOnReturn}" />
  </bean>
  <!-- slave数据源 -->
  <bean id="slaveDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${slave.jdbc.driverClassName}" /> 
    <property name="url" value="${slave.jdbc.url}" /> 
    <property name="username" value="${slave.jdbc.username}" /> 
    <property name="password" value="${slave.jdbc.password}" /> 
    <property name="initialSize" value="${slave.jdbc.initialSize}" /> 
    <property name="minIdle" value="${slave.jdbc.minIdle}" />  
    <property name="maxActive" value="${slave.jdbc.maxActive}" /> 
    <property name="maxWait" value="${slave.jdbc.maxWait}" />
    <property name="removeAbandoned" value="${slave.jdbc.removeAbandoned}" />
    <property name="removeAbandonedTimeout" value="${slave.jdbc.removeAbandonedTimeout}" />
    <property name="timeBetweenEvictionRunsMillis" value="${slave.jdbc.timeBetweenEvictionRunsMillis}" />
    <property name="minEvictableIdleTimeMillis" value="${slave.jdbc.minEvictableIdleTimeMillis}" />
    <property name="validationQuery" value="${slave.jdbc.validationQuery}" />
    <property name="testWhileIdle" value="${slave.jdbc.testWhileIdle}" />
    <property name="testOnBorrow" value="${slave.jdbc.testOnBorrow}" />
    <property name="testOnReturn" value="${slave.jdbc.testOnReturn}" />
  </bean>
  <!-- 动态数据源，根据service接口上的注解来决定取哪个数据源 -->
  <bean id="dataSource" class="com.yzb.util.DynamicDataSource"> 
    <property name="targetDataSources">   
     <map key-type="java.lang.String">   
       <!-- write or slave -->  
       <entry key="slave" value-ref="slaveDataSource"/>   
       <!-- read or master  --> 
       <entry key="master" value-ref="masterDataSource"/>   
     </map>        
    </property>  
    <property name="defaultTargetDataSource" ref="masterDataSource"/>   
  </bean>
  <!-- Mybatis文件 -->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="configLocation" value="classpath:mybatis-config.xml" /> 
    <property name="dataSource" ref="dataSource" />
    <!-- 映射文件路径 -->
    <property name="mapperLocations" value="classpath*:dbmappers/*.xml" />
  </bean>
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.yzb.dao" />
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
  </bean>
  <!-- 事务管理器 -->
  <bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
  </bean>
  <!-- 声明式开启 -->
  <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" order="1"/>
  <!-- 为业务逻辑层的方法解析@DataSource注解 为当前线程的HandleDataSource注入数据源 -->  
  <bean id="dataSourceAspect" class="com.yzb.util.DataSourceAspect" />  
  <aop:config proxy-target-class="true">  
    <aop:aspect id="dataSourceAspect" ref="dataSourceAspect" order="2">  
      <aop:pointcut id="tx" expression="execution(* com.yzb.service.impl..*.*(..)) "/>  
      <aop:before pointcut-ref="tx" method="before" />        
    </aop:aspect>  
  </aop:config>
</beans>

DataSource.java

DataSourceAspect.java

package com.yzb.util;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/** 
 * RUNTIME 
 * 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。 
 * 
 */ 
@Retention(RetentionPolicy.RUNTIME) 
@Target(ElementType.METHOD) 
public @interface DataSource
{
  String value();
}

DynamicDataSource.java

package com.yzb.util;
import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
public class DataSourceAspect
{
  /**
   * 在dao层方法获取datasource对象之前，在切面中指定当前线程数据源
   */
  public void before(JoinPoint point)
  {
    Object target = point.getTarget();
    String method = point.getSignature().getName();
    Class<?>[] classz = target.getClass().getInterfaces();            // 获取目标类的接口， 所以@DataSource需要写在接口上
    Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())
        .getMethod().getParameterTypes();
    try
    {
      Method m = classz[0].getMethod(method, parameterTypes);
      if (m != null && m.isAnnotationPresent(DataSource.class))
      {
        DataSource data = m.getAnnotation(DataSource.class);
        System.out.println("用户选择数据库库类型：" + data.value());
        HandleDataSource.putDataSource(data.value());            // 数据源放到当前线程中
      }
    } catch (Exception e)
    {
      e.printStackTrace();
    }
  }
  }

HandleDataSource.java

package com.yzb.util;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class DynamicDataSource extends AbstractRoutingDataSource
{
  /**
   * 获取与数据源相关的key 此key是Map<String,DataSource> resolvedDataSources 中与数据源绑定的key值
   * 在通过determineTargetDataSource获取目标数据源时使用
   */
  @Override
  protected Object determineCurrentLookupKey()
  {
    return HandleDataSource.getDataSource();
  }
}

Appliquer @DataSource sur l'interface du service pour spécifier la source de données

package com.yzb.util;
public class HandleDataSource
{
  public static final ThreadLocal<String> holder = new ThreadLocal<String>();
  /**
   * 绑定当前线程数据源
   * 
   * @param key
   */
  public static void putDataSource(String datasource)
  {
    holder.set(datasource);
  }
  /**
   * 获取当前线程的数据源
   * 
   * @return
   */
  public static String getDataSource()
  {
    return holder.get();
  }
}

package com.yzb.service;
import java.util.List;
import com.yzb.model.Person;
import com.yzb.util.DataSource;
public interface IPersonService {
  /**
   * 加载全部的person
   * @return
   */
  List<Person> listAllPerson();
  /**
   * 查询某个人的信息
   * @param personId
   * @return
   */
  @DataSource("slave")      // 指定使用从数据源
  Person getPerson(int personId);
  boolean updatePerson(Person person);
}

Notes Lors des tests, comment savez-vous que vous lisez dans la base de données ? Nous pouvons modifier la valeur d'un certain champ de l'enregistrement interrogé dans la base de données pour distinguer les bases de données maître et esclave

Nous devons faire attention aux transactions et essayer de garantir que les transactions sont effectuées sur une seule source de données ;

Lorsqu'il y a plusieurs aops sur un service, vous devez faire attention à l'ordre de tissage des aop et utiliser le mot-clé order pour contrôler l'ordre de tissage

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!