zoukankan      html  css  js  c++  java
  • 原理解密 → Spring AOP 实现动态数据源(读写分离),底层原理是什么

    开心一刻

      女孩睡醒玩手机,收到男孩发来一条信息:我要去跟我喜欢的人表白了!
      女孩的心猛的一痛,回了条信息:去吧,祝你好运!
      男孩回了句:但是我没有勇气说不来,怕被打!
      女孩:没事的,我相信你!此时女孩已经伤心的流泪了
      男孩:我已经到她家门口了,不敢敲门!
      女孩擦了擦眼泪:不用怕,你是个好人,会有好报的!
      男孩:那你来开下门吧,我在你家门口!
      女孩不敢相信,赶紧跑去开门,看到他的那一刻伤心的泪水变成了感动
      男孩拿出手里那束玫瑰花说:你姐姐在家吗?

    前情回归

      一般来讲,读写分离无非两种实现方式。第一种是依靠数据库中间件(比如:MyCat),也就是说应用程序连接到中间件,中间件帮我们做读写分离;第二种是应用程序自己做读写分离,结合 Spring AOP 实现读写分离

      数据库中间件的方式不做过多的阐述(谁让你是配角!),有兴趣的可以去查看

        Mycat - 实现数据库的读写分离与高可用

        Mycat - 高可用与负载均衡实现,满满的干货!

       spring集成mybatis实现mysql读写分离,简单介绍了通过 Spring AOP 从应用程序层面实现读写分离;读写分离效果是达到了,可我们知道为什么那么做就能实现读写分离吗 ?知道的请快点走开

      接下来请好好欣赏我的表演

    原理解密

      我们逐个讲解其中涉及的点,然后串起来理解读写分离的底层原理

      Spring AOP

        AOP:Aspect Oriented Program

        关于 Spring AOP,相信大家耳熟能详,它是对 OOP 的一种补充,OOP 是纵向的,AOP 则是横向的

        

        如上图所示,OOP 属于一种纵向拓展,AOP 则是一种横向拓展。AOP 依托于 OOP,将公共功能代码抽象出来作为一个切面,减少重复代码量,降低耦合

        AOP 的底层实现是动态代理,具体的表现形式粗略如下

        

        对 Spring AOP 有个大致了解了,我们就可以接着往下看了 

      Spring 数据源

        无论是 Spring JDBC,还是 Hibernate,亦或是 MyBatis,其实都是对 JDBC 的封装;对于JDBC,我们不要太熟,大体流程如下

        

        然而,在实际应用中,我们往往不会直接使用 JDBC,而是使用 ORM,ORM 会封装上述的流程,也就说我们不再需要关注了;MyBatis 使用步骤大致如下

        

        我们以 SpringBoot + pagehelper + Druid(ssm) 为例,来看看具体是怎么获取 Connection 对象的

        

        可以看到,如果事务管理器中存在 Connection 对象,则直接返回,否则从数据源中获取返回(同时也赋值给了事务管理器);当取到 Connection 对象后,后续的流程大家就非常清楚了

        然而我们不需要关注 Connection 对象,只需要关注数据源,为什么呢 ? 因为我们的配置文件中配置的是数据源而不是 Connection,是不是很有道理 ?

      ThreadLocal

        如果我们需要在各层之间进行参数的传递,实现方式有哪些 ?

        最常见的方式可能就是方法参数,但还有一种容易忽略的方式:ThreadLocal,可以在当前线程内传递参数,减少方法的参数个数

        关于 ThreadLocal,有兴趣的可以查看:结合ThreadLocal来看spring事务源码,感受下清泉般的洗涤!

      当我们熟悉上面的三点后,后面的就好理解了,接着往下看

      动态数据源

        一个数据源只能对应一个数据库,如果我们有多个数据库(一主多从),那么就需要配置多个数据源,类似如下

        <!-- 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>
    View Code

        可是事务管理器中只有一个数据源的引用

        

        那怎么对应我们配置文件中的多个数据源呢 ?其实,我们可以自定义一个类 DynamicDataSource 来实现 DataSource,DynamicDataSource 中存储我们配置的多数据源,然后将 DynamicDataSource 的实例配置给事务管理器;当从事务管理器获取 Connection 对象的时候,会从 DynamicDataSource 实例获取,然后再由 DynamicDataSource 根据 routeKey 路由到某个具体的数据源,从中获取 Connection;大体流程如下

        

        Spring 也考虑到了这一点,提供了一个抽象类:AbstractRoutingDataSource,DynamicDataSource 继承它可以为我们省非常多的代码

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

        配置文件中增加如下配置

    <!-- 动态数据源,根据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>
    View Code

        但是问题又来了,这个 routeKey 怎么处理,也就说 DynamicDataSource 怎么知道用哪个数据源 ? AbstractRoutingDataSource 提供了一个方法: determineCurrentLookupKey 我们只需要实现它,DynamicDataSource 就知道是使用哪个 lookupKey (routeKey 在 Spring 中的命名)了;determineCurrentLookupKey 具体该如何实现了,我们可以结合 ThreadLocal 来实现;整个流程大致如下

        

        一旦我们在切面中指定了 lookupKey,那么后续就会使用 lookupKey 对应的数据源来操作数据库了

      自此,相信大家已经明白了动态数据源的底层原理

    总结

      Spring AOP → 将我们指定的 lookupKey 放入 ThreadLocal

      ThreadLocal → 线程内共享 lookupKey

      DynamicDataSource → 对多数据源进行封装,根据 ThreadLocal 中的 lookupKey 动态选择具体的数据源

      如果我们对其中的某个环节不懂,可以试着删掉它,然后看这个流程能否正常串起来,这样就能明白各个环节的作用了

      Springboot 版示例代码:spring-boot-dynamic-DataSource

    悬念

      Spring AOP 实现多数据源,是否与 Spring 事务冲突 ,若冲突了该如何解决 ?

    参考

      什么是面向切面编程AOP?

      Spring AOP就是这么简单啦

  • 相关阅读:
    总结Linq或者lamdba的写法
    JObject 用法 、JProperty 用法、JArray 用法 Linq 转 Json
    System.DateTime.Now 24小时制。
    将springboot jar应用打包成镜像并在docker运行成容器
    RPC框架——简单高效hessian的使用方式
    WebService—规范介绍和几种实现WebService的框架介绍
    Java三大体系JavaEE、JavaSE、JavaME的区别
    JavaEE体系架构
    JavaEE 技术体系
    注解之@CookieValue
  • 原文地址:https://www.cnblogs.com/youzhibing/p/11965210.html
Copyright © 2011-2022 走看看