从零开发分布式数据库中间件一、读写分离的数据库中间件（转）

<h1>
    <span class="link_title"><a href="/happyheng/article/details/54176951">
    从零开发分布式数据库中间件 一、读写分离的数据库中间件        
       
    </a>
    </span>

     
</h1>

<div class="article_manage clearfix">
    <div class="article_l">
       
    </div>
</div>    <style type="text/css">        
        .embody{
            padding:10px 10px 10px;
            margin:0 -20px;
            border-bottom:solid 1px #ededed;                
        }
        .embody_b{
            margin:0 ;
            padding:10px 0;
        }
        .embody .embody_t,.embody .embody_c{
            display: inline-block;
            margin-right:10px;
        }
        .embody_t{
            font-size: 12px;
            color:#999;
        }
        .embody_c{
            font-size: 12px;
        }
        .embody_c img,.embody_c em{
            display: inline-block;
            vertical-align: middle;               
        }
         .embody_c img{               
            30px;
            height:30px;
        }
        .embody_c em{
            margin: 0 20px 0 10px;
            color:#333;
            font-style: normal;
        }
</style>
<script type="text/javascript">
    $(function () {
        try
        {
            var lib = eval("("+$("#lib").attr("value")+")");
            var html = "";
            if (lib.err == 0) {
                $.each(lib.data, function (i) {
                    var obj = lib.data[i];
                    //html += '<img src="' + obj.logo + '"/>' + obj.name + "&nbsp;&nbsp;";
                    html += ' <a href="' + obj.url + '" target="_blank">';
                    html += ' <img src="' + obj.logo + '">';
                    html += ' <em><b>' + obj.name + '</b></em>';
                    html += ' </a>';
                });
                if (html != "") {
                    setTimeout(function () {
                        $("#lib").html(html);                      
                        $("#embody").show();
                    }, 100);
                }
            }      
        } catch (err)
        { }
        
    });
</script>
  <div class="category clearfix">

在传统的单机体系中，我们在操作数据库时，只需要直接得到数据库的连接，然后操作数据库即可，可是在现在的数据爆炸时代，只靠单机是无法承载如此大的用户量的，即我们不能纵向扩展，那么我们就只能水平进行扩展，即使用读写分离的主从数据库来缓解数据库的压力，而在读写分离之后，如何使程序能正确的得到主数据库的连接或者是从数据库的连接，就是我们今天读写分离的数据库中间件需要实现的。

一、主从数据库介绍：

主从数据库即为一个主数据库会有对应n个从数据库，而从数据库只能有一个对应的从数据库。主从数据库中写的操作需要使用主数据库，而读操作使用从数据库。主数据库与从数据库始终保持数据一致性。其中保持数据库一致的原理即为当主数据库数据发生变化时，会将操作写入到主数据库日志中，而从数据库会不停的读取主数据库的日志保存到自己的日志系统中，然后进行执行，从而保持了主从数据库一致。

二、开发前准备及ConnectionFactory类的开发：

在了解了主从数据库后，我们可以进行分布式数据库中间件的开发，由于mysql本身支持主从数据库，但限于篇幅，就不讲mysql的主从配置了，我们先使用本机的mysql作为一主两从的数据库源即可，下面是我本机的数据库连接配置文件，其中有一主两从：

[java] view plain copy

print?

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

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类：

[java] view plain copy

print?

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;
}
}

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;
}

}

在Spring配置文件中，从配置文件中读取配置并将配置转换为封装的DataSource类：

[java] view plain copy

print?

<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>

    <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>
&lt;bean id="slaveDataSource1" class="com.happyheng.connection.DataSource"&gt;
    &lt;property name="driver" value="${slave1.driver}"/&gt;
    &lt;property name="url" value="${slave1.dburl}"/&gt;
    &lt;property name="user" value="${slave1.user}"/&gt;
    &lt;property name="password" value="${slave1.password}"/&gt;
&lt;/bean&gt;

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

&lt;bean id="propertyConfigurer"
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"&gt;
    &lt;property name="locations"&gt;
        &lt;list&gt;
            &lt;value&gt;classpath:dataSource.properties&lt;/value&gt;
        &lt;/list&gt;
    &lt;/property&gt;
&lt;/bean&gt;</pre>有了主从的连接之后，我们就可以写一个ConnectionFactory类，此类可以为外部类直接提供主数据库、从数据库的连接，相当于数据库连接的封装：<br>


[java] view plain copy print?
@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;  
    }  
}  
@Service
public class ConnectionFactory {
@Autowired
private DataSource masterDataSource;

@Autowired
private DataSource slaveDataSource1;

@Autowired
private DataSource slaveDataSource2;

private List&lt;DataSource&gt; slaveDataSourceList;

private int slaveDataSourceSize;


@PostConstruct
private void init() {
    slaveDataSourceList = new ArrayList&lt;&gt;();
    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;
}

}
封装完成后，我们就可以使用getMasterConnection()直接得到主数据库的连接，使用getSlaveConnection(int)可以得到从数据库1或者是从数据2的连接。



三、Proxy代理类的实现：
  代理类即是可以让程序中数据库访问得到正确的数据库连接，所以称为代理。
  1、使用ThreadLocal为当前线程指定数据库访问模式：
  由于Proxy不知道程序使用的是主数据库还是从数据库，所以程序在访问数据库之前要调用Proxy代理类来为当前线程打一个Tag，即指定是使用主数据库还是从数据库。由于而web服务器中每个请求是多线程环境，所以使用ThreadLocal类：
  2、使用随机法来访问从数据库：
  由于从数据库有多个，所以我们可以使用随机法来随机访问每个从数据库，随机法在高并发的情况下有很平均的分布，性能也非常好。
  3、具体实现：
[java] view plain copy print?
@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();  
        }  
  
    }  
  
}  
@Service
public class DataSourceProxy {
ThreadLocal&lt;String&gt; dataSourceThreadLocal = new ThreadLocal&lt;&gt;();

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) &amp;&amp; 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一下来鼓励我吧。

    </div>
 <div class="tracking-ad" data-mod="popu_222"><a href="javascript:void(0);" target="_blank">&nbsp;</a>   </div>
<div class="tracking-ad" data-mod="popu_223"> <a href="javascript:void(0);" target="_blank">&nbsp;</a></div>
<script type="text/javascript">
    function btndigga() {
        $(".tracking-ad[data-mod='popu_222'] a").click();
    }
    function btnburya() {
        $(".tracking-ad[data-mod='popu_223'] a").click();
    }
        </script>

相关阅读:
DP_knapsack
也谈交换两个变量
 SidebySide Assembly
Generate permutation for N elements
Pixel Shader 像素着色
 Drill into View Matrix
使用D3DXCreateSphere绘图的步骤
 原来VisualStudio本身也可以查看调试信息
 DirectX Effects初探
 Shortcuts
原文地址：https://www.cnblogs.com/jpfss/p/8136349.html

从零开发分布式数据库中间件 一、读写分离的数据库中间件（转）

从零开发分布式数据库中间件一、读写分离的数据库中间件（转）