1.先上原理图

2.说明

两个mysql采用主主同步的方式进行部署。

在安装mysql的服务器上安装客户端(目前是这么做,以后想在zookeeper扩展集成),客户端实时监控mysql应用的可用性,可用时想zookeepercreateNode,当网络不可用或者mysql应用不可用时,建立的znode消失。

在客户端,通过改造proxool数据库连接池的方式,在建立连接之前,从zookeeper中去取真实的数据库URL,如果有多个URL,即有多个服务时,采用随机算法去拿连接(以后准备扩展权重)。当连接不可用时,数据库连接池将重建连接,这时候又回去zookeeper拿连接,因为agent建立的临时znode消失了,就不能拿到已经失效的url了。

这个方案只是初步的实验和实现了,还有很多后续的问题,主要为了解决lvs+keepalived只能在同一个区域内的问题。

3.部分实现

  1).agent

  

/**
* 数据库可用性检测
* @author tomsnail
* @date 2015年4月3日 上午10:11:51
*/
public class TestMySQL { public static boolean test(String url){ Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
String sql = ConfigHelp.getLocalConifg("jdbc_inventory.house-keeping-test-sql", "select 0");
try {
Class.forName(ConfigHelp.getLocalConifg("jdbc_inventory.driver-class", "com.mysql.jdbc.Driver"));// 动态加载mysql驱动
conn = DriverManager.getConnection(url);
stmt = conn.createStatement();
rs = stmt.executeQuery(sql);
while (rs.next()) {
}
return true;
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(rs!=null){
rs.close();
}
if(stmt!=null){
stmt.close();
}
if(conn!=null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
} }
return false;
}
}
/**
* zookeeper客户端
* @author tomsnail
* @date 2015年4月3日 上午10:11:51
*/
public class TestServer { private static final Logger logger = LoggerFactory
.getLogger(TestServer.class); private static ZooKeeper zk; private String path; //同步锁
private Lock _lock = new ReentrantLock(); // 用于等待 SyncConnected 事件触发后继续执行当前线程
private CountDownLatch latch = new CountDownLatch(1); public TestServer() {
zk = connectServer();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//logger.info("check zk...");
_lock.lock();
if (zk != null) {
if (zk.getState().isAlive()
&& zk.getState().isConnected()) {
//logger.info("zk is ok");
_lock.unlock();
continue;
}
}
close();
logger.info("reConnectServer ...");
zk = connectServer();
logger.info("reConnectServer ok");
_lock.unlock();
} } private void close() {
if(zk!=null){
try {
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
zk = null;
}
}
}).start();
} // 连接 ZooKeeper 服务器
private ZooKeeper connectServer() {
ZooKeeper zk = null;
try { zk = new ZooKeeper(ConfigHelp.ZK_CONNECTION_STRING,
ConfigHelp.ZK_SESSION_TIMEOUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown(); // 唤醒当前正在执行的线程
}
}
});
latch.await(); // 使当前线程处于等待状态
} catch (Exception e) {
logger.error("", e);
}
if (zk != null) {
try {
Stat stat = zk.exists(ConfigHelp.ZK_ROOT_PATH, false);
if (stat == null) {
String path = zk.create(ConfigHelp.ZK_ROOT_PATH,
"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT); // 创建一个临时性且有序的 ZNode
logger.info("create zookeeper node ({})", path);
}
stat = zk.exists(ConfigHelp.ZK_RMI_PATH, false);
if (stat == null) { String path = zk.create(ConfigHelp.ZK_RMI_PATH,
"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT); // 创建一个临时性且有序的 ZNode
logger.info("create zookeeper node ({})", path);
}
} catch (Exception e) {
e.printStackTrace();
}
}
return zk;
} // 创建 ZNode
public void createNode(String url) {
_lock.lock();
try {
byte[] data = url.getBytes();
path = zk.create(ConfigHelp.ZK_RMI_PATH + "/", data,
ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.EPHEMERAL_SEQUENTIAL); // 创建一个临时性且有序的 ZNode
logger.info("create zookeeper node ({} => {})", path, url);
} catch (Exception e) {
logger.error("", e);
e.printStackTrace();
}
_lock.unlock();
} public void deleteNode(String url){
_lock.lock();
try {
Stat stat = zk.exists(path, false);
if(stat!=null){
zk.delete(url, stat.getVersion());
}
} catch (Exception e) {
e.printStackTrace();
}
_lock.unlock();
}
}
/**
* 数据库检测测试主类
* @author tomsnail
* @date 2015年4月3日 上午10:11:51
*/
public class TestMain { private static TestServer testServer = new TestServer(); public static void main(String[] args) {
String url = ConfigHelp.getLocalConifg("jdbc_inventory.driver-url", "select 0");
boolean isOK = false;
while(true){
if(TestMySQL.test(url)){
if(isOK){ }else{
testServer.createNode(url);//建立znode
}
isOK = true;
}else{
isOK = false;
testServer.deleteNode(url);//删除znode
} try {
Thread.currentThread().sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

  2).proxool

/**
* zookeeper信息定义类
* @author tomsnail
* @date 2015年4月2日 下午6:49:13
*/
public class ZkInfoDefinition { public static final String PREFIX_ZK = "zookeeper"; public static final String ZK_URL = "zkUrl"; public static final String ZK_SESSION_TIMEOUT = "sessionTimeout"; public static final String ZK_PATH = "zkPath"; public static final String ZK_ENABLE = "zkEnable"; public static String zkUrl="192.168.102.1:31315"; public static int sessionTimeout = 5000; public static boolean isEnable = false; public static String zkPath = "/root/db"; public String getZkUrl() {
return zkUrl;
} public void setZkUrl(String zkUrl) {
this.zkUrl = zkUrl;
} public int getSessionTimeout() {
return sessionTimeout;
} public void setSessionTimeout(int sessionTimeout) {
this.sessionTimeout = sessionTimeout;
} public String getZkPath() {
return zkPath;
} public void setZkPath(String zkPath) {
this.zkPath = zkPath;
} public ZkInfoDefinition(String zkUrl, int sessionTimeout, String zkPath) {
super();
this.zkUrl = zkUrl;
this.sessionTimeout = sessionTimeout;
this.zkPath = zkPath;
}
public ZkInfoDefinition(){ }
}
/**
* zookeeper客户端
* @author tomsnail
* @date 2015年4月3日 上午10:15:11
*/
public class ZkClient { private static final Logger logger = LoggerFactory.getLogger(ZkClient.class); // 用于等待 SyncConnected 事件触发后继续执行当前线程
private CountDownLatch latch = new CountDownLatch(1); // 定义一个 volatile 成员变量,用于保存最新的 RMI 地址(考虑到该变量或许会被其它线程所修改,一旦修改后,该变量的值会影响到所有线程)
private volatile List<String> dataList = new ArrayList<String>(); private Lock _lock = new ReentrantLock(); private static ZooKeeper zk; private LBUrl lbUrl; public ZkClient(){
this(new BasicLBUrl());
} // 构造器
public ZkClient(LBUrl lbUrl) {
this.lbUrl = lbUrl;
zk = connectServer(); // 连接 ZooKeeper 服务器并获取 ZooKeeper 对象
watchNode();
new Thread(new Runnable() { @Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
_lock.lock();
if (zk != null) {
if (zk.getState().isAlive()
&& zk.getState().isConnected()) {
_lock.unlock();
continue;
}
}
if(zk!=null){
try {
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
zk = null;
}
zk = connectServer();
_lock.unlock();
}
}
}).start();
} // 查找 URL 服务
public String getUrl() {
if (dataList!=null&&dataList.size()>0) {
return this.lbUrl.getUrl(dataList);
}
return null;
} public List<String> getUrls(){
return dataList;
} // 连接 ZooKeeper 服务器
private ZooKeeper connectServer() {
ZooKeeper zk = null;
try {
zk = new ZooKeeper(ZkInfoDefinition.zkUrl, ZkInfoDefinition.sessionTimeout, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown(); // 唤醒当前正在执行的线程
}
}
});
latch.await(); // 使当前线程处于等待状态
} catch (Exception e) {
logger.error("", e);
}
return zk;
} // 观察 /registry 节点下所有子节点是否有变化
private void watchNode() {
_lock.lock();
if(zk!=null&&zk.getState().isAlive()&&zk.getState().isConnected()){ }else{
if(zk!=null){
try {
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
}
zk = null;
}
zk = connectServer();
}
try {
List<String> nodeList = zk.getChildren(ZkInfoDefinition.zkPath, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeChildrenChanged) {
watchNode(); // 若子节点有变化,则重新调用该方法(为了获取最新子节点中的数据)
}
}
});
List<String> dataList = new ArrayList<String>(); // 用于存放 /registry 所有子节点中的数据
for (String node : nodeList) {
byte[] data = zk.getData(ZkInfoDefinition.zkPath + "/" + node, false, null); // 获取 /registry 的子节点中的数据
dataList.add(new String(data)); }
logger.debug("node data: {}", dataList);
this.dataList = dataList;
} catch (Exception e) {
logger.error("", e);
}
_lock.unlock();
} public static void main(String[] args) {
ZkClient client = new ZkClient();
System.out.println(client.getUrl());
}
}
/**
* 从zookeeper获得URL连接操作类
* @author tomsnail
* @date 2015年4月2日 下午6:56:06
*/
public class ZkUrlOperation { private static final ZkUrlOperation instance = new ZkUrlOperation(); private static ZkInfoDefinition zkInfoDefinition; private static ZkClient zkClient; private static final byte[] _lock = new byte[0]; private ZkUrlOperation(){ } public static ZkUrlOperation getInstance(){
return instance;
} public void addZkInfoDefinition(ZkInfoDefinition zkInfoDefinition){
ZkUrlOperation.zkInfoDefinition = zkInfoDefinition;
} public void addZkInfoDefinition(String key,String value){
if(ZkUrlOperation.zkInfoDefinition==null){
ZkUrlOperation.zkInfoDefinition = new ZkInfoDefinition();
}
if(key.contains(ZkInfoDefinition.ZK_PATH)){
ZkUrlOperation.zkInfoDefinition.setZkPath(value);
}
if(key.contains(ZkInfoDefinition.ZK_SESSION_TIMEOUT)){
ZkUrlOperation.zkInfoDefinition.setSessionTimeout(Integer.valueOf(value));;
}
if(key.contains(ZkInfoDefinition.ZK_URL)){
ZkUrlOperation.zkInfoDefinition.setZkUrl(value);;
}
if(key.contains(ZkInfoDefinition.ZK_ENABLE)){
ZkUrlOperation.zkInfoDefinition.isEnable = Boolean.valueOf(value);
}
} public String getUrl(){
synchronized (_lock) {
if(zkInfoDefinition.isEnable){
if(zkClient==null){
zkClient = new ZkClient();
} String url = zkClient.getUrl();
return url;
}else{
return "";
} } } public boolean isAvailUrl(String url){
synchronized (_lock) {
if(zkInfoDefinition.isEnable){
if(zkClient==null){
zkClient = new ZkClient();
}
List<String> urls = zkClient.getUrls();
for(int i=0;i<urls.size();i++){
if(url.equals(urls.get(i))){
return true;
}
}
return false;
}
return false; } } }

基于zookeeper的MySQL主主负载均衡的简单实现的更多相关文章

  1. MySQL主主双机负载均衡

    MySQL双机主主架构,其上辅以负载均衡设备,可以实现mysql数据库的负载均衡高性能和高可用性,负载均衡设备可以根据算法将数据库操作的负 载平均分到两台MySQL服务器上,这样对于每台服务器来说工作 ...

  2. 搭建MySQL高可用负载均衡集群

    1.简介 使用MySQL时随着时间的增长,用户量以及数据量的逐渐增加,访问量更是剧增,最终将会使MySQL达到某个瓶颈,那么MySQL的性能将会大大降低.这一结果也不利于软件的推广. 那么如何跨过这个 ...

  3. 搭建MySQL高可用负载均衡集群(转)

    阅读目录 1.简介 2.基本环境 3.配置MySQL主主复制 4.中间件简述 4.1.Haproxy介绍 4.2.keepalived介绍 5.中间件的安装与配置(haproxy.keepalived ...

  4. [转]搭建MySQL高可用负载均衡集群

    转自:http://www.cnblogs.com/phpstudy2015-6/p/6706465.html 阅读目录 1.简介 2.基本环境 3.配置MySQL主主复制 4.中间件简述 4.1.H ...

  5. 【Nginx】如何使用Nginx实现MySQL数据库的负载均衡?看完我懂了!!

    写在前面 Nginx能够实现HTTP.HTTPS协议的负载均衡,也能够实现TCP协议的负载均衡.那么,问题来了,可不可以通过Nginx实现MySQL数据库的负载均衡呢?答案是:可以.接下来,就让我们一 ...

  6. Nginx基于TCP/UDP端口的四层负载均衡(stream模块)配置梳理

    通过我们会用Nginx的upstream做基于http/https端口的7层负载均衡,由于Nginx老版本不支持tcp协议,所以基于tcp/udp端口的四层负载均衡一般用LVS或Haproxy来做.至 ...

  7. 基于Consul+Upsync+Nginx实现动态负载均衡

    基于Consul+Upsync+Nginx实现动态负载均衡 1.Consul环境搭建 下载consul_0.7.5_linux_amd64.zip到/usr/local/src目录 cd /usr/l ...

  8. nginx负载均衡的简单实现

    负载均衡是我们大流量网站要做的一个东西,下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法,希望对有需要的同学有所帮助哦. 负载均衡 先来简单了解一下什么是负载均衡,单从字面上的意思来理解就可 ...

  9. Nginx实现负载均衡的简单案例

    七层负载均衡的实现(Nginx): 基于URL等应用层信息的负载均衡,一般使用Nginx来实现 Nginx的proxy是它一个很强大的功能,实现了7层负载均衡 功能强大.性能卓越.运行稳定 配置简单灵 ...

  10. Nginx负载均衡配置简单配置方法

    http://www.jb51.net/article/121235.htm Nginx作为负载均衡服务器,用户请求先到达nginx,再由nginx根据负载配置将请求转发至不同的Web服务器.下面通过 ...

随机推荐

  1. python实现接口测试到unittest框架集成

    接口测试是面试测试岗位基本都会问到的问题,但是对于一些刚做测试的小伙伴可能并不是很熟悉,也有可能了解接口测试,但是完全不知道接口自动化怎么做.下面我们大概介绍一下. 首先我们需要知道接口自动化测试的目 ...

  2. 利用expload 分割字符串 变成数组

    #admin_abc去掉下划线 =>>变成 array('admin','abc') $table_Name=explode('_', $table_Name);

  3. 调整图像的尺寸 - cvResize() 函数实现

    前言 有时会碰到一张图片太大了,想将它缩小.本文将讲解一个很好用的函数解决这个问题. 图像尺寸调整函数 cvResize() // 图像尺寸调整函数 void Resize ( const CvArr ...

  4. Micro Python:运行在微控制器上的Python

    Micro Python运行在微控制器上的Python.遵守MIT协议.由剑桥大学的理论物理学家乔治·达明设计.和Arduino类似,但Micro Python更强大. Micro Python的软件 ...

  5. Android开发:LocationManager获取经纬度及定位过程(附demo)

    在Android开发其中.常常须要用到定位功能,尤其是依赖于地理位置功能的应用.非常多人喜欢使用百度地图,高德地图提供的sdk.开放API,可是在只须要经纬度,或者城市,街道地址等信息.并不须要提供预 ...

  6. jQuery+bootstrap实现美化警告/确认/提示对话框插件

    http://www.html580.com/12067/demo http://craftpip.github.io/jquery-confirm/

  7. 【BZOJ3997】[TJOI2015]组合数学 最长反链

    [BZOJ3997][TJOI2015]组合数学 Description 给出一个网格图,其中某些格子有财宝,每次从左上角出发,只能向下或右走.问至少走多少次才能将财宝捡完.此对此问题变形,假设每个格 ...

  8. 【BZOJ3295】[Cqoi2011]动态逆序对 cdq分治

    [BZOJ3295][Cqoi2011]动态逆序对 Description 对于序列A,它的逆序对数定义为满足i<j,且Ai>Aj的数对(i,j)的个数.给1到n的一个排列,按照某种顺序依 ...

  9. shell实现mysql热备份

    #!/bin/bash #my.hc.sh PATH=/usr/local/sbin:/usr/bin:/bin BACKDIR = /backup/mysql ROOTPASS = ******** ...

  10. Django项目高频使用文件

    数据库配置: MySQL数据库 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'HOST': 'localhost' ...