在傳統的單機體系中，我們在操作資料庫時，只需要直接得到資料庫的連線，然後操作資料庫即可，可是在現在的資料爆炸時代，只靠單機是無法承載如此大的使用者量的，即我們不能縱向擴充套件，那麼我們就只能水平進行擴充套件，即使用讀寫分離的主從資料庫來緩解資料庫的壓力，而在讀寫分離之後，如何使程式能正確的得到主資料庫的連線或者是從資料庫的連線，就是我們今天讀寫分離的資料庫中介軟體需要實現的。

一、主從資料庫介紹：

  主從資料庫即為一個主資料庫會有對應n個從資料庫，而從資料庫只能有一個對應的從資料庫。主從資料庫中寫的操作需要使用主資料庫，而讀操作使用從資料庫。主資料庫與從資料庫始終保持資料一致性。其中保持資料庫一致的原理即為當主資料庫資料發生變化時，會將操作寫入到主資料庫日誌中，而從資料庫會不停的讀取主資料庫的日誌儲存到自己的日誌系統中，然後進行執行，從而保持了主從資料庫一致。

二、開發前準備及ConnectionFactory類的開發：

  在瞭解了主從資料庫後，我們可以進行分散式資料庫中介軟體的開發，由於mysql本身支援主從資料庫，但限於篇幅，就不講mysql的主從配置了，我們先使用本機的mysql作為一主兩從的資料庫源即可，下面是我本機的資料庫連線配置檔案，其中有一主兩從：

master.driver=com.mysql.jdbc.Driver
master.dburl=jdbc\:mysql\://127.0.0.1\:3306/master_slave_db
master.user=root
master.password=mytestcon

slave1.driver=com.mysql.jdbc.Driver
slave1.dburl=jdbc\:mysql\://127.0.0.1\:3306/master_slave_db
slave1.user=root
slave1.password=mytestcon

slave2.driver=com.mysql.jdbc.Driver
slave2.dburl=jdbc\:mysql\://127.0.0.1\:3306/master_slave_db
slave2.user=root
slave2.password=mytestcon
 

封裝的DataSource類：

public class DataSource {

    private String driver;

    private String url;

    private String user;

    private String password;


    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
 

    <bean id="masterDataSource" class="com.happyheng.connection.DataSource">
        <property name="driver" value="${master.driver}"/>
        <property name="url" value="${master.dburl}"/>
        <property name="user" value="${master.user}"/>
        <property name="password" value="${master.password}"/>
    </bean>

    <bean id="slaveDataSource1" class="com.happyheng.connection.DataSource">
        <property name="driver" value="${slave1.driver}"/>
        <property name="url" value="${slave1.dburl}"/>
        <property name="user" value="${slave1.user}"/>
        <property name="password" value="${slave1.password}"/>
    </bean>

    <bean id="slaveDataSource2" class="com.happyheng.connection.DataSource">
        <property name="driver" value="${slave2.driver}"/>
        <property name="url" value="${slave2.dburl}"/>
        <property name="user" value="${slave2.user}"/>
        <property name="password" value="${slave2.password}"/>
    </bean>

    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:dataSource.properties</value>
            </list>
        </property>
    </bean>

@Service
public class ConnectionFactory {

    @Autowired
    private DataSource masterDataSource;

    @Autowired
    private DataSource slaveDataSource1;

    @Autowired
    private DataSource slaveDataSource2;

    private List<DataSource> slaveDataSourceList;

    private int slaveDataSourceSize;


    @PostConstruct
    private void init() {
        slaveDataSourceList = new ArrayList<>();
        slaveDataSourceList.add(slaveDataSource1);
        slaveDataSourceList.add(slaveDataSource2);

        slaveDataSourceSize = slaveDataSourceList.size();
    }


    /**
     * 得到主資料的連線
     */
    public Connection getMasterConnection() {
        return getConnection(masterDataSource);
    }

    /**
     * 得到從資料庫的連線數量
     */
    public int getSlaveDataSourceSize() {
        return slaveDataSourceSize;
    }

    /**
     * 得到從資料n的連線
     */
    public Connection getSlaveConnection(int index){
        return getConnection(slaveDataSourceList.get(index));
    }


    private Connection getConnection(DataSource dataSource){

        Connection connection = null;
        try {
            Class.forName(dataSource.getDriver());

            connection = DriverManager.getConnection(dataSource.getUrl(), dataSource.getUser(), dataSource.getPassword());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }
}

三、Proxy代理類的實現：

  代理類即是可以讓程式中資料庫訪問得到正確的資料庫連線，所以稱為代理。

  1、使用ThreadLocal為當前執行緒指定資料庫訪問模式：

  由於Proxy不知道程式使用的是主資料庫還是從資料庫，所以程式在訪問資料庫之前要呼叫Proxy代理類來為當前執行緒打一個Tag，即指定是使用主資料庫還是從資料庫。由於而web伺服器中每個請求是多執行緒環境，所以使用ThreadLocal類：

  2、使用隨機法來訪問從資料庫：

  由於從資料庫有多個，所以我們可以使用隨機法來隨機訪問每個從資料庫，隨機法在高併發的情況下有很平均的分佈，效能也非常好。

  3、具體實現：

@Service
public class DataSourceProxy {

    ThreadLocal<String> dataSourceThreadLocal = new ThreadLocal<>();

    public static final String MASTER = "master";
    public static final String SLAVE = "slave";

    @Resource
    private ConnectionFactory connectionFactory;

    /**
     * 設定當前執行緒的資料庫Mode
     */
    public void setMode(String dataMode) {
        dataSourceThreadLocal.set(dataMode);
    }

    /**
     * 得到當前資料庫Mode
     */
    public String getMode() {
        return dataSourceThreadLocal.get();
    }

    /**
     * 根據當前Mode得到Connection連線物件
     */
    public Connection getThreadConnection() {

        // 1.判斷當前是從資料還是主資料庫,預設是主資料庫
        String mode = getMode();
        if (!StringUtils.isEmpty(mode) && SLAVE.equals(mode)) {

            // y1.如果是從資料庫,那麼使用隨機數的形式來得到從資料庫連線
            double random = Math.random();
            int index = (int) (random * connectionFactory.getSlaveDataSourceSize());

            System.out.println("----使用的為第" + (index + 1) + "從資料庫----");

            return connectionFactory.getSlaveConnection(index);
        } else {

            System.out.println("----使用的為主資料庫----");

            // f1.如果是主資料庫,因為只有一個,所以直接獲取即可
            return connectionFactory.getMasterConnection();
        }

    }

}

4、此工程已在github上開源，可以完整實現資料庫的讀寫分離，地址為：github 。如果覺得不錯，那麼就star一下來鼓勵我吧。