闲话少说，直接列举问题：
①ab两台数据库服务器做集群，由于两台服务器配置不一样，如何在代码中要实现每访问服务器a的数据库2次，才能访问服务器b的数据库1次。
②ab两台数据库服务器做读写分离，如何在代码中控制，查询数据使用服务器a的数据库连接，增删改使用服务器b的数据库连接。
代码结构：
代码实现：
①数据库连接信息默认值
我要评论package com.keji10.core.jdbc.properties;
/**
* 类描述： 数据库连接信息默认值
*
* @since 1.5
* @version 1.0
* @author xuanly
*
*/
public interface jdbcpropertiescontants {
/**
* jdbc.maxactive最大活跃数（默认值）
*/
public static final int jdbc_maxactive_default = 20;
/**
* jdbc.maxidle最大连接数（默认值）
*/
public static final int jdbc_maxidle_default = 20;
/**
* jdbc.maxwait默认等待时间（默认值）
*/
public static final int jdbc_maxwait_default = 10000;
/**
* jdbc.weight默认数据库连接池权重（默认值）
*/
public static final int jdbc_weight_default = 1;
}
package com.keji10.core.jdbc.properties;
/**
* 类描述： 数据库配置文件实体类
*
* @since 1.5
* @version 1.0
* @author xuanly
*
*/
public class jdbcpropertiesbean implements jdbcpropertiescontants {
private string jdbcdriver;
private string jdbcurl;
private string jdbcusername;
private string jdbcpassword;
private int jdbcmaxactive;
private int jdbcmaxidle;
private int jdbcmaxwait;
private int jdbcweight;
public string getjdbcdriver() {
return jdbcdriver;
}
public void setjdbcdriver(string jdbcdriver) {
this.jdbcdriver = jdbcdriver;
}
public string getjdbcurl() {
return jdbcurl;
}
public void setjdbcurl(string jdbcurl) {
this.jdbcurl = jdbcurl;
}
public string getjdbcusername() {
return jdbcusername;
}
public void setjdbcusername(string jdbcusername) {
this.jdbcusername = jdbcusername;
}
public string getjdbcpassword() {
return jdbcpassword;
}
public void setjdbcpassword(string jdbcpassword) {
this.jdbcpassword = jdbcpassword;
}
public int getjdbcweight() {
if (jdbcweight == 0) {
// 返回默认值
return jdbc_weight_default;
}
return jdbcweight;
}
public void setjdbcweight(int jdbcweight) {
this.jdbcweight = jdbcweight;
}
public int getjdbcmaxactive() {
if (jdbcmaxactive == 0) {
// 返回默认值
return jdbc_maxactive_default;
}
return jdbcmaxactive;
}
public void setjdbcmaxactive(int jdbcmaxactive) {
this.jdbcmaxactive = jdbcmaxactive;
}
public int getjdbcmaxidle() {
if (jdbcmaxidle == 0) {
// 返回默认值
return jdbc_maxidle_default;
}
return jdbcmaxidle;
}
public void setjdbcmaxidle(int jdbcmaxidle) {
this.jdbcmaxidle = jdbcmaxidle;
}
public int getjdbcmaxwait() {
if (jdbcmaxwait == 0) {
// 返回默认值
return jdbc_maxwait_default;
}
return jdbcmaxwait;
}
public void setjdbcmaxwait(int jdbcmaxwait) {
this.jdbcmaxwait = jdbcmaxwait;
}
public string tostring() {
stringbuffer s = new stringbuffer();
s.append("jdbcdriver =" + jdbcdriver);
s.append("jdbcurl =" + jdbcurl);
s.append("jdbcusername =" + jdbcusername);
s.append("jdbcpassword =" + jdbcpassword);
s.append("jdbcmaxactive =" + jdbcmaxactive);
s.append("jdbcmaxidle =" + jdbcmaxidle);
s.append("jdbcmaxwait =" + jdbcmaxwait);
s.append("jdbcweight =" + jdbcweight);
return s.tostring();
}
}
③数据库配置文件信息获取
package com.keji10.core.jdbc.properties;
import java.util.resourcebundle;
import org.apache.log4j.logger;
import com.keji10.core.exception.dbexception;
/**
* 类描述： 数据库配置文件信息获取
*
* @since 1.5
* @version 1.0
* @author xuanly
*
*/
public class jdbcpropertiesmanager {
private logger logger = logger.getlogger(jdbcpropertiesmanager.class.getname());
// 单例模式begin
private static jdbcpropertiesmanager instance = new jdbcpropertiesmanager();
private jdbcpropertiesmanager() {
}
public static jdbcpropertiesmanager getinstance() {
return instance;
}
// 单例模式end
private jdbcpropertiesbean jdbcpropertiesbean;
/**
* 获取jdbc.propertiesbean配置文件
*
* @return jdbcpropertiesbean
* @throws dbexception
*/
public jdbcpropertiesbean getjdbcpropertiesbean() throws dbexception {
return getjdbcpropertiesbean("jdbc");
}
public jdbcpropertiesbean getjdbcpropertiesbean(string propertiefile) throws dbexception {
resourcebundle rb = resourcebundle.getbundle(propertiefile);
jdbcpropertiesbean = new jdbcpropertiesbean();
try {
jdbcpropertiesbean.setjdbcdriver(rb.getstring("jdbc.driver"));
jdbcpropertiesbean.setjdbcurl(rb.getstring("jdbc.url"));
jdbcpropertiesbean.setjdbcusername(rb.getstring("jdbc.username"));
jdbcpropertiesbean.setjdbcpassword(rb.getstring("jdbc.password"));
} catch (exception e) {
logger.warn("获取数据库连接配置文件【jdbc.driver】失败，执行无法启动！");
logger.warn("获取数据库连接配置文件【jdbc.url】失败，执行无法启动！");
logger.warn("获取数据库连接配置文件【jdbc.username】失败，执行无法启动！");
logger.warn("获取数据库连接配置文件【jdbc.password】失败，执行无法启动！");
logger.error(e);
throw new dbexception(e);
}
try {
jdbcpropertiesbean.setjdbcmaxactive(integer.valueof(rb.getstring("jdbc.maxactive")));
jdbcpropertiesbean.setjdbcmaxidle(integer.valueof(rb.getstring("jdbc.maxidle")));
jdbcpropertiesbean.setjdbcmaxwait(integer.valueof(rb.getstring("jdbc.maxwait")));
jdbcpropertiesbean.setjdbcweight(integer.valueof(rb.getstring("jdbc.weight")));
} catch (exception e) {
logger.warn("获取数据库连接配置文件【jdbc.maxactive】失败，系统将执行默认配置");
logger.warn("获取数据库连接配置文件【jdbc.maxidle】失败，系统将执行默认配置");
logger.warn("获取数据库连接配置文件【jdbc.maxwait】失败，系统将执行默认配置");
logger.warn("获取数据库连接配置文件【jdbc.weight】失败，系统将执行默认配置");
}
return jdbcpropertiesbean;
}
}
④数据库连接池管理
package com.keji10.core.jdbc.datasource;
import java.util.hashmap;
import java.util.map;
import javax.sql.datasource;
import org.apache.commons.dbcp.basicdatasource;
import org.apache.log4j.logger;
import com.keji10.core.commons.configbean;
import com.keji10.core.exception.dbexception;
import com.keji10.core.jdbc.properties.jdbcpropertiesbean;
import com.keji10.core.jdbc.properties.jdbcpropertiesmanager;
/**
* 类描述：数据库连接池管理
*
* @since 1.5
* @version 1.0
* @author chenairu
*
*/
public class dbdatasource {
private logger logger = logger.getlogger(dbdatasource.class.getname());
// 单例模式begin
private static dbdatasource instance = new dbdatasource();
private dbdatasource() {
}
public static dbdatasource getinstance() {
return instance;
}
// 单例模式end
// 非主数据库连接池集群池
private map<string, datasource> otherdatasourcemap = new hashmap<string, datasource>();
// 主数据库连接池集群池
private map<integer, datasource> maindatasourcemap = new hashmap<integer, datasource>();
// 记录数据库负载均衡的配置
private map<integer, integer> maindatasourceweightmap = new hashmap<integer, integer>();
// 记录获取数据库连接的指针
private int maindatasourceweightindex = 0;
/**
* 获取连接池
*
* @param bean
* @return
* @throws dbexception
*/
public datasource getdatasource(jdbcpropertiesbean bean) throws dbexception {
if (bean == null) {
return getdatasource();
}
if (bean.getjdbcdriver() == null || bean.getjdbcurl() == null || bean.getjdbcusername() == null || bean.getjdbcpassword() == null) {
logger.error("********数据库配置信息不完整！！！*********");
logger.error("*********加载默认数据库配置！！！*********");
return getdatasource();
}
datasource datasource = (datasource) otherdatasourcemap.get(bean.tostring());
if (datasource != null) {
return datasource;
}
logger.info("*********加载数据库配置***********************");
logger.info("jdbcdriver =" + bean.getjdbcdriver());
logger.info("jdbcurl =" + bean.getjdbcurl());
logger.info("jdbcusername =" + bean.getjdbcusername());
logger.info("jdbcpassword =" + bean.getjdbcpassword());
logger.info("jdbcmaxactive=" + bean.getjdbcmaxactive());
logger.info("jdbcmaxidle =" + bean.getjdbcmaxidle());
logger.info("jdbcmaxwait =" + bean.getjdbcmaxwait());
basicdatasource basicdatasource = new basicdatasource();
basicdatasource.setdriverclassname(bean.getjdbcdriver());
basicdatasource.seturl(bean.getjdbcurl());
basicdatasource.setusername(bean.getjdbcusername());
basicdatasource.setpassword(bean.getjdbcpassword());
basicdatasource.setmaxactive(bean.getjdbcmaxactive());
basicdatasource.setmaxidle(bean.getjdbcmaxidle());
basicdatasource.setmaxwait(bean.getjdbcmaxwait());
datasource = basicdatasource;
logger.info("*********加载数据库配置完成************************");
otherdatasourcemap.put(bean.tostring(), datasource);
return datasource;
}
/**
* 获取连接池
*
* @return 连接池
* @throws dbexception
*/
public datasource getdatasource() throws dbexception {
string jdbcfilename;
jdbcpropertiesbean bean;
datasource datasource;
string jdbcs = configbean.getinstance().getjdbcs();
if (maindatasourcemap.isempty()) {
for (int i = 0; i < jdbcs.split(",").length; i++) {
jdbcfilename = jdbcs.split(",")[i];
bean = jdbcpropertiesmanager.getinstance().getjdbcpropertiesbean(jdbcfilename);
logger.info("*********加载数据库配置***********************");
logger.info("jdbcdriver =" + bean.getjdbcdriver());
logger.info("jdbcurl =" + bean.getjdbcurl());
logger.info("jdbcusername =" + bean.getjdbcusername());
logger.info("jdbcpassword =" + bean.getjdbcpassword());
logger.info("jdbcmaxactive=" + bean.getjdbcmaxactive());
logger.info("jdbcmaxidle =" + bean.getjdbcmaxidle());
logger.info("jdbcmaxwait =" + bean.getjdbcmaxwait());
logger.info("jdbcweight =" + bean.getjdbcweight());
basicdatasource basicdatasource = new basicdatasource();
basicdatasource.setdriverclassname(bean.getjdbcdriver());
basicdatasource.seturl(bean.getjdbcurl());
basicdatasource.setusername(bean.getjdbcusername());
basicdatasource.setpassword(bean.getjdbcpassword());
basicdatasource.setmaxactive(bean.getjdbcmaxactive());
basicdatasource.setmaxidle(bean.getjdbcmaxidle());
basicdatasource.setmaxwait(bean.getjdbcmaxwait());
datasource = basicdatasource;
//负载设置关键代码---begin
maindatasourcemap.put(i, datasource);
for (int j = 0; j < bean.getjdbcweight(); j++) {
maindatasourceweightmap.put(maindatasourceweightmap.size() + 1, i);
}
//负载设置关键代码---end
logger.info("*********加载数据库配置完成************************");
}
}
int maindatasourcenowindex;
try {
maindatasourcenowindex = maindatasourceweightmap.get(maindatasourceweightindex % (maindatasourceweightmap.size()));
maindatasourceweightindex++;
if (maindatasourceweightindex >= maindatasourceweightmap.size()) {
maindatasourceweightindex = 0;
}
} catch (exception e) {
maindatasourcenowindex = 0;
}
return (datasource) maindatasourcemap.get(maindatasourcenowindex);
}
/**
* 清空数据库连接池
*/
public void clear() {
otherdatasourcemap.clear();
maindatasourcemap.clear();
maindatasourceweightmap.clear();
maindatasourceweightindex = 0;
}
}
⑤数据库连接实现
package com.keji10.core.jdbc.datasource;
import java.sql.connection;
import java.sql.sqlexception;
import javax.sql.datasource;
import org.apache.log4j.logger;
import com.keji10.core.exception.dbexception;
import com.keji10.core.jdbc.properties.jdbcpropertiesbean;
/**
* 类描述：数据库连接实现
*
* @since 1.5
* @version 1.0
* @author xuanly
*
*/
public class dbconnection {
private logger logger = logger.getlogger(dbconnection.class.getname());
// 单例模式begin
private static dbconnection instance = new dbconnection();
private dbconnection() {
}
public static dbconnection getinstance() {
return instance;
}
// 单例模式end
/**
* 获取默认数据库连接
*
* @return 数据库连接
* @throws dbexception
*/
public connection getconnection() throws dbexception {
try {
return dbdatasource.getinstance().getdatasource().getconnection();
} catch (sqlexception e) {
logger.error(e);
throw new dbexception(e);
}
}
/**
* 根据配置文件获取自定义数据库连接
*
* @param jdbcpropertiesbean
* @return
* @throws dbexception
*/
public connection getconnection(jdbcpropertiesbean jdbcpropertiesbean) throws dbexception {
datasource datasource = dbdatasource.getinstance().getdatasource(jdbcpropertiesbean);
try {
return datasource.getconnection();
} catch (sqlexception e) {
logger.error(e);
throw new dbexception(e);
}
}
/**
* 关闭数据库连接
*
* @throws dbexception
*/
public void close(connection connection) throws dbexception {
try {
if (connection == null) {
return;
}
if (connection.isclosed()) {
return;
}
if (connection != null) {
connection.close();
connection = null;
}
} catch (sqlexception e) {
logger.error(e);
throw new dbexception(e);
} finally {
connection = null;
}
}
/**
* 清空数据库连接池
*/
public void clear() {
dbdatasource.getinstance().clear();
}
}
封装框架最核心的部分，莫过于数据库连接的封装。数据库连接就像一条管道，一端连着数据库，一端连接java程序。
如果一个框架，能够像数据库连接一样，一端连着数据库，一端连着用户的界面，中间无需编辑java代码，即可完成项目开发。
那这套框架的思路将会为以后的开发，开辟一个新模式。
计划安排，下一编先把对象映射完成，再写数据库查询的封装。
如对本文有疑问， 点击进行留言回复！！
网友评论