平时接到很多规模不大的小型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的文章 http://xiejin2008.iteye.com/blog/370584，讲得很详细
把这个类贴上来，我比较犹豫，大家都看了千百遍了，但这也确实是够用的小成本连接池配置，能对付并发至少20的访问量，对于我所处理的项目来说，并发数达到20是比较少见的，所以这种方式对于我来说屡试不爽啊。。
然后是核心的逻辑处理类，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，多多锻炼````