钢炮级 持久层 —— 上篇

Title：核心处理基类

    平时接到很多规模不大的小型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，多多锻炼````