Mysql主从复制读写分离连接的获取

最新推荐文章于 2023-09-05 17:27:35 发布
最新推荐文章于 2023-09-05 17:27:35 发布
阅读量148 收藏
点赞数
分类专栏： JDBC 文章标签： jdbc mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Donald_Draper/article/details/88307157
版权
JDBC驱动初始化-Mysql:[url]http://donald-draper.iteye.com/blog/2342010[/url]
JDBC连接的获取：[url]http://donald-draper.iteye.com/blog/2342011[/url]
Mysql负载均衡连接的获取：[url]http://donald-draper.iteye.com/blog/2342089[/url]
Mysql主从复制读写分离连接的获取：[url]http://donald-draper.iteye.com/blog/2342108[/url]
ConnectionImp创建MysqlIO ：[url]http://donald-draper.iteye.com/blog/2342959[/url]
Mysql预编译SQL：[url]http://donald-draper.iteye.com/blog/2342960[/url]
MysqlSQL PreparedStatement的查询:[url]http://donald-draper.iteye.com/blog/2343083[/url]
MySQL ServerPreparedStatement查询：[url]http://donald-draper.iteye.com/blog/2343124[/url]
前面讲过Driver的初始化，单机Server连接的获取，负载均衡连接的获取，今天讲一下主从复制，读写分析连接的获取：
从下面一段代码来看：
//如果url以jdbc:mysql:replication://则调用集群连接获取方法 
if(StringUtils.startsWithIgnoreCase(url, "jdbc:mysql:replication://"))
return connectReplicationConnection(url, info);

//NonRegisteringDriver 
private Connection connectReplicationConnection(String url, Properties info)
        throws SQLException
    {
        Properties parsedProps = parseURL(url, info);
        if(parsedProps == null)
            return null;
        Properties masterProps = (Properties)parsedProps.clone();
        Properties slavesProps = (Properties)parsedProps.clone();
        slavesProps.setProperty("com.mysql.jdbc.ReplicationConnection.isSlave", "true");
        String hostValues = parsedProps.getProperty("HOST");
        if(hostValues != null)
        {
            StringTokenizer st = new StringTokenizer(hostValues, ",");
            StringBuffer masterHost = new StringBuffer();
            StringBuffer slaveHosts = new StringBuffer();
	    //Url中第一个host为master，后面为Slave
            if(st.hasMoreTokens())
            {
                String hostPortPair[] = parseHostPortPair(st.nextToken());
                if(hostPortPair[0] != null)
                    masterHost.append(hostPortPair[0]);
                if(hostPortPair[1] != null)
                {
                    masterHost.append(":");
                    masterHost.append(hostPortPair[1]);
                }
            }
            boolean firstSlaveHost = true;
            do
            {
                if(!st.hasMoreTokens())
                    break;
                String hostPortPair[] = parseHostPortPair(st.nextToken());
                if(!firstSlaveHost)
                    slaveHosts.append(",");
                else
                    firstSlaveHost = false;
                if(hostPortPair[0] != null)
                    slaveHosts.append(hostPortPair[0]);
                if(hostPortPair[1] != null)
                {
                    slaveHosts.append(":");
                    slaveHosts.append(hostPortPair[1]);
                }
            } while(true);
            if(slaveHosts.length() == 0)
                throw SQLError.createSQLException("Must specify at least one slave host to connect to for master/slave replication load-balancing functionality", "01S00", null);
            //MaterHost
	    masterProps.setProperty("HOST", masterHost.toString());
	    //SlaveHost
            slavesProps.setProperty("HOST", slaveHosts.toString());
        }
        return new ReplicationConnection(masterProps, slavesProps);
    }

我们来看一下ReplicationConnection 
public class ReplicationConnection
    implements Connection, PingTarget
{  
    protected Connection currentConnection;//当前连接
    protected Connection masterConnection;//主连接
    protected Connection slavesConnection;//从连接
    public ReplicationConnection(Properties masterProperties, Properties slaveProperties)
        throws SQLException
    {
        NonRegisteringDriver driver = new NonRegisteringDriver();
        StringBuffer masterUrl = new StringBuffer("jdbc:mysql://");
        StringBuffer slaveUrl = new StringBuffer("jdbc:mysql://");
        String masterHost = masterProperties.getProperty("HOST");
	//初始化Master与Slave的URL
        if(masterHost != null)
            masterUrl.append(masterHost);
        String slaveHost = slaveProperties.getProperty("HOST");
        if(slaveHost != null)
            slaveUrl.append(slaveHost);
        String masterDb = masterProperties.getProperty("DBNAME");
        masterUrl.append("/");
        if(masterDb != null)
            masterUrl.append(masterDb);
        String slaveDb = slaveProperties.getProperty("DBNAME");
        slaveUrl.append("/");
        if(slaveDb != null)
            slaveUrl.append(slaveDb);
        slaveProperties.setProperty("roundRobinLoadBalance", "true");
	//从Driver获取Master连接
        masterConnection = (Connection)driver.connect(masterUrl.toString(), masterProperties);
	//从Driver获取Slave连接
        slavesConnection = (Connection)driver.connect(slaveUrl.toString(), slaveProperties);
        slavesConnection.setReadOnly(true);
	//当前连接为masterConnection
        currentConnection = masterConnection;
    }
    public synchronized void setReadOnly(boolean readOnly)
        throws SQLException
    {
        if(readOnly)
        {
            if(currentConnection != slavesConnection)
                switchToSlavesConnection();
        } else
        if(currentConnection != masterConnection)
            switchToMasterConnection();
    }
    //Master与SLave连接切换
     private synchronized void switchToMasterConnection()
        throws SQLException
    {
        swapConnections(masterConnection, slavesConnection);
    }
    //Slave与Master连接切换
    private synchronized void switchToSlavesConnection()
        throws SQLException
    {
        swapConnections(slavesConnection, masterConnection);
    }
    //切换连接
    private synchronized void swapConnections(Connection switchToConnection, Connection switchFromConnection)
        throws SQLException
    {
        String switchFromCatalog = switchFromConnection.getCatalog();
        String switchToCatalog = switchToConnection.getCatalog();
        if(switchToCatalog != null && !switchToCatalog.equals(switchFromCatalog))
            switchToConnection.setCatalog(switchFromCatalog);
        else
        if(switchFromCatalog != null)
            switchToConnection.setCatalog(switchFromCatalog);
        boolean switchToAutoCommit = switchToConnection.getAutoCommit();
        boolean switchFromConnectionAutoCommit = switchFromConnection.getAutoCommit();
        if(switchFromConnectionAutoCommit != switchToAutoCommit)
            switchToConnection.setAutoCommit(switchFromConnectionAutoCommit);
        int switchToIsolation = switchToConnection.getTransactionIsolation();
        int switchFromIsolation = switchFromConnection.getTransactionIsolation();
        if(switchFromIsolation != switchToIsolation)
            switchToConnection.setTransactionIsolation(switchFromIsolation);
        currentConnection = switchToConnection;
    }
    //回滚
     public synchronized void rollback()
        throws SQLException
    {
        currentConnection.rollback();
    }

    public synchronized void rollback(Savepoint savepoint)
        throws SQLException
    {
        currentConnection.rollback(savepoint);
    }
    //设置是否自动提交
    public synchronized void setAutoCommit(boolean autoCommit)
        throws SQLException
    {
        currentConnection.setAutoCommit(autoCommit);
    }
    public PreparedStatement prepareStatement(String sql)
        throws SQLException
    {
        PreparedStatement pstmt = currentConnection.prepareStatement(sql);
        ((com.mysql.jdbc.Statement)pstmt).setPingTarget(this);
        return pstmt;
    }
    public CallableStatement prepareCall(String sql)
        throws SQLException
    {
        return currentConnection.prepareCall(sql);
    }
}

总结：
[color=blue]从上面可以看出，主从集群的连接获取，首先解析url分离出Mater host和Slave host，第一个为Master，后面为Slave，NonRegisteringDriver创建复制连接时，返回的是一个ReplicationConnection，而ReplicationConnection内有三个连接分别为，currentConnection，masterConnection，slavesConnection，
这三个连接实际上是ConnectionImpl；默认情况下currentConnection为masterConnection，当我们设置readonly为true时，切换到slavesConnection，为false，切换到masterConnection；；ReplicationConnection的相关方法的实现，实际上是调用ConnectionImpl的相应方法。[/color]
//NonRegisteringReplicationDriver 
public class NonRegisteringReplicationDriver extends NonRegisteringDriver
{

    public NonRegisteringReplicationDriver()
        throws SQLException
    {
    }

    public Connection connect(String url, Properties info)
        throws SQLException
    {
        Properties parsedProps = parseURL(url, info);
        if(parsedProps == null)
            return null;
        Properties masterProps = (Properties)parsedProps.clone();
        Properties slavesProps = (Properties)parsedProps.clone();
        slavesProps.setProperty("com.mysql.jdbc.ReplicationConnection.isSlave", "true");
        String hostValues = parsedProps.getProperty("HOST");
        if(hostValues != null)
        {
            StringTokenizer st = new StringTokenizer(hostValues, ",");
            StringBuffer masterHost = new StringBuffer();
            StringBuffer slaveHosts = new StringBuffer();
            if(st.hasMoreTokens())
            {
                String hostPortPair[] = parseHostPortPair(st.nextToken());
                if(hostPortPair[0] != null)
                    masterHost.append(hostPortPair[0]);
                if(hostPortPair[1] != null)
                {
                    masterHost.append(":");
                    masterHost.append(hostPortPair[1]);
                }
            }
            boolean firstSlaveHost = true;
            do
            {
                if(!st.hasMoreTokens())
                    break;
                String hostPortPair[] = parseHostPortPair(st.nextToken());
                if(!firstSlaveHost)
                    slaveHosts.append(",");
                else
                    firstSlaveHost = false;
                if(hostPortPair[0] != null)
                    slaveHosts.append(hostPortPair[0]);
                if(hostPortPair[1] != null)
                {
                    slaveHosts.append(":");
                    slaveHosts.append(hostPortPair[1]);
                }
            } while(true);
            if(slaveHosts.length() == 0)
                throw SQLError.createSQLException("Must specify at least one slave host to connect to for master/slave replication load-balancing functionality", "01S00", null);
            masterProps.setProperty("HOST", masterHost.toString());
            slavesProps.setProperty("HOST", slaveHosts.toString());
        }
        return new ReplicationConnection(masterProps, slavesProps);
    }
}
Donald_Draper
关注
专栏目录
vivado中工程调试出现的一些critical Messages解决方法
nature_forest的博客
08-19 1万+
1. create_clock:No valid object(s) found for '-objects[get_ports{pcie_sys_clk_clk_p[0]}]'. 这个错误的原因是我在源代码的基础上又包了一层，包了一个顶层，然后输入的信号input pcie_sys_clk_clk_p 需要在后面加一句声明 wirepcie_sys_clk_clk_p； 加上后就...
Mysql 读写分离
syztoo
05-14 592
一、介绍 1.什么是读写分离 读写分离的基本原理是将数据库读和写操作分散到不同的节点上。Mysql 的读写分离需要建立在主从复制基础之上，Master 数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而 Slave 数据库处理SELECT查询操作，Master 数据库的写操作导致的变更通过主从复制架构同步到集群中的 Slave 数据库中。 2.应用场景 因为数据...
mysql数据库主从设置配置
移动互联网后端服务架构
07-20 600
mysql版本：mysql Ver 14.14 Distrib 5.1.73master 设置： server-id=1 //master都设置成1 log-bin=/data/mysql/log_bin_save // binary文件存储路径 binlog_do_db=shenbian //需要同步的数据库 GRANT REPLICATION SLAVE,REPLICATI
如何解决mysql的master-slave模式中ReplicationDriver的使用问题
求贤若渴, 礼贤下士
06-19 738
/** * 作者：张荣华 * 日期：2008-6-19 **/ 前言： 之前downpour有一个贴([url]http://www.iteye.com/topic/143714[/url])讨论了在java中如何使用mysql的master-slave模式(master-slave模式的介绍见Qieqie的这个贴：[url]http://www.iteye.com/to...
You must specify at least one directory for a flat directory repository.
u012540309的博客
02-08 6560
You must specify at least one directory for a flat directory repository.配置gradle时出现这个错误，repositories { flatDir { //dirs 'libs' } }是不小心把libs注释掉了，去掉注释就ok了...
详解MySQL主从复制读写分离搭建
12-16
MySQL主从复制，读写分离的设置非常简单： 修改配置my.cnf文件 master 和 slave设置的差不多： [mysqld] log-bin=mysql-bin server-id=222 log-bin=mysql-bin的意思是：启用二进制日志。 server-id=222的意思是...
MySQL主从复制读写分离.zip
03-14
MySQL主从复制与读写分离是数据库架构中的重要策略，用于提高系统性能和可用性。在高并发的互联网应用中，这种设计模式尤为常见。本文将深入探讨这两个概念及其实施方法。 **一、MySQL主从复制** MySQL主从复制是...
mysql主从复制读写分离的配置方法详解
09-09
MySQL主从复制和读写分离是数据库高可用性和性能优化的重要技术。主从复制确保数据在多个服务器间同步，而读写分离则可以提高数据库处理并发请求的能力，尤其适用于读多写少的应用场景。 主从复制配置过程如下： 1...
MySQL主从复制 读写分离
06-24
根据提供的文件信息，我们可以总结出以下关于MySQL主从复制与读写分离的相关知识点： ### MySQL主从复制原理 MySQL主从复制是一种数据同步机制，它允许将一个MySQL服务器（主服务器）上的数据自动复制到一个或多个...
[Common 17-55] ‘set_property‘ expects at least one object. Resolution: If [get_＜value＞] was used to
jingjiankai5228的博客
06-05 1万+
vivado2018.4遇到此问题可以直接升级到18.3版本即可
vivado约束文件报错
热门推荐
ningjinghai11的博客
05-24 4万+
'set_property' expects at least one object报XDC里面的set_property找不到正确的object，这个在vivado后续版本中都显示为警告，一般都是处于object的port名大小写问题。XDC和Verilog都对大小写敏感。建议RTL内部接口定义全部用小写。错误： set_property PACKAGE_PIN "V7 " [get_ports...
FPGA编译报错内容[Common 17-55] ‘set_property‘ expects at least one object.
最新发布
m0_50993874的博客
09-05 1万+
FPGA代码编译时报错。
Vivado Error：[Place 30-602]IO port ‘InClk‘ is driving multiple buffers.解决方法
独木舟216的博客
09-05 3330
此篇是我在学习中做的归纳与总结，其中如果存在版权或知识错误请直接联系我，欢迎留言。 PS:本着知识共享的原则，此篇博客可以转载，但请标明出处！ Error描述： [Place 30-602] IO port 'InClk' is driving multiple buffers. This will lead to unplaceable/unroutable situation. The buffers connected are: u_DispTop/u_D...
WARNING: [Labtools 27-3413] vivado报错调试界面无信号无波形解决方法
nature_forest的博客
03-02 2万+
vivado----fpga硬件调试 (五) ----找不到ila核问题及解决，WARNING: [Labtools 27-3413]
vivado报位置约束指令的critical warning
weixin_44943244的博客
11-30 5333
位置约束指令的critical warning： [Common 17-55] ‘set_property’ expects at least one object. [“F:/prj/ip_updata_prj/test_name/test_name.srcs/constrs_1/imports/xdc/top.xdc”:57] top.xdc里输入这两条指令会报上面两条指令。 set_property LOC FE_X0Y3 [get_cells */DUT0/inst/FE_I] set_proper
mysql主从连接串,Mysql主从复制读写分离连接的获取
weixin_42098759的博客
03-17 269
JDBC驱动初始化-Mysql:http://www.voidcn.com/article/p-fzvwitdv-boq.htmlJDBC连接的获取：http://www.voidcn.com/article/p-krnatvgp-boq.htmlMysql负载均衡连接的获取：http://www.voidcn.com/article/p-kdfkoeud-boq.htmlMysql主从复制读写分...
mysql主从java连接_Mysql主从复制读写分离连接的获取
weixin_35650041的博客
02-02 414
http://donald-draper.iteye.com/blog/2342010JDBC连接的获取：http://donald-draper.iteye.com/blog/2342011Mysql负载均衡连接的获取：http://donald-draper.iteye.com/blog/2342089Mysql主从复制读写分离连接的获取：http://donald-draper.iteye....
Mycat实现MySQL主从复制读写分离配置实战
"这篇教程详细介绍了如何在Mycat中配置基于Mysql的主从复制和读写分离，适合DBA学习。文章首先提到了软件环境，包括Windows 7操作系统，Mycat-server 1.6版本，JDK 1.8以及两台Mysql 5.6服务器。接着，文章阐述了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值