DruidDataSource 通过编码方式实现数据库读写分离。

最新推荐文章于 2024-07-24 11:33:36 发布
最新推荐文章于 2024-07-24 11:33:36 发布
阅读量6.8k 收藏 3
点赞数
分类专栏： Java(功能篇) java 基础知识 MySQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/52936256
版权

源码：DruidDataSourceFactory创建数据库连接DataSource

package com.common.common.util.mysql;

import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DataSourceUtil {
	  /** 使用配置文件构建Druid数据源. */  
    public static final int DRUID_MYSQL_MASTER = 1;  
	  /** 使用配置文件构建Druid数据源. */  
    public static final int DRUID_MYSQL_SALVE = 2;  
   
	
	public static final DataSource getDataSource(int sourceType) throws Exception { 
		 DataSource dataSource = null; 
		
		 Properties p =new Properties();
		 p.put("initialSize", "1");
		 p.put("minIdle", "1");
		 p.put("maxActive", "20");
		 p.put("maxWait", "60000");
		 p.put("timeBetweenEvictionRunsMillis", "60000");
		 p.put("minEvictableIdleTimeMillis", "300000");		      
		 p.put("validationQuery", "SELECT 'x' from dual");
		 p.put("testWhileIdle", "true");
		 p.put("testOnBorrow", "false");
		 p.put("testOnReturn", "false");
		 p.put("poolPreparedStatements", "true");
		 p.put("maxPoolPreparedStatementPerConnectionSize", "20");
		 p.put("filters", "stat");
		                   
		 
     
        switch (sourceType) {  
        case DRUID_MYSQL_MASTER:
          p.put("url", "jdbc:mysql://***?useUnicode=true&characterEncoding=utf8");
          p.put("username", "***");
          p.put("password", "***");
        	
          dataSource = DruidDataSourceFactory.createDataSource(p);  	
          break;  
        case DRUID_MYSQL_SALVE:  
           p.put("url", "jdbc:mysql://***?useUnicode=true&characterEncoding=utf8");
           p.put("username", "***");
           p.put("password", "***");
           	
          dataSource = DruidDataSourceFactory.createDataSource(p);  	  
          break;      
        }  
        return dataSource;  
    }  
	

}


封装读写数据库的增删改查操作。 

package com.common.common.util.mysql;
import java.sql.CallableStatement;  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  

public class ConnectionDB {
    /** 
     * 创建数据库连接对象 
     */  
    private Connection connnection = null;  
  
    /** 
     * 创建PreparedStatement对象 
     */  
    private PreparedStatement preparedStatement = null;  
      
    /** 
     * 创建CallableStatement对象 
     */  
    private CallableStatement callableStatement = null;  
  
    /** 
     * 创建结果集对象 
     */  
    private ResultSet resultSet = null;  
  

  
    /** 
     * 建立数据库连接 
     * @return 数据库连接 
     * @throws Exception 
     */  
    public Connection getConnection(int type) throws Exception {  
        try {  
        	
            // 获取连接  
            connnection =DataSourceUtil.getDataSource(type).getConnection();
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        }  
        return connnection;  
    }  
  
    /** 
     * insert update delete SQL语句的执行的统一方法 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 受影响的行数 
     * @throws Exception 
     */  
    public int executeUpdate(String sql, Object[] params){  
        // 受影响的行数  
        int affectedLine = 0;  
          
        try {  
            // 获得连接  
            connnection = this.getConnection(1);  
            // 调用SQL   
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            affectedLine = preparedStatement.executeUpdate();  
  
        } catch (Exception e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
        return affectedLine;  
    }  
  
    /** 
     * SQL 查询将查询结果直接放入ResultSet中 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 结果集 
     * @throws Exception 
     */  
    private ResultSet executeQueryRS(String sql, Object[] params){  
        try {  
            // 获得连接  
            connnection = this.getConnection(2);  
              
            // 调用SQL  
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            resultSet = preparedStatement.executeQuery();  
  
        } catch (Exception e) {  
            System.out.println(e.getMessage());  
        }  
  
        return resultSet;  
    }  
  
    /** 
     * 获取结果集，并将结果放在List中 
     *  
     * @param sql 
     *            SQL语句 
     * @return List 
     *                       结果集 
     * @throws Exception 
     */  
    public List<Object> excuteQuery(String sql, Object[] params) {  
        // 执行SQL获得结果集  
        ResultSet rs = executeQueryRS(sql, params);  
          
        // 创建ResultSetMetaData对象  
        ResultSetMetaData rsmd = null;  
          
        // 结果集列数  
        int columnCount = 0;  
        try {  
            rsmd = rs.getMetaData();  
              
            // 获得结果集列数  
            columnCount = rsmd.getColumnCount();  
        } catch (SQLException e1) {  
            System.out.println(e1.getMessage());  
        }  
  
        // 创建List  
        List<Object> list = new ArrayList<Object>();  
  
        try {  
            // 将ResultSet的结果保存到List中  
            while (rs.next()) {  
                Map<String, Object> map = new HashMap<String, Object>();  
                for (int i = 1; i <= columnCount; i++) {  
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));  
                }  
                list.add(map);  
            }  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 关闭所有资源  
            closeAll();  
        }  
  
        return list;  
    }  
      
    /** 
     * 存储过程带有一个输出参数的方法 
     * @param sql 存储过程语句 
     * @param params 参数数组 
     * @param outParamPos 输出参数位置 
     * @param SqlType 输出参数类型 
     * @return 输出参数的值 
     * @throws Exception 
     */  
    public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType){  
        Object object = null;
        try { 
        	connnection = this.getConnection(1);  
       
            // 调用存储过程  
            callableStatement = connnection.prepareCall(sql);  
              
            // 给参数赋值  
            if(params != null) {  
                for(int i = 0; i < params.length; i++) {  
                    callableStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 注册输出参数  
            callableStatement.registerOutParameter(outParamPos, SqlType);  
              
            // 执行  
            callableStatement.execute();  
              
            // 得到输出参数  
            object = callableStatement.getObject(outParamPos);  
              
        } catch (Exception e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
          
        return object;  
    }  
  
    /** 
     * 关闭所有资源 
     */  
    private void closeAll() {  
        // 关闭结果集对象  
        if (resultSet != null) {  
            try {  
                resultSet.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭PreparedStatement对象  
        if (preparedStatement != null) {  
            try {  
                preparedStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
          
        // 关闭CallableStatement 对象  
        if (callableStatement != null) {  
            try {  
                callableStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭Connection 对象  
        if (connnection != null) {  
            try {  
                connnection.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }     
    }  

}

实例代码封装： 

package com.common.common.util.mysql;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.smart.entity.HomeDevice;
import com.smart.entity.HomeDeviceAlarm;
import com.smart.entity.HomeDeviceAttrStatu;
import com.smart.entity.HomeDeviceCommand;
import com.smart.entity.HomeDeviceLog;

public class ConnectionDBUtil {
	
	public List<HomeDevice> selectAlarmSubDeviceByDevUIDTypeCode(HomeDevice parame) {
		List<HomeDevice> list =new ArrayList<HomeDevice>();
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getGatewayId(),parame.getDeviceUid(),parame.getTypeCode()};
		List<Object> set= util.excuteQuery("select * from wlsq_data.home_device a where a.del_flag=0 AND a.gateway_id= ? and a.device_uid = ? and a.type_code=?", objs);
		if(set !=null && set.size() >0){
			for(Object obj:set){
				HomeDevice homeDevice =new HomeDevice();
				HashMap<String, Object> map =(HashMap<String, Object>)obj;				
				homeDevice.setId((Integer)map.get("id"));
				homeDevice.setTypeCode((Integer)map.get("type_code"));
				homeDevice.setDeviceUid((String)map.get("device_uid"));
				homeDevice.setDeviceName((String)map.get("device_name"));
				homeDevice.setStatus((String)map.get("status"));
				homeDevice.setGatewayId((Integer)map.get("gateway_id"));
				homeDevice.setCreatorId((String)map.get("creator_id"));
				homeDevice.setCreatedTime((Date)map.get("created_time"));
				homeDevice.setUpTime((Date)map.get("up_time"));
				homeDevice.setDelFlag((Integer)map.get("del_flag"));
				list.add(homeDevice);
			}
			
		}		
		return list;		
	}
	
	public List<HomeDeviceCommand> selectDevCommand(HomeDeviceCommand parame){
		List<HomeDeviceCommand> list =new ArrayList<HomeDeviceCommand>();
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getTypeCode()};
		List<Object> set= util.excuteQuery("select * from wlsq_data.home_device_command where del_flag=0 and type_code = ?", objs);
		if(set !=null && set.size() >0){
			for(Object obj:set){
				HomeDeviceCommand homeDeviceCommand =new HomeDeviceCommand();
				HashMap<String, Object> map =(HashMap<String, Object>)obj;				
				homeDeviceCommand.setId((Integer)map.get("id"));
				homeDeviceCommand.setTypeCode((Integer)map.get("type_code"));
				homeDeviceCommand.setCommand((String)map.get("command"));
				homeDeviceCommand.setCommandDesc((String)map.get("command_desc"));
				homeDeviceCommand.setCreatorId((String)map.get("creator_id"));
				homeDeviceCommand.setCreatedTime((Date)map.get("created_time"));
				homeDeviceCommand.setUpTime((Date)map.get("up_time"));
				homeDeviceCommand.setDelFlag((Integer)map.get("del_flag"));
				homeDeviceCommand.setCommandType((String)map.get("command_type"));
				homeDeviceCommand.setCommandCode((String)map.get("command_code"));				
				list.add(homeDeviceCommand);
			}			
		}		
		return list;
	}
	
	public void SaveAlarmAttrStatus(int device_id,Integer type_code,String command_type,String command_code,String comand,String command_desc) {
		//保存到设备属性表中
		HomeDeviceAttrStatu record = new HomeDeviceAttrStatu();
		record.setDeviceId(device_id);
		record.setTypeCode(type_code);
		record.setCommandType(command_type);
		record.setCommandCode(command_code);
		record.setComand(comand);
		record.setComandDesc(command_desc);
		record.setCreatedTime(new Date());
		record.setUpTime(new Date());
		record.setDelFlag(0);
		
		if(selectExistsDeviceAttr(record)>0){ 
			updateDeviceAttr(record); 
		}else{
			insertDeviceAttr(record);
		}		
	}
	
	public int selectExistsDeviceAttr(HomeDeviceAttrStatu parame){
		int result =0;
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getDeviceId(),parame.getTypeCode(),parame.getCommandType(),parame.getCommandCode()};
		List<Object> set= util.excuteQuery("select  count(id) as id from wlsq_data.home_device_attr_statu  where device_id = ? and type_code = ? and command_type = ? and command_code = ?", objs);
		if(set !=null && set.size() >0){
			for(Object obj:set){			
				HashMap<String, Object> map =(HashMap<String, Object>)obj;				
				result = (Integer)map.get("id");
			}			
		}		
		return result;
	}
	
	public void updateDeviceAttr(HomeDeviceAttrStatu parame){
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getComand(),parame.getComandDesc(),parame.getUpTime(),parame.getDelFlag(),parame.getDeviceId(),parame.getTypeCode(),parame.getCommandType(),parame.getCommandCode()};
		String sql ="update wlsq_data.home_device_attr_statu  set comand = ?, comand_desc = ?, up_time = ?, del_flag = ? where device_id = ? and type_code = ? and command_type = ? and command_code = ?"; 
		util.executeUpdate(sql, objs); 		
	}
	
	public void insertDeviceAttr(HomeDeviceAttrStatu parame){
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getDeviceId(),parame.getTypeCode(),parame.getCommandType(),parame.getCommandCode(),parame.getComand(),parame.getComandDesc(),parame.getCreatedTime(),parame.getDelFlag(),parame.getUpTime()};
		String sql = "insert into wlsq_data.home_device_attr_statu (device_id, type_code, command_type, command_code, comand, comand_desc, created_time, del_flag, up_time) values (?, ?, ?, ?, ?, ?, ?, ?,?)";   
		util.executeUpdate(sql, objs); 		
	}
	
	public void SaveDeviceLog(int gatewayId,int deviceId,String command,String commandDesc,String gatewayUid,String deviceUid,String deviceName) {
		HomeDeviceLog devLogObj = new HomeDeviceLog();
		devLogObj.setGatewayUid(gatewayUid);
		devLogObj.setDeviceUid(deviceUid);
		devLogObj.setDeviceName(deviceName);
		devLogObj.setGatewayId(gatewayId);
		devLogObj.setDeviceId(deviceId);
		devLogObj.setMsgType("log");
		devLogObj.setMsgCommand(command);
		devLogObj.setMsgContent(commandDesc);
		devLogObj.setCreatedTime(new Date());
		devLogObj.setUpTime(new Date());
		devLogObj.setDelFlag(0);
		insertDeviceLog(devLogObj);		
	}
	public void insertDeviceLog(HomeDeviceLog parame) {
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getGatewayId(),parame.getDeviceId(),parame.getMsgType(),parame.getMsgContent(),parame.getMsgCommand(),parame.getCreatedTime(),parame.getDelFlag()};
		String sql = " insert into wlsq_data.home_device_log (gateway_id, device_id, msg_type, msg_content, msg_command, created_time,del_flag) values (?,?,?,?,?,?,?)";  
		util.executeUpdate(sql, objs); 
	}
	
	public HomeDeviceAlarm SaveDeviceAlarmLog(int gatewayId,int deviceId,String command,String commandDesc,String msgId){
		HomeDeviceAlarm devAlarmObj = new HomeDeviceAlarm();
		devAlarmObj.setGatewayId(gatewayId);
		devAlarmObj.setDeviceId(deviceId);
		devAlarmObj.setMsgType("alarm");
		devAlarmObj.setMsgCommand(command);
		devAlarmObj.setMsgContent(commandDesc);
		devAlarmObj.setStatus(0);
		devAlarmObj.setValid(0);
		devAlarmObj.setCreatedTime(new Date());
		devAlarmObj.setDelFlag(0);
		devAlarmObj.setReportId(msgId);
		
		insertDeviceAlarmLog(devAlarmObj);
		
		return devAlarmObj;		
	}
	
	public void insertDeviceAlarmLog(HomeDeviceAlarm parame){
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getGatewayId(),parame.getDeviceId(),parame.getMsgType(),parame.getMsgContent(),parame.getMsgCommand(),parame.getValid(),parame.getStatus(),parame.getCreatedTime(),parame.getDelFlag(),parame.getReportId()};
		String sql = "insert into wlsq_data.home_device_alarm (gateway_id, device_id,msg_type, msg_content, msg_command,valid, status, created_time, del_flag,up_time,report_id) values (?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), ?)";    
    	util.executeUpdate(sql, objs); 		
	}
	
	
	public String selectGatewayAlias(String gateway_uid){
		String result ="";
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{gateway_uid};
		List<Object> set= util.excuteQuery("select gateway_alias from wlsq_data.alarm_install_position where gateway_uid=? and del_flag=0 ", objs);
		if(set !=null && set.size() >0){
			for(Object obj:set){			
				HashMap<String, Object> map =(HashMap<String, Object>)obj;				
				result = (String)map.get("gateway_alias");
			}			
		}		
		return result;		
	}
	
	private void UpdateRestOnLineDevice(int gatewayId,String deviceId,Integer typeCode) {
		HomeDevice restOnLineDevObj = new HomeDevice();
		restOnLineDevObj.setGatewayId(gatewayId);
		restOnLineDevObj.setTypeCode(typeCode);
		restOnLineDevObj.setDeviceUid(deviceId);
		restOnLineDevObj.setStatus("1");
		restOnLineDevObj.setUpTime(new Date());
		
		updateDeviceOffLine(restOnLineDevObj);		
	}
	
	public void updateDeviceOffLine(HomeDevice parame) {
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.getStatus(),parame.getUpTime(),parame.getGatewayId(),parame.getDeviceUid()};
		String sql = "update wlsq_data.home_device a set a.status=?,a.up_time=? where a.gateway_id= ? and a.device_uid=? and a.del_flag = 0"; 			   
    	util.executeUpdate(sql, objs); 		
	}
	
	public void deleteDeviceByUId(Map<String, Object> parame) {
		ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.get("device_uid"),parame.get("gateway_uid")};
		String sql = "update wlsq_data.home_device a set a.del_flag=1,a.up_time=NOW() where a.device_uid = ? and gateway_id = (select id from wlsq_data.home_gateway where gateway_uid = ?)";		
		util.executeUpdate(sql, objs); 			
	}
	
	public void UpdateOffLineDevice(int gatewayId,String deviceId,Integer typeCode)  {
		HomeDevice offLineDevObj = new HomeDevice();
		offLineDevObj.setGatewayId(gatewayId);
		offLineDevObj.setTypeCode(typeCode);
		offLineDevObj.setDeviceUid(deviceId);
		offLineDevObj.setStatus("0");
		offLineDevObj.setUpTime(new Date());
		
		updateDeviceOffLine(offLineDevObj);//更新掉线设备状态
	}
	
    public void updateGatewayStatus(Map<String, Object> parame) {
    	ConnectionDB util = new ConnectionDB();
		Object[] objs =new Object[]{parame.get("status"),parame.get("gateway_uid")};
		String sql = "update  wlsq_data.home_gateway set status = ?, up_time = NOW() WHERE gateway_uid = ? and del_flag = 0";			
		util.executeUpdate(sql, objs); 	
    }
	

	
	
	
	
	
	
	
	
	
	
	
	
	
	
	

}



在奋斗的大道
关注
专栏目录
mysql一主多从以及使用springboot aop进行读写分离的搭建的正确姿式
lifetragedy的专栏
06-03 2907
介绍 这是一篇高度集中火力的生产环境中的mysql5.7一主多从以及结合spring boot进行读写分离的最全文档。主末笔者还会给出一个完整的基于spring boot的使用aop特性做完整项目读写分离的全代码与演示。 本文涉及技术点如下： mysql5.7.30+版本 spring boot AOP haproxy keep alive 1.目标 mySQL层1主挂多从 安装3台mysql服务器，三台服务分布如下： mySQL master: 192.168.2.101 mySQ..
【微服务】springboot 适配多数据源设计与实现
congge
07-04 6312
springboot多数据源配置详解
Spring Boot 自定义数据源DruidDataSource代码
08-25
主要介绍了Spring Boot 自定义数据源DruidDataSource代码,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java JDBC数据库连接封装和实例代码
zhouzhiwengang的专栏
10-26 2265
java jdbc功能代码封装： package com.common.common.util.mysql; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import
druid配置项详解
最新发布
chenXiJ的博客
07-24 873
druid的常用配置详解
Java之对于jdbc对数据库的封装
weixin_30650859的博客
08-11 81
package com.myweb.utils; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.M...
jdbc连接数据库封装的代码
zsmsxbl的博客
10-24 474
package com.weihai.conn; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class DBconn { ...
java封装示例代码
weixin_30510153的博客
04-10 158
package com.imooc; public class Telphone { private float screen; private float cpu; private float mem; public float getScreen(){ return screen; } ...
详解MyBatis多数据源配置(读写分离)
08-31
本文将详细介绍如何在MyBatis中设置多数据源，并实现读写分离，以达到优化数据库访问的目的。 读写分离是数据库架构中的重要策略，它将读操作与写操作分配到不同的服务器，通常主库负责写操作，从库处理读操作，...
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 6633
springboot整合sharding-jdbc实现分库分表详解
使用Sharding-JDBC实现分库分表
2401_84048179的博客
04-19 973
Sharding-JDBC是当当网研发的开源分布式数据库中间件，从 3.0 开始Sharding-JDBC被包含在 Sharding-Sphere中，之后该项目进入进入Apache孵化器，4.0版本之后的版本为Apache版本。ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding- Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。
JDBC 数据库连接和操作的封装
08-17
将数据库连接和增删查改的方法进行封装，将重复性的代码提取出去作为工具类，尽量减少类与类之间的固定依赖
Java连接数据库 JDBC封装类 带使用例子
08-06
Java JDBC封装类，带增删改查例子，支持oracle,MySql,hsqldb 等，支持事务，返回数据格式 支持二维数组，MAP格式，以及javabean对象。有利于初学者DbDemo.java为demo,Connect为jdbc封装类，可以作为项目共通类使用。
java连接数据库（工具类的封装）
10-02
一个标准的连接数据库类的封装…………Mysql
JAVA连接数据库封装（mysql）
08-12
Java与数据库mysql的连接类，这是一个只要满足命名规范和遵守javaBean规范就能实现数据库表的记录与对应javaBean之间的对象转换
DruidDataSource数据源配置详解
06-29
可以帮助你了解,以及配置实现DruidDataSource数据源的配置
druid+mybatis 多数据源及读写分离的处理
S&Y_shhy_QQ_1127833416
02-19 2938
现如今复杂的业务系统，一般会将数据库按业务拆开，比如产品系统的数据库放在product db中，订单系统的数据库放在order db中...，然后，如果量大了，可能每个库还要考虑做读、写分离，以进一步提高系统性能，下面就来看看如何处理： 核心思路：配置多个数据源，然后利用RoutingDataSource结合AOP来动态切不同的库。 存在一下几个问题： 1、配置文件中，多数据源的配置节...
druid mysql读写分离_Spring Boot + Mybatis + Druid 实现MySQL一主多从读写分离
weixin_35817939的博客
01-19 659
Spring Boot 读写分离实现原理实现方式主要是通过扩展Spring AbstractRoutingDataSource这个类充当DataSource路由中介，在运行当中根据自定义KEY值动态切换正真的DataSource。具体实现创建测试库、表：create database `mytest_db`;CREATE TABLE `t_user` (`id` int(11) NOT NULL ...
JDBC 封装MySQL数据库连接类
IT-Andy
04-28 776
方式一：创建一个DBHelper类，封装代码，但这种方式导致程序代码的耦合度比较高！ package com.andy.shopping.util.db; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /** * 连接数据库类 * @author andy ...
Spring Boot + Mybatis 实现数据库读写分离详解
总结来说，通过Spring Boot的`AbstractRoutingDataSource`和MyBatis插件，我们可以轻松实现数据库的读写分离，提高系统的扩展性和稳定性。在实际项目中，还需要考虑更多的细节，例如数据同步延迟问题、故障切换策略...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值