mysql读写分离

最新推荐文章于 2022-06-19 00:28:21 发布

才子花花

最新推荐文章于 2022-06-19 00:28:21 发布

阅读量278

点赞数

分类专栏： mysql 文章标签： mysql

本文链接：https://blog.youkuaiyun.com/UserBeanClass/article/details/79356055

版权

mysql 专栏收录该内容

3 篇文章

订阅专栏

mysql 读写分离实现原理和代码实例

首先我们闭上眼睛想一想，我们为什么要使用读写分离？使用了有什么好处和坏处。
一、mysql 读写分离的原理：
简单的说就是以前我们操作数据库在同一个库中，如果用户访问量大，对一个数据库中的一张表出现查询，修改，新增等操作，就有可能出现幻读，甚至在高并发的情况下服务器就会蹦掉。
为了减轻数据库的操作的压力，我们再这里使用个数据库分别为master（主-写库）slaver(从-读库)；用master库做update,insert,delete,用slaver库做select，然后将master库同步到slaver库（这里使用主从复制—详见下篇博客）！
这里写图片描述
读写分离的优点：
1. 在数据一致性要求不高的情况可以使用读写分离，达到提高吞吐量，提升查询性能；
2. 提高机器的性能；

基于spring+mybatis+maven 中读写分离的配置和代码实现
原理示意图
这里写图片描述
AOP切面是是基于server层之前对访问方法进行判断，是走读库还是写库，如果是select，find,get就进入slaver读库，如果是insert，update,delete就进入master写库

代码实现

DynamicDataSource

/**
 * 定义数据源这里由spring提高的AbstractRoutingDataSource,实现determineCurrentLookupKey方法
 * 由于DynamicDataSource是单例，线程不安全，所以采用ThreadLocal保证线程安全，由DBContextHolder完成
 *
 */
public class DynamicDataSource extends AbstractRoutingDataSource{  

    @Override  
    protected Object determineCurrentLookupKey() {  
        return DBContextHolder.getDBType(); 
    }  
}

DBContextHolder

public class DBContextHolder{  
    //写库对应的key
    public static final String DATA_SOURCE_MASTER = "master";  
    //读库对应的key
    public static final String DATA_SOURCE_SLAVER = "slaver";  
    //使用threadLocal记录当前线程的数据源key  
    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<String>();  
    //设置数据源key  
    public static void setDBType(String dbType) {  
        THREAD_LOCAL.set(dbType);  
    }  
    //获取数据源key  
    public static String getDBType() {  
        return THREAD_LOCAL.get();  
    }  

    public static void clearDBType() {  
        THREAD_LOCAL.remove();  
    }  
}

DataSourceAspect

/**
 * 定义数据源的AOP切面，通过该Service的方法名判断是应该走读库还是写库
 * 
 */
public class DataSourceAspect {

    /**
     * 在进入Service方法之前执行
     * 
     * @param point 切面对象
     */
    public void before(JoinPoint point) {
        // 获取到当前执行的方法名
        String methodName = point.getSignature().getName();
        if (isSlave(methodName)) {
            // 标记为读库
            DBContextHolder.setDBType(DBContextHolder.DATA_SOURCE_SLAVER);
        } else {
            // 标记为写库
            DBContextHolder.setDBType(DBContextHolder.DATA_SOURCE_MASTER);
        }
    }

    /**
     * 判断是否为读库
     * 
     * @param methodName
     * @return
     */
    private Boolean isSlave(String methodName) {
        // 方法名以query、find、get开头的方法名走从库
        Boolean falg= StringUtils.startsWithAny(methodName, "query", "find", "get","select");
        return falg;
    }

}

—-配置实现—–
首先在jdbc.properties中配置两个数据源

#写数据库
jdbc.master.driver=com.mysql.jdbc.Driver
jdbc.master.url=jdbc:mysql://localhost:3306/base_station_management?useSSL=false
jdbc.master.username=root
jdbc.master.password=1234

#读数据库
jdbc.slaver.driver=com.mysql.jdbc.Driver
jdbc.slaver.url=jdbc:mysql://192.168.0.223:1024/base_station_management?useSSL=false
jdbc.slaver.username=amplifi
jdbc.slaver.password=Cc8EY9T6IPNko8XioPqvWg==

#connection pool settings
# maxIdle是最大的空闲连接数，这里取值为20，表示即使没有数据库连接时依然可以保持20个空闲的连接，它们不会被清除，随时处于待命状态
jdbc.pool.maxIdle=20
# maxActive是最大激活连接数，这里取值为190，表示同时最多有190个数据库连接
jdbc.pool.maxActive=190

jdbc.initialSize=5
jdbc.maxActive=20
jdbc.maxIdle=5
jdbc.defaultAutoCommit=true
jdbc.removeAbandoned=true  
jdbc.removeAbandonedTimeout=30 
jdbc.logAbandoned=true
#\u4e3b\u52a8\u68c0\u6d4b\u8fde\u63a5\u6c60\u662f\u5426\u6709\u6548
jdbc.testWhileIdle=true
#jdbc.validationQuery=select 1 from dual 
jdbc.timeBetweenEvictionRunsMillis=30000
jdbc.numTestsPerEvictionRun=10

在applicationContext.xml中定义链接池

<context:component-scan base-package="main.java.com.lxg.*" />

    <!-- 配置写数据源  -->
    <bean id="dbPasswordCallbackMaster" class="main.java.com.lxg.spring.mybatis.DBPwdUtil" lazy-init="true"/>
    <bean id="dataSourceMaster" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.master.driver}" />
        <property name="url" value="${jdbc.master.url}" />
        <property name="username" value="${jdbc.master.username}" />
        <property name="password" value="${jdbc.master.password}" />
          <!-- 配置初始化大小、最小、最大 -->  
        <property name="initialSize" value="20" />  
        <property name="minIdle" value="20" />  
        <property name="maxActive" value="100" />  
        <!-- 配置获取连接等待超时的时间 -->  
        <property name="maxWait" value="60000" />  
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->  
        <property name="timeBetweenEvictionRunsMillis" value="3600000" />  
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->  
        <property name="minEvictableIdleTimeMillis" value="300000" />  
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->  
        <property name="poolPreparedStatements" value="true" />  
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20" /> 

        <property name="defaultAutoCommit" value="false" />
        <!-- 设置密码解密算法 -->
        <property name="connectionProperties" value="password=${jdbc.master.password}"/> 
        <property name="passwordCallback" ref="dbPasswordCallbackMaster"/>
    </bean>

    <!-- 配置读数据源 -->
    <bean id="dbPasswordCallbackSlaver" class="main.java.com.lxg.spring.mybatis.DBPwdUtil" lazy-init="true"/>
    <bean id="dataSourceSlaver" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.slaver.driver}" />
        <property name="url" value="${jdbc.slaver.url}" />
        <property name="username" value="${jdbc.slaver.username}" />
        <property name="password" value="${jdbc.slaver.password}" />
          <!-- 配置初始化大小、最小、最大 -->  
        <property name="initialSize" value="20" />  
        <property name="minIdle" value="20" />  
        <property name="maxActive" value="100" />  
        <!-- 配置获取连接等待超时的时间 -->  
        <property name="maxWait" value="60000" />  
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->  
        <property name="timeBetweenEvictionRunsMillis" value="3600000" />  
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->  
        <property name="minEvictableIdleTimeMillis" value="300000" />  
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->  
        <property name="poolPreparedStatements" value="true" />  
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20" /> 

        <property name="defaultAutoCommit" value="false" />
        <!-- 设置密码解密算法 -->
        <property name="connectionProperties" value="password=${jdbc.slaver.password}"/> 
        <property name="passwordCallback" ref="dbPasswordCallbackSlaver"/> 
    </bean>

引入标记的数据源

<bean id="dataSource" class="main.java.com.lxg.springdatesource.DynamicDataSource">
        <!-- 通过key-value的形式来关联数据源 -->
        <property name="targetDataSources">
            <map key-type="java.lang.String">
                <!-- 这个key需要和程序中的key一致 -->
                <entry key="master" value-ref="dataSourceMaster"/>
                <entry key="slaver" value-ref="dataSourceSlaver"/>
            </map>
        </property>
         <!-- 设置默认的数据源，这里默认走写库 -->
        <property name="defaultTargetDataSource" ref="dataSourceMaster" />
    </bean>

配置事务管理器

<!-- 定义AOP切面处理器 -->
    <bean class="main.java.com.lxg.springdatesource.DataSourceAspect" id="dataSourceAspect" />

    <aop:config>
        <!--pointcut元素定义一个切入点，execution中的第一个星号 用以匹配方法的返回类型， 这里星号表明匹配所有返回类型。 
        com.lxg.service.*.*(..)表明匹配com.lxg.service包下的所有类的所有 
            方法 -->
        <aop:pointcut id="myPointcut" expression="execution(* main.java.com.lxg.service.impl.*.*(..))" />
        <!--将定义好的事务处理策略应用到上述的切入点 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut" />

        <!-- 将切面应用到自定义的切面处理器上，-9999保证该切面优先级最高执行 -->
        <aop:aspect ref="dataSourceAspect" order="-9999">
            <aop:before method="before" pointcut-ref="myPointcut" />

        </aop:aspect>

    </aop:config>
    <--aop代理报错配置-->
    <aop:aspectj-autoproxy  proxy-target-class="true"/>

引入数据源信息

<util:properties id="settings"
        location="classpath:/jdbc.properties" />
    <!-- <context:property-placeholder location="classpath:/config/context.properties"/> -->
    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:/jdbc.properties</value>
            </list>
        </property>
    </bean>

mybatis配置

    <!-- MyBatis配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 显式指定Mapper文件位置 -->
        <property name="mapperLocations" value="classpath*:/mapper/*Mapper.xml" />
        <!-- mybatis配置文件路径 -->
        <property name="configLocation" value="classpath:/mybatis-config.xml" />
    </bean>

    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
        <!-- 这个执行器会批量执行更新语句, 还有SIMPLE 和 REUSE -->
        <constructor-arg index="1" value="BATCH" />
    </bean> 

    <!-- 扫描basePackage接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 映射器接口文件的包路径， -->
        <property name="basePackage" value="main.java.com.lxg.mapper" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>