2. 程式人生 > >Spring+MyBatis實現數據庫讀寫分離方案

Spring+MyBatis實現數據庫讀寫分離方案

阿新 • • 發佈：2018-10-19
enabled nco put cdata nproxy log4j equals end aso

方案1
通過MyBatis配置文件創建讀寫分離兩個DataSource，每個SqlSessionFactoryBean對象的mapperLocations屬性制定兩個讀寫數據源的配置文件。將所有讀的操作配置在讀文件中，所有寫的操作配置在寫文件中。

優點：實現簡單
缺點：維護麻煩，需要對原有的xml文件進行重新修改，不支持多讀，不易擴展
實現方式

<bean id="abstractDataSource" abstract="true" class="com.alibaba.druid.pool.DruidDataSource" init-method="init"

destroy-method="close">
<property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
<!-- 配置獲取連接等待超時的時間 -->
<property name="maxWait" value="60000"/>
<!-- 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒 -->
<property name="timeBetweenEvictionRunsMillis" value="60000"/>
<!-- 配置一個連接在池中最小生存的時間，單位是毫秒 -->
<property name="minEvictableIdleTimeMillis" value="300000"/>
<property name="validationQuery" value="SELECT ‘x‘"/>
<property name="testWhileIdle" value="true"/>
<property name="testOnBorrow" value="false"/>
<property name="testOnReturn" value="false"/>
<!-- 打開PSCache，並且指定每個連接上PSCache的大小 -->
<property name="poolPreparedStatements" value="true"/>
<property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>
<property name="filters" value="config"/>
<property name="connectionProperties" value="config.decrypt=true" />
</bean>

<bean id="readDataSource" parent="abstractDataSource">
<!-- 基本屬性 url、user、password -->
<property name="url" value="${read.jdbc.url}"/>
<property name="username" value="${read.jdbc.user}"/>
<property name="password" value="${read.jdbc.password}"/>
<!-- 配置初始化大小、最小、最大 -->
<property name="initialSize" value="${read.jdbc.initPoolSize}"/>
<property name="minIdle" value="10"/>
<property name="maxActive" value="${read.jdbc.maxPoolSize}"/>
</bean>

<bean id="writeDataSource" parent="abstractDataSource">
<!-- 基本屬性 url、user、password -->
<property name="url" value="${write.jdbc.url}"/>
<property name="username" value="${write.jdbc.user}"/>
<property name="password" value="${write.jdbc.password}"/>
<!-- 配置初始化大小、最小、最大 -->
<property name="initialSize" value="${write.jdbc.initPoolSize}"/>
<property name="minIdle" value="10"/>
<property name="maxActive" value="${write.jdbc.maxPoolSize}"/>
</bean>

<bean id="readSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 實例化sqlSessionFactory時需要使用上述配置好的數據源以及SQL映射文件 -->
<property name="dataSource" ref="readDataSource"/>
<property name="mapperLocations" value="classpath:mapper/read/*.xml"/>
</bean>

<bean id="writeSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 實例化sqlSessionFactory時需要使用上述配置好的數據源以及SQL映射文件 -->
<property name="dataSource" ref="writeDataSource"/>
<property name="mapperLocations" value="classpath:mapper/write/*.xml"/>
</bean>

方案2
通過Spring AOP在業務層實現讀寫分離，在DAO層調用前定義切面，利用Spring的AbstractRoutingDataSource解決多數據源的問題，實現動態選擇數據源

優點：通過註解的方法在DAO每個方法上配置數據源，原有代碼改動量少，易擴展，支持多讀
缺點：需要在DAO每個方法上配置註解，人工管理，容易出錯
實現方式

//定義枚舉類型，讀寫
public enum DynamicDataSourceGlobal {
READ, WRITE;
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

  • RUNTIME
  • 定義註解
  • 編譯器將把註釋記錄在類文件中，在運行時 VM 將保留註釋，因此可以反射性地讀取。
  • @author shma1664

  • */@Retention(RetentionPolicy.RUNTIME)
    br/>@Retention(RetentionPolicy.RUNTIME)
    public @interface DataSource {

    public DynamicDataSourceGlobal value() default DynamicDataSourceGlobal.READ;

}
/**

  • Created by IDEA
  • 本地線程設置和獲取數據源信息
  • User: mashaohua
  • Date: 2016-07-07 13:35

  • Desc:
    */
    public class DynamicDataSourceHolder {

    private static final ThreadLocal<DynamicDataSourceGlobal> holder = new ThreadLocal<DynamicDataSourceGlobal>();

    public static void putDataSource(DynamicDataSourceGlobal dataSource){
    holder.set(dataSource);
    }

    public static DynamicDataSourceGlobal getDataSource(){
    return holder.get();
    }

    public static void clearDataSource() {
    holder.remove();
    }

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

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-14 10:56

  • Desc: 動態數據源實現讀寫分離
    */
    public class DynamicDataSource extends AbstractRoutingDataSource {

    private Object writeDataSource; //寫數據源

    private List<Object> readDataSources; //多個讀數據源

    private int readDataSourceSize; //讀數據源個數

    private int readDataSourcePollPattern = 0; //獲取讀數據源方式，0：隨機，1：輪詢

    private AtomicLong counter = new AtomicLong(0);

    private static final Long MAX_POOL = Long.MAX_VALUE;

    private final Lock lock = new ReentrantLock();

    @Override
    public void afterPropertiesSet() {
    if (this.writeDataSource == null) {
    throw new IllegalArgumentException("Property ‘writeDataSource‘ is required");
    }
    setDefaultTargetDataSource(writeDataSource);
    Map<Object, Object> targetDataSources = new HashMap<>();
    targetDataSources.put(DynamicDataSourceGlobal.WRITE.name(), writeDataSource);
    if (this.readDataSources == null) {
    readDataSourceSize = 0;
    } else {
    for(int i=0; i<readDataSources.size(); i++) {
    targetDataSources.put(DynamicDataSourceGlobal.READ.name() + i, readDataSources.get(i));
    }
    readDataSourceSize = readDataSources.size();
    }
    setTargetDataSources(targetDataSources);
    super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {

    DynamicDataSourceGlobal dynamicDataSourceGlobal = DynamicDataSourceHolder.getDataSource();

if(dynamicDataSourceGlobal == null
        || dynamicDataSourceGlobal == DynamicDataSourceGlobal.WRITE
        || readDataSourceSize &lt;= 0) {
    return DynamicDataSourceGlobal.WRITE.name();
}

int index = 1;

if(readDataSourcePollPattern == 1) {
    //輪詢方式
    long currValue = counter.incrementAndGet();
    if((currValue + 1) &gt;= MAX_POOL) {
        try {
            lock.lock();
            if((currValue + 1) &gt;= MAX_POOL) {
                counter.set(0);
            }
        } finally {
            lock.unlock();
        }
    }
    index = (int) (currValue % readDataSourceSize);
} else {
    //隨機方式
    index = ThreadLocalRandom.current().nextInt(0, readDataSourceSize);
}
return dynamicDataSourceGlobal.name() + index;

    }

    public void setWriteDataSource(Object writeDataSource) {
    this.writeDataSource = writeDataSource;
    }

    public void setReadDataSources(List<Object> readDataSources) {
    this.readDataSources = readDataSources;
    }

    public void setReadDataSourcePollPattern(int readDataSourcePollPattern) {
    this.readDataSourcePollPattern = readDataSourcePollPattern;
    }
    }
    import org.apache.log4j.Logger;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-07 13:39

  • Desc: 定義選擇數據源切面
    */
    public class DynamicDataSourceAspect {

    private static final Logger logger = Logger.getLogger(DynamicDataSourceAspect.class);

    public void pointCut(){};

    public void before(JoinPoint point)
    {
    Object target = point.getTarget();
    String methodName = point.getSignature().getName();
    Class<?>[] clazz = target.getClass().getInterfaces();
    Class<?>[] parameterTypes = ((MethodSignature) point.getSignature()).getMethod().getParameterTypes();
    try {
    Method method = clazz[0].getMethod(methodName, parameterTypes);
    if (method != null && method.isAnnotationPresent(DataSource.class)) {
    DataSource data = method.getAnnotation(DataSource.class);
    DynamicDataSourceHolder.putDataSource(data.value());
    }
    } catch (Exception e) {
    logger.error(String.format("Choose DataSource error, method:%s, msg:%s", methodName, e.getMessage()));
    }
    }

    public void after(JoinPoint point) {
    DynamicDataSourceHolder.clearDataSource();
    }
    }
    <?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:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

    <bean id="abstractDataSource" abstract="true" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
    <!-- 配置獲取連接等待超時的時間 -->
    <property name="maxWait" value="60000"/>
    <!-- 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="60000"/>
    <!-- 配置一個連接在池中最小生存的時間，單位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="300000"/>
    <property name="validationQuery" value="SELECT ‘x‘"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>
    <!-- 打開PSCache，並且指定每個連接上PSCache的大小 -->
    <property name="poolPreparedStatements" value="true"/>
    <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>
    <property name="filters" value="config"/>
    <property name="connectionProperties" value="config.decrypt=true" />
    </bean>

    <bean id="dataSourceRead1" parent="abstractDataSource">
    <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
    <!-- 基本屬性 url、user、password -->
    <property name="url" value="${read1.jdbc.url}"/>
    <property name="username" value="${read1.jdbc.user}"/>
    <property name="password" value="${read1.jdbc.password}"/>
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="${read1.jdbc.initPoolSize}"/>
    <property name="minIdle" value="${read1.jdbc.minPoolSize}"/>
    <property name="maxActive" value="${read1.jdbc.maxPoolSize}"/>
    </bean>

    <bean id="dataSourceRead2" parent="abstractDataSource">
    <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
    <!-- 基本屬性 url、user、password -->
    <property name="url" value="${read2.jdbc.url}"/>
    <property name="username" value="${read2.jdbc.user}"/>
    <property name="password" value="${read2.jdbc.password}"/>
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="${read2.jdbc.initPoolSize}"/>
    <property name="minIdle" value="${read2.jdbc.minPoolSize}"/>
    <property name="maxActive" value="${read2.jdbc.maxPoolSize}"/>
    </bean>

    <bean id="dataSourceWrite" parent="abstractDataSource">
    <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
    <!-- 基本屬性 url、user、password -->
    <property name="url" value="${write.jdbc.url}"/>
    <property name="username" value="${write.jdbc.user}"/>
    <property name="password" value="${write.jdbc.password}"/>
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="${write.jdbc.initPoolSize}"/>
    <property name="minIdle" value="${write.jdbc.minPoolSize}"/>
    <property name="maxActive" value="${write.jdbc.maxPoolSize}"/>
    </bean>

    <bean id="dataSource" class="com.test.api.dao.datasource.DynamicDataSource">
    <property name="writeDataSource" ref="dataSourceWrite" />
    <property name="readDataSources">
    <list>
    <ref bean="dataSourceRead1" />
    <ref bean="dataSourceRead2" />
    </list>
    </property>
    <!--輪詢方式-->
    <property name="readDataSourcePollPattern" value="1" />
    <property name="defaultTargetDataSource" ref="dataSourceWrite"/>
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 針對myBatis的配置項 -->
    <!-- 配置sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 實例化sqlSessionFactory時需要使用上述配置好的數據源以及SQL映射文件 -->
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 配置掃描器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 掃描包以及它的子包下的所有映射接口類 -->
    <property name="basePackage" value="com.test.api.dao.inte"/>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!-- 配置數據庫註解aop -->
    <bean id="dynamicDataSourceAspect" class="com.test.api.dao.datasource.DynamicDataSourceAspect" />
    <aop:config>
    <aop:aspect id="c" ref="dynamicDataSourceAspect">
    <aop:pointcut id="tx" expression="execution( com.test.api.dao.inte...*(..))"/>
    <aop:before pointcut-ref="tx" method="before"/>
    <aop:after pointcut-ref="tx" method="after"/>
    </aop:aspect>
    </aop:config>
    <!-- 配置數據庫註解aop -->
    </beans>

方案3
通過Mybatis的Plugin在業務層實現數據庫讀寫分離，在MyBatis創建Statement對象前通過攔截器選擇真正的數據源，在攔截器中根據方法名稱不同（select、update、insert、delete）選擇數據源。

優點：原有代碼不變，支持多讀，易擴展
缺點：
實現方式

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-19 15:40

  • Desc: 創建Connection代理接口
    */
    public interface ConnectionProxy extends Connection {

    /**

    • 根據傳入的讀寫分離需要的key路由到正確的connection
    • @param key 數據源標識
    • @return
      */
      Connection getTargetConnection(String key);
      }
      import java.lang.reflect.InvocationHandler;
      import java.lang.reflect.InvocationTargetException;
      import java.lang.reflect.Method;
      import java.lang.reflect.Proxy;
      import java.sql.Connection;
      import java.sql.SQLException;
      import java.util.ArrayList;
      import java.util.List;
      import java.util.logging.Logger;

import javax.sql.DataSource;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.jdbc.datasource.AbstractDataSource;
import org.springframework.jdbc.datasource.lookup.DataSourceLookup;
import org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup;
import org.springframework.util.Assert;

public abstract class AbstractDynamicDataSourceProxy extends AbstractDataSource implements InitializingBean {

private List&lt;Object&gt; readDataSources;
private List&lt;DataSource&gt; resolvedReadDataSources;

private Object writeDataSource;
private DataSource resolvedWriteDataSource;

private int readDataSourcePollPattern = 0;

private int readDsSize;

private boolean defaultAutoCommit = true;
private int defaultTransactionIsolation = Connection.TRANSACTION_READ_COMMITTED;

public static final String READ = "read";

public static final String WRITE = "write";

private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();

@Override
public Connection getConnection() throws SQLException {
    return (Connection) Proxy.newProxyInstance(
            com.autohome.api.dealer.tuan.dao.rwmybatis.ConnectionProxy.class.getClassLoader(),
            new Class[] {com.autohome.api.dealer.tuan.dao.rwmybatis.ConnectionProxy.class},
            new RWConnectionInvocationHandler());
}

@Override
public Connection getConnection(String username, String password)
        throws SQLException {
    return (Connection) Proxy.newProxyInstance(
            com.autohome.api.dealer.tuan.dao.rwmybatis.ConnectionProxy.class.getClassLoader(),
            new Class[] {com.autohome.api.dealer.tuan.dao.rwmybatis.ConnectionProxy.class},
            new RWConnectionInvocationHandler(username,password));
}

public int getReadDsSize(){
    return readDsSize;
}

public List&lt;DataSource&gt; getResolvedReadDataSources() {
    return resolvedReadDataSources;
}

public void afterPropertiesSet() throws Exception {

    if(writeDataSource == null){
        throw new IllegalArgumentException("Property ‘writeDataSource‘ is required");
    }
    this.resolvedWriteDataSource = resolveSpecifiedDataSource(writeDataSource);

    resolvedReadDataSources = new ArrayList&lt;DataSource&gt;(readDataSources.size());
    for(Object item : readDataSources){
        resolvedReadDataSources.add(resolveSpecifiedDataSource(item));
    }
    readDsSize = readDataSources.size();
}

protected DataSource determineTargetDataSource(String key) {
    Assert.notNull(this.resolvedReadDataSources, "DataSource router not initialized");
    if(WRITE.equals(key)){
        return resolvedWriteDataSource;
    }else{
        return loadReadDataSource();
    }
}

public Logger getParentLogger() {
    // NOOP Just ignore
    return null;
}

/**
 * 獲取真實的data source
 * @param dataSource (jndi | real data source)
 * @return
 * @throws IllegalArgumentException
 */
protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
    if (dataSource instanceof DataSource) {
        return (DataSource) dataSource;
    }
    else if (dataSource instanceof String) {
        return this.dataSourceLookup.getDataSource((String) dataSource);
    }
    else {
        throw new IllegalArgumentException(
                "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
    }
}

protected abstract DataSource loadReadDataSource();

public void setReadDsSize(int readDsSize) {
    this.readDsSize = readDsSize;
}

public List&lt;Object&gt; getReadDataSources() {
    return readDataSources;
}

public void setReadDataSources(List&lt;Object&gt; readDataSources) {
    this.readDataSources = readDataSources;
}

public Object getWriteDataSource() {
    return writeDataSource;
}

public void setWriteDataSource(Object writeDataSource) {
    this.writeDataSource = writeDataSource;
}

public void setResolvedReadDataSources(List&lt;DataSource&gt; resolvedReadDataSources) {
    this.resolvedReadDataSources = resolvedReadDataSources;
}

public DataSource getResolvedWriteDataSource() {
    return resolvedWriteDataSource;
}

public void setResolvedWriteDataSource(DataSource resolvedWriteDataSource) {
    this.resolvedWriteDataSource = resolvedWriteDataSource;
}

public int getReadDataSourcePollPattern() {
    return readDataSourcePollPattern;
}

public void setReadDataSourcePollPattern(int readDataSourcePollPattern) {
    this.readDataSourcePollPattern = readDataSourcePollPattern;
}

/**
 * Invocation handler that defers fetching an actual JDBC Connection
 * until first creation of a Statement.
 */
private class RWConnectionInvocationHandler implements InvocationHandler {

    private String username;

    private String password;

    private Boolean readOnly = Boolean.FALSE;

    private Integer transactionIsolation;

    private Boolean autoCommit;

    private boolean closed = false;

    private Connection target;

    public RWConnectionInvocationHandler() {

    }

    public RWConnectionInvocationHandler(String username, String password) {
        this();
        this.username = username;
        this.password = password;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // Invocation on ConnectionProxy interface coming in...

        if (method.getName().equals("equals")) {
            // We must avoid fetching a target Connection for "equals".
            // Only consider equal when proxies are identical.
            return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);
        }
        else if (method.getName().equals("hashCode")) {
            // We must avoid fetching a target Connection for "hashCode",
            // and we must return the same hash code even when the target
            // Connection has been fetched: use hashCode of Connection proxy.
            return new Integer(System.identityHashCode(proxy));
        }
        else if (method.getName().equals("getTargetConnection")) {
            // Handle getTargetConnection method: return underlying connection.
            return getTargetConnection(method,args);
        }

        if (!hasTargetConnection()) {
            // No physical target Connection kept yet -&gt;
            // resolve transaction demarcation methods without fetching
            // a physical JDBC Connection until absolutely necessary.

            if (method.getName().equals("toString")) {
                return "RW Routing DataSource Proxy";
            }
            else if (method.getName().equals("isReadOnly")) {
                return this.readOnly;
            }
            else if (method.getName().equals("setReadOnly")) {
                this.readOnly = (Boolean) args[0];
                return null;
            }
            else if (method.getName().equals("getTransactionIsolation")) {
                if (this.transactionIsolation != null) {
                    return this.transactionIsolation;
                }
                return defaultTransactionIsolation;
                // Else fetch actual Connection and check there,
                // because we didn‘t have a default specified.
            }
            else if (method.getName().equals("setTransactionIsolation")) {
                this.transactionIsolation = (Integer) args[0];
                return null;
            }
            else if (method.getName().equals("getAutoCommit")) {
                if (this.autoCommit != null)
                    return this.autoCommit;
                return defaultAutoCommit;
                // Else fetch actual Connection and check there,
                // because we didn‘t have a default specified.
            }
            else if (method.getName().equals("setAutoCommit")) {
                this.autoCommit = (Boolean) args[0];
                return null;
            }
            else if (method.getName().equals("commit")) {
                // Ignore: no statements created yet.
                return null;
            }
            else if (method.getName().equals("rollback")) {
                // Ignore: no statements created yet.
                return null;
            }
            else if (method.getName().equals("getWarnings")) {
                return null;
            }
            else if (method.getName().equals("clearWarnings")) {
                return null;
            }
            else if (method.getName().equals("isClosed")) {
                return (this.closed ? Boolean.TRUE : Boolean.FALSE);
            }
            else if (method.getName().equals("close")) {
                // Ignore: no target connection yet.
                this.closed = true;
                return null;
            }
            else if (this.closed) {
                // Connection proxy closed, without ever having fetched a
                // physical JDBC Connection: throw corresponding SQLException.
                throw new SQLException("Illegal operation: connection is closed");
            }
        }

        // Target Connection already fetched,
        // or target Connection necessary for current operation -&gt;
        // invoke method on target connection.
        try {
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }

    /**
     * Return whether the proxy currently holds a target Connection.
     */
    private boolean hasTargetConnection() {
        return (this.target != null);
    }

    /**
     * Return the target Connection, fetching it and initializing it if necessary.
     */
    private Connection getTargetConnection(Method operation,Object[] args) throws SQLException {

        if (this.target == null) {
            String key = (String) args[0];
            // No target Connection held -&gt; fetch one.
            if (logger.isDebugEnabled()) {
                logger.debug("Connecting to database for operation ‘" + operation.getName() + "‘");
            }

            // Fetch physical Connection from DataSource.
            this.target = (this.username != null) ?
                    determineTargetDataSource(key).getConnection(this.username, this.password) :
                    determineTargetDataSource(key).getConnection();

            // If we still lack default connection properties, check them now.
            //checkDefaultConnectionProperties(this.target);

            // Apply kept transaction settings, if any.
            if (this.readOnly.booleanValue()) {
                this.target.setReadOnly(this.readOnly.booleanValue());
            }
            if (this.transactionIsolation != null) {
                this.target.setTransactionIsolation(this.transactionIsolation.intValue());
            }
            if (this.autoCommit != null && this.autoCommit.booleanValue() != this.target.getAutoCommit()) {
                this.target.setAutoCommit(this.autoCommit.booleanValue());
            }
        }

        else {
            // Target Connection already held -&gt; return it.
            if (logger.isDebugEnabled()) {
                logger.debug("Using existing database connection for operation ‘" + operation.getName() + "‘");
            }
        }

        return this.target;
    }
}

}
import javax.sql.DataSource;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-19 16:04

  • Desc:
    */
    public class DynamicRoutingDataSourceProxy extends AbstractDynamicDataSourceProxy {

    private AtomicLong counter = new AtomicLong(0);

    private static final Long MAX_POOL = Long.MAX_VALUE;

    private final Lock lock = new ReentrantLock();

    @Override
    protected DataSource loadReadDataSource() {
    int index = 1;

    if(getReadDataSourcePollPattern() == 1) {
    //輪詢方式
    long currValue = counter.incrementAndGet();
    if((currValue + 1) &gt;= MAX_POOL) {
        try {
            lock.lock();
            if((currValue + 1) &gt;= MAX_POOL) {
                counter.set(0);
            }
        } finally {
            lock.unlock();
        }
    }
    index = (int) (currValue % getReadDsSize());
} else {
    //隨機方式
    index = ThreadLocalRandom.current().nextInt(0, getReadDsSize());
}
return getResolvedReadDataSources().get(index);

    }
    }
    import org.apache.ibatis.executor.statement.RoutingStatementHandler;
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.SqlCommandType;
    import org.apache.ibatis.plugin.*;

import java.sql.Connection;
import java.util.Properties;

/**

  • 攔截器
    */
    @Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
    public class DynamicPlugin implements Interceptor {

    public Object intercept(Invocation invocation) throws Throwable {

    Connection conn = (Connection)invocation.getArgs()[0];
//如果是采用了我們代理,則路由數據源
if(conn instanceof com.autohome.api.dealer.tuan.dao.rwmybatis.ConnectionProxy){
    StatementHandler statementHandler = (StatementHandler) invocation
            .getTarget();

    MappedStatement mappedStatement = null;
    if (statementHandler instanceof RoutingStatementHandler) {
        StatementHandler delegate = (StatementHandler) ReflectionUtils
                .getFieldValue(statementHandler, "delegate");
        mappedStatement = (MappedStatement) ReflectionUtils.getFieldValue(
                delegate, "mappedStatement");
    } else {
        mappedStatement = (MappedStatement) ReflectionUtils.getFieldValue(
                statementHandler, "mappedStatement");
    }
    String key = AbstractDynamicDataSourceProxy.WRITE;

    if(mappedStatement.getSqlCommandType() == SqlCommandType.SELECT){
        key = AbstractDynamicDataSourceProxy.READ;
    }else{
        key = AbstractDynamicDataSourceProxy.WRITE;
    }

    ConnectionProxy connectionProxy = (ConnectionProxy)conn;
    connectionProxy.getTargetConnection(key);

}

return invocation.proceed();

    }

    public Object plugin(Object target) {

    return Plugin.wrap(target, this);

    }

    public void setProperties(Properties properties) {
    //NOOP

    }

}
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;

import java.lang.reflect.*;

public class ReflectionUtils {

private static final Log logger = LogFactory.getLog(ReflectionUtils.class);

/**
 * 直接設置對象屬性值,無視private/protected修飾符,不經過setter函數.
 */
public static void setFieldValue(final Object object, final String fieldName, final Object value) {
    Field field = getDeclaredField(object, fieldName);

    if (field == null)
        throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

    makeAccessible(field);

    try {
        field.set(object, value);
    } catch (IllegalAccessException e) {

    }
}

/**
 * 直接讀取對象屬性值,無視private/protected修飾符,不經過getter函數.
 */
public static Object getFieldValue(final Object object, final String fieldName) {
    Field field = getDeclaredField(object, fieldName);

    if (field == null)
        throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

    makeAccessible(field);

    Object result = null;
    try {
        result = field.get(object);
    } catch (IllegalAccessException e) {

    }
    return result;
}

/**
 * 直接調用對象方法,無視private/protected修飾符.
 */
public static Object invokeMethod(final Object object, final String methodName, final Class&lt;?&gt;[] parameterTypes,
        final Object[] parameters) throws InvocationTargetException {
    Method method = getDeclaredMethod(object, methodName, parameterTypes);
    if (method == null)
        throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");

    method.setAccessible(true);

    try {
        return method.invoke(object, parameters);
    } catch (IllegalAccessException e) {

    }

    return null;
}

/**
 * 循環向上轉型,獲取對象的DeclaredField.
 */
protected static Field getDeclaredField(final Object object, final String fieldName) {
    for (Class&lt;?&gt; superClass = object.getClass(); superClass != Object.class; superClass = superClass
            .getSuperclass()) {
        try {
            return superClass.getDeclaredField(fieldName);
        } catch (NoSuchFieldException e) {
        }
    }
    return null;
}

/**
 * 循環向上轉型,獲取對象的DeclaredField.
 */
protected static void makeAccessible(final Field field) {
    if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
        field.setAccessible(true);
    }
}

/**
 * 循環向上轉型,獲取對象的DeclaredMethod.
 */
protected static Method getDeclaredMethod(Object object, String methodName, Class&lt;?&gt;[] parameterTypes) {
    for (Class&lt;?&gt; superClass = object.getClass(); superClass != Object.class; superClass = superClass
            .getSuperclass()) {
        try {
            return superClass.getDeclaredMethod(methodName, parameterTypes);
        } catch (NoSuchMethodException e) {

        }
    }
    return null;
}

/**
 * 通過反射,獲得Class定義中聲明的父類的泛型參數的類型.
 * eg.
 * public UserDao extends HibernateDao&lt;User&gt;
 *
 * @param clazz The class to introspect
 * @return the first generic declaration, or Object.class if cannot be determined
 */
@SuppressWarnings("unchecked")
public static &lt;T&gt; Class&lt;T&gt; getSuperClassGenricType(final Class clazz) {
    return getSuperClassGenricType(clazz, 0);
}

/**
 * 通過反射,獲得Class定義中聲明的父類的泛型參數的類型.
 * eg.
 * public UserDao extends HibernateDao&lt;User&gt;
 *
 * @param clazz The class to introspect
 * @return the first generic declaration, or Object.class if cannot be determined
 */
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(final Class clazz, final int index) {

    Type genType = clazz.getGenericSuperclass();

    if (!(genType instanceof ParameterizedType)) {
        logger.warn(clazz.getSimpleName() + "‘s superclass not ParameterizedType");
        return Object.class;
    }

    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

    if (index &gt;= params.length || index &lt; 0) {
        logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "‘s Parameterized Type: "
                + params.length);
        return Object.class;
    }
    if (!(params[index] instanceof Class)) {
        logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
        return Object.class;
    }

    return (Class) params[index];
}

/**
 * 將反射時的checked exception轉換為unchecked exception.
 */
public static IllegalArgumentException convertToUncheckedException(Exception e) {
    if (e instanceof IllegalAccessException || e instanceof IllegalArgumentException
            || e instanceof NoSuchMethodException)
        return new IllegalArgumentException("Refelction Exception.", e);
    else
        return new IllegalArgumentException(e);
}

}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD SQL Map Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<plugins>
<plugin interceptor="com.test.api.dao.mybatis.DynamicPlugin">
</plugin>
</plugins>

</configuration>
<?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:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

&lt;bean id="abstractDataSource" abstract="true" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"&gt;
    &lt;property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/&gt;
    &lt;!-- 配置獲取連接等待超時的時間 --&gt;
    &lt;property name="maxWait" value="60000"/&gt;
    &lt;!-- 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒 --&gt;
    &lt;property name="timeBetweenEvictionRunsMillis" value="60000"/&gt;
    &lt;!-- 配置一個連接在池中最小生存的時間，單位是毫秒 --&gt;
    &lt;property name="minEvictableIdleTimeMillis" value="300000"/&gt;
    &lt;property name="validationQuery" value="SELECT ‘x‘"/&gt;
    &lt;property name="testWhileIdle" value="true"/&gt;
    &lt;property name="testOnBorrow" value="false"/&gt;
    &lt;property name="testOnReturn" value="false"/&gt;
    &lt;!-- 打開PSCache，並且指定每個連接上PSCache的大小 --&gt;
    &lt;property name="poolPreparedStatements" value="true"/&gt;
    &lt;property name="maxPoolPreparedStatementPerConnectionSize" value="20"/&gt;
    &lt;property name="filters" value="config"/&gt;
    &lt;property name="connectionProperties" value="config.decrypt=true" /&gt;
&lt;/bean&gt;

&lt;bean id="dataSourceRead1" parent="abstractDataSource"&gt;
    &lt;property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/&gt;
    &lt;!-- 基本屬性 url、user、password --&gt;
    &lt;property name="url" value="${read1.jdbc.url}"/&gt;
    &lt;property name="username" value="${read1.jdbc.user}"/&gt;
    &lt;property name="password" value="${read1.jdbc.password}"/&gt;
    &lt;!-- 配置初始化大小、最小、最大 --&gt;
    &lt;property name="initialSize" value="${read1.jdbc.initPoolSize}"/&gt;
    &lt;property name="minIdle" value="${read1.jdbc.minPoolSize}"/&gt;
    &lt;property name="maxActive" value="${read1.jdbc.maxPoolSize}"/&gt;
&lt;/bean&gt;

&lt;bean id="dataSourceRead2" parent="abstractDataSource"&gt;
    &lt;property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/&gt;
    &lt;!-- 基本屬性 url、user、password --&gt;
    &lt;property name="url" value="${read2.jdbc.url}"/&gt;
    &lt;property name="username" value="${read2.jdbc.user}"/&gt;
    &lt;property name="password" value="${read2.jdbc.password}"/&gt;
    &lt;!-- 配置初始化大小、最小、最大 --&gt;
    &lt;property name="initialSize" value="${read2.jdbc.initPoolSize}"/&gt;
    &lt;property name="minIdle" value="${read2.jdbc.minPoolSize}"/&gt;
    &lt;property name="maxActive" value="${read2.jdbc.maxPoolSize}"/&gt;
&lt;/bean&gt;

&lt;bean id="dataSourceWrite" parent="abstractDataSource"&gt;
    &lt;property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/&gt;
    &lt;!-- 基本屬性 url、user、password --&gt;
    &lt;property name="url" value="${write.jdbc.url}"/&gt;
    &lt;property name="username" value="${write.jdbc.user}"/&gt;
    &lt;property name="password" value="${write.jdbc.password}"/&gt;
    &lt;!-- 配置初始化大小、最小、最大 --&gt;
    &lt;property name="initialSize" value="${write.jdbc.initPoolSize}"/&gt;
    &lt;property name="minIdle" value="${write.jdbc.minPoolSize}"/&gt;
    &lt;property name="maxActive" value="${write.jdbc.maxPoolSize}"/&gt;
&lt;/bean&gt;

&lt;bean id="dataSource" class="com.test.api.dao.datasource.DynamicRoutingDataSourceProxy"&gt;
    &lt;property name="writeDataSource" ref="dataSourceWrite" /&gt;
    &lt;property name="readDataSources"&gt;
        &lt;list&gt;
            &lt;ref bean="dataSourceRead1" /&gt;
            &lt;ref bean="dataSourceRead2" /&gt;
        &lt;/list&gt;
    &lt;/property&gt;
    &lt;!--輪詢方式--&gt;
    &lt;property name="readDataSourcePollPattern" value="1" /&gt;
&lt;/bean&gt;

&lt;tx:annotation-driven transaction-manager="transactionManager"/&gt;

&lt;bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"&gt;
    &lt;property name="dataSource" ref="dataSource"/&gt;
&lt;/bean&gt;

&lt;!-- 針對myBatis的配置項 --&gt;
&lt;!-- 配置sqlSessionFactory --&gt;
&lt;bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"&gt;
    &lt;!-- 實例化sqlSessionFactory時需要使用上述配置好的數據源以及SQL映射文件 --&gt;
    &lt;property name="dataSource" ref="dataSource"/&gt;
    &lt;property name="mapperLocations" value="classpath:mapper/*.xml"/&gt;
    &lt;property name="configLocation" value="classpath:mybatis-plugin-config.xml" /&gt;
&lt;/bean&gt;

&lt;bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"&gt;
    &lt;constructor-arg ref="sqlSessionFactory" /&gt;
&lt;/bean&gt;
&lt;!-- 通過掃描的模式，掃描目錄下所有的mapper， 根據對應的mapper.xml為其生成代理類--&gt;
&lt;bean id="mapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer"&gt;
    &lt;property name="basePackage" value="com.test.api.dao.inte" /&gt;
    &lt;property name="sqlSessionTemplate" ref="sqlSessionTemplate"&gt;&lt;/property&gt;
&lt;/bean&gt;

</beans>

方案4
如果你的後臺結構是spring+mybatis，可以通過spring的AbstractRoutingDataSource和mybatis Plugin攔截器實現非常友好的讀寫分離，原有代碼不需要任何改變。推薦第四種方案

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

import java.util.HashMap;
import java.util.Map;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-14 10:56

  • Desc: 動態數據源實現讀寫分離
    */
    public class DynamicDataSource extends AbstractRoutingDataSource {

    private Object writeDataSource; //寫數據源

    private Object readDataSource; //讀數據源

    @Override
    public void afterPropertiesSet() {
    if (this.writeDataSource == null) {
    throw new IllegalArgumentException("Property ‘writeDataSource‘ is required");
    }
    setDefaultTargetDataSource(writeDataSource);
    Map<Object, Object> targetDataSources = new HashMap<>();
    targetDataSources.put(DynamicDataSourceGlobal.WRITE.name(), writeDataSource);
    if(readDataSource != null) {
    targetDataSources.put(DynamicDataSourceGlobal.READ.name(), readDataSource);
    }
    setTargetDataSources(targetDataSources);
    super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {

    DynamicDataSourceGlobal dynamicDataSourceGlobal = DynamicDataSourceHolder.getDataSource();

if(dynamicDataSourceGlobal == null
        || dynamicDataSourceGlobal == DynamicDataSourceGlobal.WRITE) {
    return DynamicDataSourceGlobal.WRITE.name();
}

return DynamicDataSourceGlobal.READ.name();

    }

    public void setWriteDataSource(Object writeDataSource) {
    this.writeDataSource = writeDataSource;
    }

    public Object getWriteDataSource() {
    return writeDataSource;
    }

    public Object getReadDataSource() {
    return readDataSource;
    }

    public void setReadDataSource(Object readDataSource) {
    this.readDataSource = readDataSource;
    }
    }
    /**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-07-14 10:58

  • Desc:
    */
    public enum DynamicDataSourceGlobal {
    READ, WRITE;
    }
    public final class DynamicDataSourceHolder {

    private static final ThreadLocal<DynamicDataSourceGlobal> holder = new ThreadLocal<DynamicDataSourceGlobal>();

    private DynamicDataSourceHolder() {
    //
    }

    public static void putDataSource(DynamicDataSourceGlobal dataSource){
    holder.set(dataSource);
    }

    public static DynamicDataSourceGlobal getDataSource(){
    return holder.get();
    }

    public static void clearDataSource() {
    holder.remove();
    }

}
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-08-10 14:34

  • Desc:
    */
    public class DynamicDataSourceTransactionManager extends DataSourceTransactionManager {

    /**

    • 只讀事務到讀庫，讀寫事務到寫庫
    • @param transaction

    • @param definition*/
      @Override
      br/>*/
      @Override

      //設置數據源
      boolean readOnly = definition.isReadOnly();
      if(readOnly) {
      DynamicDataSourceHolder.putDataSource(DynamicDataSourceGlobal.READ);
      } else {
      DynamicDataSourceHolder.putDataSource(DynamicDataSourceGlobal.WRITE);
      }
      super.doBegin(transaction, definition);
      }

    /**

    • 清理本地線程的數據源
    • @param transaction*/
      @Override
      br/>*/
      @Override
      super.doCleanupAfterCompletion(transaction);
      DynamicDataSourceHolder.clearDataSource();
      }
      }
      import org.apache.ibatis.executor.Executor;
      import org.apache.ibatis.executor.keygen.SelectKeyGenerator;
      import org.apache.ibatis.mapping.BoundSql;
      import org.apache.ibatis.mapping.MappedStatement;
      import org.apache.ibatis.mapping.SqlCommandType;
      import org.apache.ibatis.plugin.*;
      import org.apache.ibatis.session.ResultHandler;
      import org.apache.ibatis.session.RowBounds;
      import org.slf4j.Logger;
      import org.slf4j.LoggerFactory;
      import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

/**

  • Created by IDEA
  • User: mashaohua
  • Date: 2016-08-10 11:09

  • Desc:*/
    @Intercepts({
    br/>*/
    @Intercepts({
    MappedStatement.class, Object.class }),
    @Signature(type = Executor.class, method = "query", args = {
    MappedStatement.class, Object.class, RowBounds.class,
    ResultHandler.class }) })
    public class DynamicPlugin implements Interceptor {

    protected static final Logger logger = LoggerFactory.getLogger(DynamicPlugin.class);

    private static final String REGEX = ".insert\u0020.|.delete\u0020.|.update\u0020.";

    private static final Map<String, DynamicDataSourceGlobal> cacheMap = new ConcurrentHashMap<>();

    @Override
    public Object intercept(Invocation invocation) throws Throwable {

    boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
if(!synchronizationActive) {
    Object[] objects = invocation.getArgs();
    MappedStatement ms = (MappedStatement) objects[0];

    DynamicDataSourceGlobal dynamicDataSourceGlobal = null;

    if((dynamicDataSourceGlobal = cacheMap.get(ms.getId())) == null) {
        //讀方法
        if(ms.getSqlCommandType().equals(SqlCommandType.SELECT)) {
            //!selectKey 為自增id查詢主鍵(SELECT LAST_INSERT_ID() )方法，使用主庫
            if(ms.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)) {
                dynamicDataSourceGlobal = DynamicDataSourceGlobal.WRITE;
            } else {
                BoundSql boundSql = ms.getSqlSource().getBoundSql(objects[1]);
                String sql = boundSql.getSql().toLowerCase(Locale.CHINA).replaceAll("[\\t\\n\\r]", " ");
                if(sql.matches(REGEX)) {
                    dynamicDataSourceGlobal = DynamicDataSourceGlobal.WRITE;
                } else {
                    dynamicDataSourceGlobal = DynamicDataSourceGlobal.READ;
                }
            }
        }else{
            dynamicDataSourceGlobal = DynamicDataSourceGlobal.WRITE;
        }
        logger.warn("設置方法[{}] use [{}] Strategy, SqlCommandType [{}]..", ms.getId(), dynamicDataSourceGlobal.name(), ms.getSqlCommandType().name());
        cacheMap.put(ms.getId(), dynamicDataSourceGlobal);
    }
    DynamicDataSourceHolder.putDataSource(dynamicDataSourceGlobal);
}

return invocation.proceed();

    }

    @Override
    public Object plugin(Object target) {
    if (target instanceof Executor) {
    return Plugin.wrap(target, this);
    } else {
    return target;
    }
    }

    @Override
    public void setProperties(Properties properties) {
    //
    }
    }

Spring+MyBatis實現數據庫讀寫分離方案

相關推薦

Spring+MyBatis實現數據庫讀寫分離方案

enabled nco put cdata nproxy log4j equals end aso 方案1通過MyBatis配置文件創建讀寫分離兩個DataSource，每個SqlSessionFactoryBean對象的mapperLocations屬性制定兩個讀寫數據源

springboot+mybatis實現數據庫讀寫分離

aspect def con odin scanner config help getconf mine 本文不包含數據庫主從配置。 實現思路：在項目中配置多數據源，通過代碼控制訪問哪一個數據源。 spring-jdbc為我們提供了AbstractRoutingDataSo

Spring + Mybatis項目實現數據庫讀寫分離

eterm nec trac vid () lose classpath mls exc 主要思路：通過實現AbstractRoutingDataSource類來動態管理數據源，利用面向切面思維，每一次進入service方法前，選擇數據源。 1、首先pom.xml中添加as

ProxySQL+Mysql實現數據庫讀寫分離實戰

until reboot centos7.x orm 有一個 datadir 執行 proc sqlit ProxySQL介紹 ProxySQL是一個高性能的MySQL中間件，擁有強大的規則引擎。具有以下特性：http://www.proxysql.com/ 1、連接池，

java實現mysql數據庫讀寫分離之定義多數據源方式

修改 protect frame auto ret 更新數據 logs cannot initial 該示例是基於spring提供的AbstractRoutingDataSource，實現了一個動態數據源的功能，在spring配置中定義多個數據庫分為主、從數據庫，實現效

mysql+proxysql+keepalived實現高可用的數據庫讀寫分離

mysql讀寫分離 主從復制 proxysql前言 為了降低一臺數據庫的IO，遠程連接數據庫的時候，可以實現讀寫分離進行調度。這裏就出現了一個單點，所以必須要做一個高可用。當然數據庫服務器也需要做主從復制。實驗結構 說明：上圖的拓撲只是整個架構中的一個小部分，其余功能的實現此圖並未規

Mycat實現Mysql數據庫讀寫分離

測試 9.png http company 分片 col windows版本 更多 win Linux和Windows環境下搭建Mycat數據讀寫分離 前提需要：1.服務器裝有JVM虛擬機，就是JDK。2.兩個Mysql數據庫已經實現主從復制,參考：https://

利用amoeba(變形蟲)實現mysql數據庫讀寫分離

基本 變量 占用內存 mysql- 主庫 圖片 prop 執行 客戶端連接 關於mysql的讀寫分離架構有很多，百度的話幾乎都是用mysql_proxy實現的。由於proxy是基於lua腳本語言實現的，所以網上不少網友表示proxy效率不高，也不穩定，不建議在生產環境使用；

Spring配置動態數據源-讀寫分離和多數據源

brush ride 常開 resolve ttr 表達 customer 事務管理 cda 　　在現在互聯網系統中，隨著用戶量的增長，單數據源通常無法滿足系統的負載要求。因此為了解決用戶量增長帶來的壓力，在數據庫層面會采用讀寫分離技術和數據庫拆分等技術。讀寫分離就是就是一

看京東架構師如何解決，數據庫讀寫分離與事務糾纏的坑

Java 架構師 微服務 源碼分析 本篇文章討論在數據庫讀寫分離時使用事務的那些坑：1. 在讀寫分離時會不會造成事務主從切換錯誤一個線程在Serivcie時Select時選擇的是從庫，DynamicDataSourceHolder中ThreadLocal對應線程存儲的是slave，然後調用Ma

配置數據庫讀寫分離服務器

數據庫配置一主一從 主從同步結構，並在客戶端測試配置master51> grant all on webdb.* to webuser@"%" identified by " 123456"; 裝包rpm -ivh maxscale-2.1.2-1.r

數據庫讀寫分離

atlas 優化 新的 使用 行數 技術分享 之前 right sql 緣由：對數據庫有頻繁操作，而寫數據本身比讀數據更耗時，則可以設計主從數據庫復制的方式同步數據，主數據庫用來更新數據，從數據庫用來查詢數據庫。 以MySql為例，可以基於sql語句復制在從庫上執行，或基

主從數據庫讀寫分離知識

數據庫數據 場景 nbsp 日誌 details 一致性 數據庫操作 參考 memcache （一）為什麽要實現讀寫分離？ 為了服務器承載更多的用戶？提升了網站的響應速度？分攤數據庫服務器的壓力？就是為了雙機熱備又不想浪費備份服務器？上面這些回答，我認為都不是錯誤的，但也都

yii2的數據庫讀寫分離配置

查看 www all local 數據庫同步 主從同步配置 服務器組 timeout lan 簡介 數據庫讀寫分離是在網站遇到性能瓶頸的時候最先考慮優化的步驟，那麽yii2是如何做數據庫讀寫分離的呢？本節教程來給大家普及一下yii2的數據庫讀寫分離配置。 兩個服務器的數據同

學會數據庫讀寫分離、分表分庫——用Mycat

切換 心跳 native 自動生成 拆分 運行 管理命令 users 業界 系統開發中，數據庫是非常重要的一個點。除了程序的本身的優化，如：SQL語句優化、代碼優化，數據庫的處理本身優化也是非常重要的。主從、熱備、分表分庫等都是系統發展遲早會遇到的技術問題問題。Myca

大型網站架構演進(5)數據庫讀寫分離

這一 流數據 tar share 讀數 應用 庫服務器 兩個 .com 原文:大型網站架構演進(5)數據庫讀寫分離　　在使用緩存後，使大部分的數據讀操作訪問都可以不通過數據庫就能完成，但是仍有一部分讀操作(包括未命中緩存的，和緩存過期的)和全部的寫操作需要訪問數據庫，當網站

想用數據庫“讀寫分離” 請先明白“讀寫分離”解決什麽問題

同時 rdquo 數據庫連接 aid 聚集 情況下 例如 容易 水平切分 https://baijiahao.baidu.com/s?id=1614304400276051465&wfr=spider&for=pc 有一些技術同學可能對於“讀寫

Spring+SpringMVc+Mybatis實現數據庫查詢

java代碼 格式 jdb web.xml配置 set ransac load idle name 大家好，本篇博客小Y將會給大家帶來一篇SSM框架實現數據查詢的Demo,使用的數據庫是Mysql,Server是TomCat.現在的SSM整合非常流行，因為springm

數據庫讀寫並發控制

寫鎖 外部 相同 nbsp try 丟失 重復 lock 行鎖 在數據庫中，並發控制是指在多個用戶/進程/線程同時對數據庫進行操作時，如何保證事務的一致性和隔離性的，同時最大程度地並發。 當多個用戶/進程/線程同時對數據庫進行操作時，會出現3種沖突情形： 讀-讀，不存在任

SQLite3數據庫讀寫

SQLite3 數據庫 //插入數據 #include <io.h> CppSQLite3DB db; BOOL re = _access("config.db", 0);//判文件是否存在 if (re != -1)//等於-1表示不存在 { db.open(&qu