Title:核心处理基类
平时接到很多规模不大的小型Web项目,很多部门提出要求说需要XXX和YYY等功能,他们之间既不能保持统一操作规范或习惯,也不能统一业务和数据,在这种的情况下,悲剧的重复,带来了悲剧的工作量。
所以,我研究出一套应对我所遇到的不同需求的相同的解决方案(恩,这个词汇受到了VS的影响,以前是解决思路),为了解决编码过程中可能遇到的问题,我定了几个整体目标:
1. 系统应具有足够的访问性能,并尽量保持最少的资源消耗。
2. 持久层的重复编写是不能接受的,应达到只需 Ctrl + V 或者包引用即可解决,且无修改。
3. 该持久层内部实现,应较低的耦合,具备高兼容性、高扩展性。
4. 内部实现应尽量简单可读,计算效率低、且计算复杂同样不能接受!
具体在编码阶段,为了控制访问方式、避免Sql泛滥,我也设置几个目标:
1. 与数据库无关
2. 与表无关,实现具体表与相应的操作相分离
3. 与业务逻辑无关
要满足以上要求,不会太困难,相信坛子里也很多,好吧,废话不错说,上代码,首先介绍 DBConnection.java
注:以上代码注释中提到的tomcat配置,请参考网友xiejin2008的文章[url]http://xiejin2008.iteye.com/blog/370584[/url],讲得很详细
把这个类贴上来,我比较犹豫,大家都看了千百遍了,但这也确实是够用的小成本连接池配置,能对付并发至少20的访问量,对于我所处理的项目来说,并发数达到20是比较少见的,所以这种方式对于我来说屡试不爽啊。。 :D
然后是核心的逻辑处理类,PublicDao.java
然后测试
得到结果:
有了这些基本的处理方法,就能满足比较简单的增删改查和简单的多表查询的操作。
这个类实现以下几个目标:
1. 要查询的表在调用时指定,所以跟具体的表实现了分离;
2. 在调用该类执行操作时,需要指定操作类型(createSql方法的第一个参数),由此具体的操作类型我们可以不再关心了。
3. 逻辑比较简单:构造SQL——>执行Execute(解析结果集)——>关闭对象
4. createSql方法规范了调用方式,不会再看到泛滥的SQL,SQL被固定在了持久层,当然类型CONDITION的操作除外。
但是也有一些问题,如下:
1. 为了支持多表查询,还是妥协的暴露的一个操作类型CDONDITION,createSql方法目前还不能强大到执行复杂度太高的SQL。
2. 调用的方法显得有些复杂,做过很多思考,尽可能让createSql方法的参数简单,很遗憾,智商有限啊
3. 不能支持分页查询SQL构造,这个需求将在下一篇介绍,毕竟只是个雏形啊,哪能一蹴而就
小总结了一下,还有一些小优点:
1. 调试。你所有的SQL只会在同一个地方执行(executeSql方法),你只需要打一个断点,Ok,错误们,找到你们更easy了。
2. 这里返回的是List和Map,不是实体类对象,你可以随便造出任何实体类对象,来跟List里面的数据耦合。当然,这些实体类要实现自动与List装配,必须有一些规范,后面我也会做介绍。
总结,以上对付的,只是基于简单的数据操作,我在使用之后发现我的持久层就孤零零的几个类,代码结构简洁了许多。之后我做了一些扩展,增加分页查询的支持是必须的,对多表查询的支持我也会尽量做到(我考虑过,由于操作比较复杂,还不如直接写SQL,性价比不高```)。有任何问题和建议,希望各位看官大大的提出来,我会继续努力实现尽可能的操作简单化。
~~~平时看别人的博客没怎么在意,今天写这些居然花了一下午,En,多多锻炼````
平时接到很多规模不大的小型Web项目,很多部门提出要求说需要XXX和YYY等功能,他们之间既不能保持统一操作规范或习惯,也不能统一业务和数据,在这种的情况下,悲剧的重复,带来了悲剧的工作量。
所以,我研究出一套应对我所遇到的不同需求的相同的解决方案(恩,这个词汇受到了VS的影响,以前是解决思路),为了解决编码过程中可能遇到的问题,我定了几个整体目标:
1. 系统应具有足够的访问性能,并尽量保持最少的资源消耗。
2. 持久层的重复编写是不能接受的,应达到只需 Ctrl + V 或者包引用即可解决,且无修改。
3. 该持久层内部实现,应较低的耦合,具备高兼容性、高扩展性。
4. 内部实现应尽量简单可读,计算效率低、且计算复杂同样不能接受!
具体在编码阶段,为了控制访问方式、避免Sql泛滥,我也设置几个目标:
1. 与数据库无关
2. 与表无关,实现具体表与相应的操作相分离
3. 与业务逻辑无关
要满足以上要求,不会太困难,相信坛子里也很多,好吧,废话不错说,上代码,首先介绍 DBConnection.java
package com.pub.db;
import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
/***
* tomcat中的配置方式:
* 1. 在tomcat/conf/context.xml中,<context></context>中配置<Resource ... />
* 2. 在相同目录下,配置server.xml,在<GlobalNamingResources>标签里配置相同的
* <Resource ... />,然后再context.xml中的<context>标签里,配置<ResourceLink />去引用它
*
* @author db2admin
*
*/
public class DBConnection {
private static Connection con = null;
/***
* 默认连接
* @return
*/
public static Connection getConnection() {
InitialContext initCtx = null;
Context context = null;
DataSource ds = null;
try {
initCtx = new InitialContext();
context = (Context) initCtx.lookup("java:comp/env");
ds = (DataSource) context.lookup("JDBC/SQL");
con = ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
} catch (NamingException e) {
e.printStackTrace();
}finally{
try {
if(context != null){
context.close();
}
if(initCtx != null){
initCtx.close();
}
} catch (NamingException e) {
e.printStackTrace();
}
}
return con;
}
}
注:以上代码注释中提到的tomcat配置,请参考网友xiejin2008的文章[url]http://xiejin2008.iteye.com/blog/370584[/url],讲得很详细
把这个类贴上来,我比较犹豫,大家都看了千百遍了,但这也确实是够用的小成本连接池配置,能对付并发至少20的访问量,对于我所处理的项目来说,并发数达到20是比较少见的,所以这种方式对于我来说屡试不爽啊。。 :D
然后是核心的逻辑处理类,PublicDao.java
package com.pub.dao;
import java.sql.Connection;
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;
import com.pub.db.DBConnection;
/***
* 核心逻辑处理类
* 缺点: 1. 拼凑条件、键值对对象操作复杂;
* 2. 建立结果集(表)与实体类的映射关系耦合程度高
* 3. 与具体数据类型的耦合度程度高
* @author db2admin
* 2010-12-01
*/
public class PublicDao {
/**当前操作状态 4*/
public final static int ADD = 4;
/**当前操作状态 3*/
public final static int UPDATE = 3;
/**当前操作状态 2*/
public final static int DELETE = 2;
/**当前操作状态 1*/
public final static int SELECT = 1;
/**当前操作状态:直接执行 0*/
public final static int CONDITION = 0;
/**当前操作状态:直接执行无返回值 -1*/
public final static int CONDITION_1 = -1;
/***
* 该方法返回用于执行的SQL
*
* 通过Map_k和Map_v来执行生成SQL,增 Add 4,删 Del 2,改 Upd 3,查 1,直接执行的SQL:condition<br>
*
* 情况零:<br>
* condition为主要执行Sql,tableName,mk和mv为空。<br>
* 情况一:Select<br>
* mk为@cols的key,mv为@where的key(或者完整"Key=Value"),condition(若不为空)为@where值【condition针对多条件临时采用", "号分隔,其顺序依次对应mv中的key】<br>
* 情况二:delete<br>
* mk中为@where的key,mv中为@where的value,其中条件中符号同样在mv中<br>
* 情况三:update<br>
* mk中为@value的key,mv中为@values的value,其中条件中符号同样在mv中,condition为查询条件<br>
* 情况四:insert<br>
* mk中为@cols,mv中为@value,与condition无关<br>
* @param type
* @param className
* @param mk
* @param mv
* @param condition
* @return
*/
public String createSql(int type,String tableName,Map<Object, String> mk,Map<Object, Object> mv,String condition){
//用于记录列名
StringBuffer cols = new StringBuffer();
//用于记录条件
StringBuffer where = new StringBuffer();
//用于记录列值,仅在插入时使用
StringBuffer value = new StringBuffer();
if(type <= 0){//直接返回Sql
return condition;
} else if(type == 1){//单表查询
//循环配置列名
for(int i=1; i <= mk.size();i++){
cols.append( mk.get(i) );
if(i != mk.size()){
cols.append(",");
}
}
//配置条件
where.append(" where 1=1 and ");
if("".equals(condition) || condition == null){
for(int i=1; i <= mv.size();i++){
where.append(mv.get(i));
if(i != mv.size()){
where.append(" and ");
}
}
}else{
for(int i=1; i <= mv.size();i++){
where.append( mv.get(i)+condition.split(", ")[i-1] );//逗号+空格
if(i != mv.size()){
where.append(" and ");
}
}
}
//查询SQL
String sql = "select @cols from "+tableName+" @where";
//替换查询列名
sql = sql.replace("@cols", ("".equals(cols))?"*":cols);
//替换查询条件
sql = sql.replace("@where", (mv.size()==0)?"":where);
return sql;
} else if(type == 2){//删除
//配置条件
where.append(" where 1=1 and ");
for(int i=1;i<=mk.size();i++){
where.append(mk.get(i) + mv.get(mk.get(i)));
if(i != mk.size()){
where.append(" and ");
}
}
//删除SQL
String sql_del = "delete from "+tableName+" @where";
//替换删除条件
sql_del = sql_del.replace("@where", where);
return sql_del;
} else if(type == 3){//修改
//配置要修改的列和值
for(int i=1;i<=mk.size();i++){
cols.append(mk.get(i)+" = "+mv.get(mk.get(i)));
if(i != mk.size()){
cols.append(",");
}
}
//配置条件
where.append(" where 1=1 and ");
if("".equals(condition) || null == condition){
where = new StringBuffer();
} else {//如果condition为空,则条件为空
where.append(condition);
}
//更新SQL
String sql_upd = "update "+tableName+" set @values @where";
//替换要更新的列和值
sql_upd = sql_upd.replace("@values", cols);
//替换更新条件
sql_upd = sql_upd.replace("@where", where);
return sql_upd;
} else if(type == 4){//插入、新增
//配置列名,以及列所对应的值
for(int i=1;i<=mk.size();i++){
cols.append(mk.get(i));
value.append(mv.get(mk.get(i)));
if(i != mk.size()){
cols.append(",");
value.append(",");
}
}
//新增SQL
String sql_add = "insert into "+tableName+" (@cols) values (@value)";
//替换列名
sql_add = sql_add.replace("@cols", cols);
//替换值
sql_add = sql_add.replace("@value", value);
return sql_add;
}
return "";
}
/***
* 执行Sql<br>
* 当type不为0,1时,直接执行返回空,反之则返回结果集,结构为:<br>
* List[
* List[
* Map(index,name(i)), List[Map(name(i),value(i))]
* ]]
* @param type 操作类型
* @param sql 执行SQL
*/
public List executeSql(int type , String sql){
//获取连接
Connection con = DBConnection.getConnection();
PreparedStatement ps = null;
ResultSet rs = null;
try {
con = DBConnection.getConnection();
ps = con.prepareStatement(sql);
//判断查询类型
if(type == SELECT || type == CONDITION){
rs = ps.executeQuery();
} else {
ps.execute();
return null;
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
if(type != SELECT && type != CONDITION){
//根据查询类型判断是否关闭连接等对象
this.close(con, ps, rs);
}
}
return priseResultSet(rs,ps,con);
}
/***
* 解析执行SQL后返回的固定结构的数据集
*
* 返回的List中有两个对象:ListM和ListMV,ListMV中包含有rs的数据行数所对应的Map数,
* 每一个Map中都存有一行完整的数据库数据
*
* @param rs 查询得到数据集
* @return List 返回一份从数据库查询出来,由rs解析得到的数据集
*/
public List priseResultSet(ResultSet rss,PreparedStatement ps,Connection con){
List<Object> list = new ArrayList<Object>();
if(rss == null){
return null;
}
//结果集
ResultSet rs = rss;
try {
//由结果集得到数据库表、字段信息
ResultSetMetaData rsmd = rs.getMetaData();
//数据库表字段数量
int count = rsmd.getColumnCount();
//封装列名
Map<Object,String> mk = new HashMap<Object,String>();
for(int i=1;i<=count;i++){
//键值对的格式为:index, 列名
mk.put(i, rsmd.getColumnName(i));
}
list.add(mk);//添加封装列名的Map
//封装列名和值的集合
List<Map> listm = new ArrayList<Map>();
while(rs.next()){
//通过遍历结果集,得到与结果集对应的Map数量
Map<Object,Object> m = new HashMap<Object,Object>();
//表字段的数量,循环查找对应列类型,及赋值给Map,这里一个Map对象封装的是: 列名, 列值
for(int i=1;i<=count;i++){
//列类型
int colType = rsmd.getColumnType(i);
//列名
String colName = rsmd.getColumnName(i);
//字符串类
if(colType == java.sql.Types.CHAR){
m.put(colName, rs.getString(colName));
}
if(colType == java.sql.Types.VARCHAR){
m.put(colName, rs.getString(colName));
}
//日期类
if(colType == java.sql.Types.DATE){
m.put(colName, rs.getDate(colName));
}
if(colType == java.sql.Types.TIMESTAMP){
m.put(colName, rs.getDate(colName));
}
//浮点数类
if(colType == java.sql.Types.DECIMAL){
m.put(colName, rs.getDouble(colName));
}
if(colType == java.sql.Types.DOUBLE){
m.put(colName, rs.getDouble(colName));
}
if(colType == java.sql.Types.FLOAT){
m.put(colName, rs.getFloat(colName));
}
//整形类
if(colType == java.sql.Types.INTEGER){
m.put(colName, rs.getInt(colName));
}
if(colType == java.sql.Types.SMALLINT){
m.put(colName, rs.getInt(colName));
}
if(colType == java.sql.Types.TINYINT){
m.put(colName, rs.getInt(colName));
}
if(colType == java.sql.Types.BIGINT){
m.put(colName, rs.getInt(colName));
}
}
listm.add(m);
}
list.add(listm);//添加值
} catch (SQLException e) {
e.printStackTrace();
} finally {
this.close(con, ps, rs);
}
return list;
}
/***
* 关闭
* @param con
* @param ps
* @param rs
*/
public void close(Connection con, PreparedStatement ps, ResultSet rs){
try {
if(rs != null){
rs.close();
}
if(ps != null){
ps.close();
}
if(con != null){
con.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
然后测试
public static void main(String[] args) {
PublicDao dao = new PublicDao();
Map<Object, String> mk = new HashMap<Object, String>();
Map<Object, Object> mv = new HashMap<Object, Object>();
mk.put(1, "A");
mk.put(2, "B");
mk.put(3, "C");
mk.put(4, "D");
mk.put(5, "E");
mk.put(6, "F");
mv.put(1, "A");
mv.put(2, "B");
mv.put(3, "C");
String condition = "=1, =2, <3";
String sql = dao.createSql(PublicDao.SELECT, "TableName", mk, mv, condition);
System.out.println(sql);
}
得到结果:
select A,B,C,D,E,F from TableName where 1=1 and A=1 and B=2 and C<3
有了这些基本的处理方法,就能满足比较简单的增删改查和简单的多表查询的操作。
这个类实现以下几个目标:
1. 要查询的表在调用时指定,所以跟具体的表实现了分离;
2. 在调用该类执行操作时,需要指定操作类型(createSql方法的第一个参数),由此具体的操作类型我们可以不再关心了。
3. 逻辑比较简单:构造SQL——>执行Execute(解析结果集)——>关闭对象
4. createSql方法规范了调用方式,不会再看到泛滥的SQL,SQL被固定在了持久层,当然类型CONDITION的操作除外。
但是也有一些问题,如下:
1. 为了支持多表查询,还是妥协的暴露的一个操作类型CDONDITION,createSql方法目前还不能强大到执行复杂度太高的SQL。
2. 调用的方法显得有些复杂,做过很多思考,尽可能让createSql方法的参数简单,很遗憾,智商有限啊
3. 不能支持分页查询SQL构造,这个需求将在下一篇介绍,毕竟只是个雏形啊,哪能一蹴而就
小总结了一下,还有一些小优点:
1. 调试。你所有的SQL只会在同一个地方执行(executeSql方法),你只需要打一个断点,Ok,错误们,找到你们更easy了。
2. 这里返回的是List和Map,不是实体类对象,你可以随便造出任何实体类对象,来跟List里面的数据耦合。当然,这些实体类要实现自动与List装配,必须有一些规范,后面我也会做介绍。
总结,以上对付的,只是基于简单的数据操作,我在使用之后发现我的持久层就孤零零的几个类,代码结构简洁了许多。之后我做了一些扩展,增加分页查询的支持是必须的,对多表查询的支持我也会尽量做到(我考虑过,由于操作比较复杂,还不如直接写SQL,性价比不高```)。有任何问题和建议,希望各位看官大大的提出来,我会继续努力实现尽可能的操作简单化。
~~~平时看别人的博客没怎么在意,今天写这些居然花了一下午,En,多多锻炼````