[框架那点事儿-快速开发季]编写自己的数据持久层（7）总结篇

// 备注：本章节的代码较多，在IE下显示有点问题，请用firefox浏览，或者请留下邮箱，我会将整个工程打包发送

 

在前面的六篇文章中，针对日常开发常用到的DB的操作对spring框架的jdbcTemplate进行了一定的封装，从增删查改四个方面，针对于全字段、部分字段、单一、批量几个方面展开来一一封装，提供了30多个API，基本能够覆盖日常开发所需的DB操作，降低一定的工作成本，提高工作效率。在这个封装的过程中，遇到了不少在进行这个专题工作前没有思考到的问题，也伴随着不断的代码新增、重构优化，将能考虑到的问题解决，首先先总结一下，自己都遇到哪些方面的问题：

 

1、数据库中获取数据如何交给DO类？同样的，在避免代码中出现sql的情况下，只使用API的时候，如何使用尽量少的参数来完成诸如查询sql语句条件参数设置？

第一个小问题，数据库中获取的数据，要传递给DO类，最快捷的方式就是通过set方法，而set方法的调用并没有一个特定的渠道，针对不同的字段都能自动完成，所以针对不同的字段，我们需要自己去判断调用其相应的set方法。这样来操作，是否我们需要针对于每一个字段都去判断名称，然后手动的调用一次set方法呢？

当然不能那么的人肉化，我们的方案是，根据字段的名称，自动解析set方法名称，然后通过反射区调用set方法，这里调用set方法还需要一个参数，这个参数就是从数据库中取出的值，这样就完成了字段的赋值。这里遇到了一个问题，就是参数类型不匹配的问题，抛出argument not match type异常，这个问题的解决我们将在下面的第2个问题中解决。

上面第二个小问题，关于sql语句查询条件的问题，我们想既然我们能够用过反射的方法调用set方法，那么肯定也可以通过反射的方法调用get方法来完成Do中的值的取出过程。所以这个问题也就迎刃而解了！

 

同时自动装配sql，我们通过引入自定义注解@Table来实现DO和Table的对应。

 

2、数据库的类型和java类型转换的问题。

从数据库中取出的ResultSet后根据name获取特定字段的值，拿到的数据的类型并非是Do类中对应字段的类型，而是一个笼统的Object类型，所以需要我们反向获取DO中的类型，然后以此进行转换，再利用反射调用set方法设置DO中向上提供。

这里还遇到一个问题是，封装的类型放入Map<String,Object>保存的时候，由于之前set进去的数据是String类型，后续再次放入的Date类型的数据，会自动变成字符串类型，时间值成为了一个字符串，在上层方法进行转换的时候，会发生数据类型转换错误异常，所以，这里需要针对于不能直接与String进行转换的参数进行手动的转换。这个解释不知道是否是发生这个类型自动转换问题的原因，至少目前debug来看，这个过程是难以控制的。

 

3、数据库获取Date类型字段空值的问题其实在连接数据库的时候使用zeroDateTimeBehavior=convertToNull就可以解决，但是这个方法一直是不是很满意的解决方案，虽然这样可以避免出现上述问题，但是从代码健壮性来看，应该至少提供一种空值的控制手段，来避免发生这种“可预知”的异常。

 

4、API的覆盖面的问题。

这个问题也是最困扰我的问题，我一直尝试能够使用纯API的方式覆盖日常所有的sql操作，但是封装到一定复杂度的时候我发现，我的代码的复杂度，尤其是API使用上的复杂度，已经远远超出了解决这条sql的使用问题，也就是说使用最笨拙的封装sql来完成操作都要简单的多。

而且这样的问题不断的涌现出来，尤其是到了后期，当简单应用场景都解决掉之后，基本上对于稍微复杂点的应用场景，都要重新开始提供一个API来解决，包括其中的级联查询问题等，甚至是使用简单的and和or组合的查询等，都日益明显的暴露我们现有的简单API的狭隘性。所以我回顾了hibernate和ibatis在使用上的一些习惯，发现他们很聪明的利用调用者编写sql，同时在sql中使用占位符的形式标识参数的手段来解决掉各种各样的应用场景无法自动封装sql的问题。所以我在想我的工作是否走进了死胡同，是否我应该退出来，重新尝试用一种新的手段来解决上述sql不能都统一自动生成的问题。

于是我删除了大片大片的代码，并且决定借用ibatis的这个方式，即使用占位符的形式，接受不同的sql语句，渲染占位符并进行操作的方式来完成不同应用场景的需求。所以这样继续我的工作，我将API分成大致三类：

1、纯使用java代码来完成的简单需求，诸如简单的不同字段的and组合查询，单值查询，这类的sql我通过自动的sql生成机制来完成；

2、使用jdbcTemplate默认占位符"?"（问号）的形式，这种方式的优点在于用户自定义sql，然后只需要传入sql和相应的参数就可以满足不同的需求，我们的参数采用的是Map的形式，这样的类型选择带来的致命问题是：sql中对于一个字段的多次操作，也就是需求是一个字段key多个value的时候，将无法满足！所以我们可以知道，为什么jdbcTemplate采用的参数类型Object[]，而不是其他的类型，而且在其低层实现上，它也是通过次序来一次渲染完成。所以一旦我们Object[]赋值顺序异常，会导致sql无法执行或者执行结果错误。

既然我们采用Map来不分次序的传递参数，程序自己解析对应的参数应该放到什么位置，但却丧失了处理一个字段在sql中多次操作的能力，如between and 或者一个字段多个or的操作等。

这是否让这种API成了鸡肋？

3、针对于上述的一些问题，我引入了类似ibatis的采用自定义名称的占位符，如"#param1#"或者"#name#"等，这样，用户传入的sql只需要是使用占位符的形式，并且传入Map中指定不同占位符的value值，我们通过自动的解析装配，来渲染最终的sql。

这样彻底解决了单列多操作的问题，也解决了Map单纯使用DO属性名称无法传递多个value的问题。比如针对于id字段，在 id between 1 and 10的应用场景中，我们可以通过 id between #id1# and #id2# 来满足。

 

还是要说一句的是，在没有思考清楚前就错误的选择Map来作为参数传递值，确实是一个失误。在后面的工作中，我考虑过如何解决Map的问题，如果真的要解决这个问题，根本的就是解决一个key多个value的问题，很自然的想到了List，但是难道要使用List<Map>来完成吗？那样调用者在组装参数的时候会疯掉……所以还是保留Map吧，针对于简单操作，作为一种便捷API，其他的不能满足的方面，有第三种自定义占位符的方式解决。

 

好了，一些细节的问题，就不去罗嗦，现在先看一下我们目前所有开发出来的API：

 

1、新增一条记录API(点击expand resource可以展开代码)

 

/** * 新增一条记录 * <p> * 要求DO：遵循spring风格的getter和setter方法 * 属性的名称和数据库的名称要对应，大小写不区分 * 示例: * ----------------------------------------------------- * TABLE Person{ * ID BIGINT NOT NULL, * NAME VARCHAR(16) .... * }//数据库中字段为大写 * ----------------------------------------------------- * class Person{ * private long id; * private String name; * }//DO类中的字段为小写 * ----------------------------------------------------- * Person person = new Person(); * person.setName("quzishen"); * long id = insertObject(person); * * </p> * @param 插入对象 * @return 主键ID * @throws RuntimeException */ public int insertObject(Object object) throws RuntimeException{ if(null == object){ throw new RuntimeException("can not inser a null value!"); } // 获取类型 @SuppressWarnings("rawtypes") Class objectClass = object.getClass(); // 使用SimpleJdbcInsert完成插入的动作 SimpleJdbcInsert inserActor = getSimpleJdbcInsert(objectClass); // 获取属性数组 Field[] fields = getFieldsFromClass(objectClass); // 获取插入数据库sql需要的参数Map Map<String, Object> paramMap = getParamMap(object, fields); //简便起见，可以使用SqlParameterSource parameters = new BeanPropertySqlParameterSource(Actor); // 获取到的参数为空 if(null == paramMap){ throw new RuntimeException("can not insert a null value!"); } //执行插入并返回主键 return inserActor.executeAndReturnKey(paramMap).intValue(); }

 

2、查询对象类API(点击expand resource可以展开代码)

 

//~~~===============================query object begin===================================~~~// /** * 查询单一对象 * <p> * 要求：遵循spring风格的getter和setter方法 * 属性的名称和数据库的名称要对应，大小写不区分 * 这里一定要注意，如果属性的大小写有点个性非常强的个人色彩， * 那么相应的setter方法要保证'set'后的属性首字母大写，其他字母大小写保持不变 * 如：pArAm ----> getPArAm & setPArAm * 示例： * ------------------------------------------------------------- * class Person{ * private long id; * } * ------------------------------------------------------------- * Map<String,Object> params = new HashMap<String,Object>(); * params.put("id","10000"); * Person person = (Person) queryForObject(params,Person.class); * * </p> * @param params 查询条件map,key 属性名字 大小写无所谓 * @param returnClass 对象类型 * @return 查询结果 */ public Object queryForObject(Map<String,Object> params,@SuppressWarnings("rawtypes") final Class returnClass) throws RuntimeException{ //获取表名 tableName = getTableConfigName(returnClass); // 组装查询sql，参数使用占位符 String sql = buildQuerySql(null,params,-1,-1,true); return queryForObjectBySql(sql,returnClass); } /** * 根据自定义sql查询对象，主要封装了rowMapper的转换过程 * 要求：遵循spring风格的getter和setter方法 * 属性的名称和数据库的名称要对应，大小写不区分 * 这里一定要注意，如果属性的大小写有点个性非常强的个人色彩， * 那么相应的setter方法要保证'set'后的属性首字母大写，其他字母大小写保持不变 * 如：pArAm ----> getPArAm & setPArAm * 使用示例： * ----------------------------------------------------- * String sql = "select * from Person where name='name' and (address='d1' or address='d2') and type=2; * Person p = (Person) queryForObjectBySql(sql,Person.class); * * @param sql 自定义sql，不适用占位符 * @param returnClass 返回类型 * @return 封装好的对象 */ public Object queryForObjectBySql(String sql,@SuppressWarnings("rawtypes") final Class returnClass){ return queryForObject(sql,returnClass); } /** * 根据sql和参数查询对象 * 使用示例 * ---------------------------------------------------------- * String sql = "select * from Person where id=#param1# and name=#param2# and age in (#age#) order by #param3# desc"; * * Map<String,Object> params = new HashMap<String,Object>(); * params.put("param1","10000"); * params.put("param2","quzishen"); * params.put("param3","score"); * params.put("age",new Object[]{25,26,27,28,29}); * * Person p = (Person) queryForObjectBySql(sql,params,Person.class); * * @param sql 查询语句，使用占位符 * @param params 参数，可以null * @param returnClass 返回对象类型 * @return */ public Object queryForObjectBySql(String sql,Map<String,Object> params,@SuppressWarnings("rawtypes") final Class returnClass){ // 自动将sql中的占位符替换成具体值 sql = getSqlFromPlaceHolder(sql,params); return queryForObject(sql, returnClass); } /** * 根据sql和参数查询部分字段 * 具体sql用法请参见queryForObjectBySql方法 * @param sql 查询语句，使用占位符 * @param params 参数 ，可以null * @param returnClass 返回对象类型 * @return */ public Map<String,Object> queryForMapBySql(String sql,Map<String,Object> params,@SuppressWarnings("rawtypes") final Class returnClass){ List<Map<String,Object>> list = queryForMapList(sql,params,returnClass); if(null == list || 0 == list.size()){ return null; }else { return list.get(0); } } //~~~query object end~~~//

 

3、查询列表类API(点击expand resource可以展开代码)

//~~~===============================query object list begin===================================~~~// /** * 查询对象列表结果 * <p> * 要求：遵循spring风格的getter和setter方法 * 属性的名称和数据库的名称要对应，大小写不区分 * 这里一定要注意，如果属性的大小写有点个性非常强的个人色彩， * 那么相应的setter方法要保证'set'后的属性首字母大写，其他字母大小写保持不变 * 如：pArAm ----> getPArAm & setPArAm * 示例： * ------------------------------------------------------------- * class Person{ * private String desc; * } * ------------------------------------------------------------- * Map<String,Object> params = new HashMap<String,Object>(); * params.put("desc","10000"); * List<Person> persons = (List<Person>) queryForList(params,Person.class); * * </p> * @param params 参数Map * @param returnClass 返回列表中的对象类型 * @return */ @SuppressWarnings("rawtypes") public List queryForObjectList(Map<String,Object> params,final Class returnClass){ return queryForObjectListOrderRow(params,returnClass); } /** * 查询对象列表结果，查询按照指定列排序 * <p> * 关于排序列（可变长度参数部分）： * 根据排序的列的次序依次排列，每个Map中存放一个键值对，允许指定的排序为 asc || desc * * 示例： * Map<String,String> orderByName = new HashMap<String,String>(); * orderByName.put("name","asc"); * * Map<String,String> orderByAge = new HashMap<String,String>(); * orderByName.put("age","desc"); * * Map<String,String> orderByType = new HashMap<String,String>(); * orderByName.put("type","asc"); * * queryForListOrderRow(params,returnClass,orderByName,orderByAge,orderByType) * </p> * @param params * @param returnClass * @param orders * @return */ @SuppressWarnings("rawtypes") public List queryForObjectListOrderRow(Map<String,Object> params, final Class returnClass, Map<String,String>... orders){ //获取表名 tableName = getTableConfigName(returnClass); // 组装查询sql，参数使用占位符替代 String sql = buildQuerySql(null,params,-1,-1,false,orders); if(logger.isDebugEnabled()){ logger.debug("RUN SQL:"+sql); } //执行查询 return queryForList(sql,params,returnClass); } /** * 根据sql查询对象列表，全字段查询并封装成特定类型 * <p> * 本方法服务于那些自定义sql进行查询的需求。上述的方法中的查询条件皆为普通的and关系，这个方法可以自定义任何类型的sql * 方法主要封装了rowMapper的转换过程。 * 如果外部sql使用占位符?,那么sql中采用的参数不能有针对同一个字段，如between操作，否则无法使用map传递一个字段的两个参数。 * 如果外部sql已经封装成能直接查询的语句，即没有使用占位符？，则params可以传NULL * </p> * @param sql 查询sql "select * from person where id=?" or "select * from person where id=1" * @param params 参数，可以为null * @param returnClass 返回类型 List<? extends Object> * @return */ @SuppressWarnings("rawtypes") public List queryForObjectListBySql(String sql,Map<String,Object> params,Class returnClass){ if(logger.isDebugEnabled()){ logger.debug("RUN SQL:"+sql); } //执行查询 return queryForList(sql,params,returnClass); } /** * 根据sql和占位符#param#查询 * 提供了另外一种占位符的形式，即用##包含的形式,使得查询更加明确而且功能更加强大 * 使用示例 * ------------------------------------------------------------- * String sql = "select * from table where name=#name# and id between #id1# and #id2#"; * Map<String,String> params = new HashMap<String,String>(); * params.put("name","quzishen"); * params.put("id1","1"); * params.put("id2","10"); * * queryForObjectListBySqlWithPlaceHolder(sql,params,Person.class); * * @param sql * @param params 可以为NULL * @param returnClass * @return */ @SuppressWarnings("rawtypes") public List queryForObjectListBySqlWithPlaceHolder(String sql,Map<String,Object> params,Class returnClass){ // 自动将sql中的占位符替换成具体值 sql = getSqlFromPlaceHolder(sql,params); return queryForList(sql, null,returnClass); } //~~~query object list end~~~//

 

4、查询属性列表类API(点击expand resource可以展开代码)

//~~~===============================query fields list begin===================================~~~// /** * 查询部分字段 * <p> * 根据指定的属性名称查询特定字段，返回一个List<Map<属性名称，属性值>> * * 使用示例： * --------------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * //设置需要查询的字段名称，名称使用DO中的即可 * List<String> fields = new ArrayList<String>(); * fields.add("id"); * fields.add(name); * fields.add("address"); * * List<Map<String,Object>> resultList = queryFieldsList(Person.class,params,fields); * ... * * </p> * @param objectClass 返回属性所在的类 * @param objectClass * @param params 查询参数map * @param returnFields 返回字段列表 * @return 返回值，用map保存每一列的结果 */ public List<Map<String,Object>> queryFieldsList(@SuppressWarnings("rawtypes")final Class objectClass,Map<String,Object> params,List<String> returnFields){ return queryFieldsListOrderRow(objectClass,params,returnFields); } /** * 查询部分字段,查询结果根据指定列排序 * <p> * 根据指定的属性名称查询特定字段，并且根据指定的列排序，返回一个List<Map<属性名称，属性值>> * 使用示例： * --------------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * //设置需要查询的字段名称，名称使用DO中的即可 * List<String> fields = new ArrayList<String>(); * fields.add("id"); * fields.add(name); * fields.add("address"); * * Map<String,String> orderByAge = new HashMap<String,String>(); * orderByName.put("age","desc"); * * Map<String,String> orderByType = new HashMap<String,String>(); * orderByName.put("type","asc"); * * List<Map<String,Object>> resultList = queryFieldsList(Person.class,params,fields,orderByAge,orderByType); * ... * * </p> * @param objectClass 返回属性所在的类 * @param params 查询参数map * @param returnFields 返回字段列表 * @param orders 查询语句排序指定字段 * @return 返回值，用map保存每一列的结果 */ public List<Map<String,Object>> queryFieldsListOrderRow(@SuppressWarnings("rawtypes")final Class objectClass, Map<String,Object> params,List<String> returnFields,Map<String,String>... orders){ //获取表名 tableName = getTableConfigName(objectClass); // 组装查询sql，参数使用占位符替代 String sql = buildQuerySql(returnFields,params,-1,-1,false,orders); return queryForMapList(sql,params,objectClass); } /** * 根据指定sql查询部分字段 * <p> * 如果外部封装的sql不使用占位符，则params传NULL * 如果外部封装的sql使用占位符，则sql不能有针对于一个字段的两个操作如between，否则map无法传递一个参数的两个值 * </p> * @param sql 查询sql，参数使用占位符 * @param params 查询参数 * @param objectClass 字段所在Do类型 * @return List<Map<String,Object>> */ public List<Map<String,Object>> queryFieldsListBySql(String sql,Map<String,Object> params,@SuppressWarnings("rawtypes")final Class objectClass){ return queryForMapList(sql,params,objectClass); } /** * 根据指定的sql和参数查询部分字段 * <p> * 参数使用##形式的占位符 * 使用示例 * ------------------------------------------------------------- * String sql = "select id,name,age from table where name=#name# and id between #id1# and #id2#"; * Map<String,String> params = new HashMap<String,String>(); * params.put("name","quzishen"); * params.put("id1","1"); * params.put("id2","10"); * * queryFieldsListBySqlWithPlaceHolder(sql,params,Person.class); * </p> * @param sql sql语句，使用##形式的占位符 * @param params 参数，可以为null * @param objectClass * @return */ public List<Map<String,Object>> queryFieldsListBySqlWithPlaceHolder(String sql,Map<String,Object> params,@SuppressWarnings("rawtypes")final Class objectClass){ // 自动将sql中的占位符替换成具体值 sql = getSqlFromPlaceHolder(sql,params); return queryForMapList(sql,null,objectClass); } //~~~query fields list end~~~//

 

5、分页类API(点击expand resource可以展开代码)

/** * 分页查询对象 * <p> * 根据指定参数分页查询对象列表 * 用法示例： * ---------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * Paginal p = queryObjectListForPaging(Person.class,params,1,10); * ... * </p> * @param objectClass 对象类型 * @param params 查询参数 * @param pageNomber 页号 * @param pageSize 分页大小 * @return 分页封装 */ @SuppressWarnings({ "rawtypes"}) public Paginal queryObjectListForPaging(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize){ return queryObjectListForPagingOrderRow(objectClass,params,pageNomber,pageSize); } /** * 分页-排序查询对象 * <p> * 分页查询，结果按照指定的条件排序 * 使用示例 * ---------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * Map<String,String> orderByAge = new HashMap<String,String>(); * orderByName.put("age","desc"); * * Map<String,String> orderByType = new HashMap<String,String>(); * orderByName.put("type","asc"); * * Paginal p = queryObjectListForPagingOrderRow(Person.class,params,1,10,orderByAge,orderByType); * ... * </p> * @param objectClass 字段所在类 * @param params 查询参数 * @param pageNomber 页号 * @param pageSize 分页大小 * @param orders 排序字段 * @return 查询结果 */ @SuppressWarnings({ "rawtypes", "unchecked"}) public Paginal queryObjectListForPagingOrderRow(final Class objectClass,Map<String,Object> params,int pageNomber,int pageSize,Map<String,String>... orders){ //~~~ return value Paginal<? extends Object> paginal = new Paginal<Object>(); // 初始化分页器 paginal.setPageNomber(pageNomber); paginal.setPageSize(pageSize); //获取表名 tableName = getTableConfigName(objectClass); //组装查询sql语句 String sql = buildQuerySql(null, params, paginal.getOffset(),paginal.getPageSize(),false,orders); //查询总记录数 int totalCount = queryCount(params,objectClass); paginal.setTotalCount(totalCount);//总记录数 paginal.setPageNum(totalCount,paginal.getPageSize());//总页码 //执行查询 List resultList = queryForList(sql,params,objectClass); paginal.setResultList(resultList); return paginal; } /** * 根据sql自动分页查询 * 传入的sql不需要关注分页内容，只需要关注于普通查询部分，方法内部自动实现分页查询 * 返回封装好的分页器 * 使用示例 * -------------------------------------------------------------- * String sql = "select * from Person where (name='quzishen' or name='zishenqu') and age=25"; * * Paginal p = queryObjectListForPagingBySql(sql,Person.class,1,10); * ... * @param sql * @param objectClass * @param pageNomber * @param pageSize * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) public Paginal queryObjectListForPagingBySql(String sql,final Class objectClass,int pageNomber,int pageSize){ //~~~ return value Paginal<? extends Object> paginal = getPaginalBySql(sql,pageNomber,pageSize); //自动添加分页部分 sql = getPagingSql(sql, paginal.getOffset(), paginal.getPageSize()); // 执行查询 List resultList = queryForList(sql,null,objectClass); paginal.setResultList(resultList); return paginal; } /** * 分页查询-使用占位符## * 使用示例 * ---------------------------------------------------------- * String sql = "select * from NOR_QUICK_NEWS where name=#name# and prop1=#prop1#"; * * Map<String, Object> params = new HashMap<String, Object>(); * params.put("name", name); * params.put("prop1", prop1); * * queryObjectListForPagingBySqlWithPlaceHolder(sql, params,NorQuickNews.class, pageNum, pageSize); * ... * 传入的sql不需要关注分页内容，只需要关注于普通查询部分，方法内部自动实现分页查询 * @param sql * @param params * @param objectClass * @param pageNomber * @param pageSize * @return */ @SuppressWarnings("rawtypes") public Paginal queryObjectListForPagingBySqlWithPlaceHolder(String sql,Map<String,Object> params,final Class objectClass,int pageNomber,int pageSize){ sql = getSqlFromPlaceHolder(sql,params); return queryObjectListForPagingBySql(sql,objectClass,pageNomber,pageSize); } /** * 分页查询部分字段 * <p> * 使用示例 * ----------------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * //设置需要查询的字段名称，名称使用DO中的即可 * List<String> fields = new ArrayList<String>(); * fields.add("id"); * fields.add(name); * fields.add("address"); * * Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10); * ... * </p> * @param objectClass 字段所在的类 * @param params 查询参数 * @param returnFields 需要查询的字段列表 * @param pageNomber 页号 * @param pageSize 分页大小 * @return 查询结果 */ @SuppressWarnings({ "rawtypes"}) public Paginal queryFieldsListForPaging(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize){ return queryFieldsListForPagingOrderRow(objectClass,params,returnFields,pageNomber,pageSize); } /** * 分页-排序查询部分字段 * <p> * 使用示例 * ----------------------------------------------------------------- * //设置查询参数 * Map<String,Object> params = new HashMap(); * params.put("city","hangzhou"); * * //设置需要查询的字段名称，名称使用DO中的即可 * List<String> fields = new ArrayList<String>(); * fields.add("id"); * fields.add(name); * fields.add("address"); * * Map<String,String> orderByAge = new HashMap<String,String>(); * orderByName.put("age","desc"); * * Map<String,String> orderByType = new HashMap<String,String>(); * orderByName.put("type","asc"); * * Paginal p = queryFieldsListForPaging(objectClass,params,fields,1,10,orderByAge,orderByType); * ... * </p> * @param objectClass 字段所在的类 * @param params 查询参数 * @param returnFields 需要查询的字段列表 * @param pageNomber 页号 * @param pageSize 分页大小 * @param orders 排序字段 * @return 查询结果 */ @SuppressWarnings({ "rawtypes", "unchecked" }) public Paginal queryFieldsListForPagingOrderRow(final Class objectClass,Map<String,Object> params,List<String> returnFields,int pageNomber,int pageSize,Map<String,String>... orders){ //~~~ return value Paginal<? extends Object> paginal = new Paginal<Object>(); // 初始化分页器 paginal.setPageNomber(pageNomber); paginal.setPageSize(pageSize); //获取表名 tableName = getTableConfigName(objectClass); //组装查询sql语句 String sql = buildQuerySql(returnFields, params, paginal.getOffset(),paginal.getPageSize(),false,orders); //查询总记录数 int totalCount = queryCount(params,objectClass); paginal.setTotalCount(totalCount);//总记录数 paginal.setPageNum(totalCount,pageSize);//总页码 //查询 得到 List<Map<String,Object>> List resultList = queryForMapList(sql,params,objectClass); paginal.setResultList(resultList); return paginal; } /** * 根据指定sql查询部分参数 * @param sql * @param objectClass * @param pageNomber * @param pageSize * @return */ @SuppressWarnings({ "rawtypes", "unchecked" }) public Paginal queryFieldsListForPagingbySql(String sql,final Class objectClass,int pageNomber,int pageSize){ //~~~ return value Paginal<? extends Object> paginal = getPaginalBySql(sql,pageNomber,pageSize); //自动添加分页部分 sql = getPagingSql(sql, paginal.getOffset(), paginal.getPageSize()); // 执行查询 List resultList = queryForMapList(sql,null,objectClass); paginal.setResultList(resultList); return paginal; } /** * 使用占位符sql分页查询部分参数 * 占位符使用##形式 * @param sql * @param params * @param objectClass * @param pageNomber * @param pageSize * @return */ @SuppressWarnings("rawtypes") public Paginal queryFieldsListForPagingbySqlWithPlaceHolder(String sql,Map<String,Object> params,final Class objectClass,int pageNomber,int pageSize){ // 渲染占位符 sql = getSqlFromPlaceHolder(sql, params); // 执行查询 return queryFieldsListForPagingbySql(sql,objectClass,pageNomber,pageSize); }

 

6、查询记录数类API(点击expand resource可以展开代码)

/** * 查询总记录数 * <p> * 根据指定查询条件查询记录总数，一般用于分页中等 * </p> * @param params 查询条件参数 * @param objectClass 对象类型 * @return 记录数 */ @SuppressWarnings({ "rawtypes"}) public int queryCount(Map<String,Object> params,Class objectClass){ //获取表名 tableName = getTableConfigName(objectClass); //组装查询总记录数sql语句 String countsql = buildQueryConteSql(params); //查询对象,存储查询条件数组 Object[] queryObject = getQueryObject(params,countsql); //查询总记录数 int totalCount = getJdbcTemplate().queryForInt(countsql, queryObject); return totalCount; } /** * 通过sql语句查询结果记录数 * @param sql 查询sql * @return 记录数 */ public int queryCount(String sql){ sql = getCountSqlFromSelectSql(sql); //查询总记录数 int totalCount = getJdbcTemplate().queryForInt(sql); return totalCount; }

 

7、修改类API(点击expand resource可以展开代码)

/** * 根据查询条件修改记录 * 除了ID之外的全字段修改，适用于从数据库取出的对象的修改。不适合单字段或部分字段修改。 * <p> * 要求DO：遵循spring风格的getter和setter方法 * 属性的名称和数据库的名称要对应，大小写不区分 * 示例: * ----------------------------------------------------- * TABLE Person{ * ID BIGINT NOT NULL, * NAME VARCHAR(16) .... * }//数据库中字段为大写 * ----------------------------------------------------- * class Person{ * private long id; * private String name; * }//DO类中的字段为小写 * ----------------------------------------------------- * Person person = new Person(); * person.setName("quzishen"); * * Map<String,Object> conditions = new HashMap<String,Object>(); * conditions.put("ID","1"); * * long id = updateObject(person); * * </p> * @param 修改后的对象值 * @param 查询条件，可以单独只有一个ID * @return * @throws RuntimeException */ public int updateObject(Object object,Map<String,Object> conditions) throws RuntimeException{ if(null == object){ throw new RuntimeException("can not insert a null value!"); } //获取表名 tableName = getTableConfigName(object.getClass()); //获取sql String sql = buildUpdateObjectSql(object,true,conditions); //执行更新 return getJdbcTemplate().update(sql); } /** * 根据查询条件更新部分字段 * <p> * 适用于更新部分字段情况 * 使用示例： * ----------------------------------------------------- * Map<String,Object> params = new HashMap<String,Object>(); * params.put("status","expired"); * * Map<String,Object> conditions = new HashMap<String,Object>(); * conditions.put("status","use"); * * updateField(params,conditions,Person.class); * * </p> * @param params 需要更新的字段以及值 * @param conditions 查询条件 * @param objectClass 字段所在的DO类的类型 * @return * @throws RuntimeException */ public int updateField(Map<String,Object> params,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass) throws RuntimeException{ if(null == params || 0 == params.size()){ throw new RuntimeException("can not insert a null value!"); } //获取表名 tableName = getTableConfigName(objectClass); //获取sql String sql = buildUpdateFieldSql(params, objectClass, true, conditions); //执行更新 return getJdbcTemplate().update(sql); } /** * 根据sql修改记录，sql使用##形式占位符 * 使用示例: * ---------------------------------------------------------------- * String sql = "update NOR_QUICK_NEWS set " + propName + "=#prop# where name=#name#"; * * Map<String, Object> conditions = new HashMap<String, Object>(); * conditions.put("prop", propValue); * conditions.put("name", name); * * return updateFieldBySqlWithPlaceHolder(sql, conditions, * NorQuickNews.class); * * @param sql * @param conditions * @param objectClass * @return */ public int updateFieldBySqlWithPlaceHolder(String sql,Map<String,Object> conditions,@SuppressWarnings("rawtypes") Class objectClass){ sql = getSqlFromPlaceHolder(sql, conditions); //执行更新 return getJdbcTemplate().update(sql); }

 

8、批量插入/修改类API(点击expand resource可以展开代码)

/** * 批量插入 * <p> * 批量将对象列表插入到数据库中，主键自动生成。 * 可以选择是否使用分页插入模式，当数据量比较大的时候可以选择，以提升性能； * · 开启分页插入模式的条件： 1、moreThanOnce 设置 true 。 2、列表总长度大于单次最大插入数目，默认500，可修改。 * * 使用示例 * ------------------------------------------------------- * List<Person> addlist = new ArrayList<Person>(); * Person p1 = new Person(); * p1.init(...); * Person p2 = new Person(); * p2.init(...); * * addlist.add(p1); addlist.add(p2); * * batchInsert(addlist,Person.class); * ... * </p> * @param updateList 插入列表 * @param objectClass 列表对象类型 * @throws RuntimeException */ @SuppressWarnings("rawtypes") public void batchInsert(List<? extends Object> updateList,Class objectClass,boolean moreThanOnce) throws RuntimeException{ if(null == updateList || 0 == updateList.size()){ throw new RuntimeException("can not inser null value!"); } // 获取SimpleJdbcInsert SimpleJdbcInsert inserActor = getSimpleJdbcInsert(objectClass); // 如果选择批量插入，并且列表长度大于单次插入最大值，则使用分页插入 if(moreThanOnce && insertPageSize < updateList.size()){ // 需要的分页总数 int totalPage = (0==updateList.size() % insertPageSize) ? (updateList.size() / insertPageSize) : (updateList.size() / insertPageSize+1); // 开始分页插入 for(int pageNo=1;pageNo<=totalPage;pageNo++){ int fromIndex = 0; int endIndex = updateList.size() > insertPageSize ? insertPageSize : updateList.size(); List<? extends Object> subList = updateList.subList(fromIndex, endIndex);//[) //insert into db insertSqlParameterSourceInfoDB(subList,inserActor); } }else { // 不分页直接插入 insertSqlParameterSourceInfoDB(updateList,inserActor); } } /** * 根据ID批量更新 * <p> * 使用示例 * -------------------------------------------------------------------------------- * class Person{ * ①、private static final long serialVersionUID = 4311010571442992834L;//位置可以在这里 * private long id; * ②、private static final long serialVersionUID = 4311010571442992834L;//位置可以在这里 * private String name; * ③、private static final long serialVersionUID = 4311010571442992834L;//位置可以在这里 * } * //上述类过滤后的顺序为 id - name * * updateList.add(p1); * updateList.add(p2); * updateList.add(p3); * * batchUpdate(updateList,Person.class); * ... * </p> * @param updateList 更新列表 * @param objectClass 更新对象类型 * @throws RuntimeException */ @SuppressWarnings("rawtypes") public void batchUpdate(final List updateList,Class objectClass) throws RuntimeException{ if(null == updateList || 0 == updateList.size()){ throw new RuntimeException("can not inser null value!"); } // 获取一个对象 Object object = getInstanceByClass(objectClass); // 生成更新sql,update table set .x = ?.. where id = ? Map<String,Object> conditions = new HashMap<String,Object>(); conditions.put(DEFAULT_ID_NAME, SQL_PLACE_HOLDER); //获取表名 tableName = getTableConfigName(object.getClass()); String sql = buildUpdateObjectSql(object, false, conditions); // 获取属性数组,其中不包括数据库中不含有的字段 serivalversionUID final Field[] fields = getFieldsMatchedDBFromClass(objectClass,false); /** * 执行批量更新操作 * 生成的sql中的占位符的顺序和DO类中顺序固定，所以这里也要按照DO类中的顺序来实施 * 在Fields中包含了部分与数据库不匹配的字段，有serivalversionuid.所以应该去除掉 */ getJdbcTemplate().batchUpdate(sql, new BatchPreparedStatementSetter(){ public int getBatchSize() { return updateList.size(); } // 设置参数 public void setValues(PreparedStatement preparedStatement, int index) throws SQLException { Object o = updateList.get(index); for(Field field : fields){ //列从1开始计数，但是方法内部也从0开始计数，所以这里需要加1 int row =1+getFieldIndexOfObject(fields, field.getName()); String value = getValueByName(o,field.getName()); preparedStatement.setString(row, value); } // 设置最后的一位，即更新条件，此处为ID,sql中参数总数为fields.length，加1可以判断最后一个ID参数的位置 preparedStatement.setString(fields.length+1, getValueByName(o,DEFAULT_ID_NAME)); } }); }

 

9、删除类API(点击expand resource可以展开代码)

/** * 根据ID删除 * @param id 记录ID * @param objectClass DO类型 * @return 操作记录数目 */ public int deletebyId(long id,@SuppressWarnings("rawtypes") Class objectClass){ // 获取表名 tableName = getTableConfigName(objectClass); // 组装sql String sql = SQL_DELETE+SQL_FROM+ tableName +SQL_WHERE+ DEFAULT_ID_NAME +"= "+ id; // 执行删除 return getJdbcTemplate().update(sql); } /** * 根据sql删除，sql使用##占位符 * 使用示例 * --------------------------------------------------------- * String sql = "delete from NOR_QUICK_NEWS where name=#name#"; * * Map<String, Object> conditions = new HashMap<String, Object>(); * conditions.put("name", name); * * return deleteBySqlWithPlaceHolder(sql, conditions); * @param sql 删除sql * @param params 参数 * @return 操作记录数目 */ public int deleteBySqlWithPlaceHolder(String sql,Map<String,Object> params){ // 获取sql，渲染参数 sql = getSqlFromPlaceHolder(sql, params); // 执行删除 return getJdbcTemplate().update(sql); }

 

以上是目前封装的所有的API，共分成9个大类，可以满足日常开发所需。其中包含一下三个文件：

 

AbstractBaseDAO

 代码较多，请参见：

 

 [框架那点事儿-快速开发季]编写自己的数据持久层（7）总结篇 代码  

  http://blog.csdn.net/quzishen/archive/2010/08/03/5786323.aspx

分页器Paginal

 

package com.normandy.position.common; import java.io.Serializable; import java.util.List; /** * 分页器 * <p> * mysql的分页机制：limit offset,pagesize [] 从0开始计数偏移offset位的pagesize条数据 * 比如： * pagesize = 10; * ------------------------------------------------- * | 页号 | 起始地址 | 结束地址 | 包含记录ID |offset| * ------------------------------------------------- * | 1 | 0 | 9 |0,1,2...9 | 0 | * | 2 | 10 | 19 |10,11,12...19 | 10 | * | 3 | 20 | 29 |20,22,23...29 | 20 | * -------------------------------------------------- * * 用法示例： * limit getOffset(),pagesize; * </p> * @author quzishen * @param <T> 查询结果的具体类型 */ public class Paginal<T extends Object> implements Serializable{ private static final long serialVersionUID = -5159256681785242925L; // 分页大小 private int pageSize; // 页号，从1开始 private int pageNomber; // 总记录数 private int totalCount; // 总页数 private int pageNum; // 查询对象列表 private List<T> resultList; /** * 获取当前页的起始地址 * @return 起始地址 */ protected int getBeginIndex(){ return (pageNomber - 1)*pageSize; } /** * 获取当前页的结束地址 * @return 结束地址 */ protected int getEndIndex(){ return pageNomber*pageSize - 1; } /** * 获取当前页的偏移量 * @return 偏移量 */ protected int getOffset(){ if(pageNomber == 1){ return 0; } else { return (pageNomber-1)*pageSize; } } /** * 根据总记录数和分页大小设置总页数 * @param totalCount 总记录数 * @param pagesize 分页大小 */ public void setPageNum(int totalCount,int pagesize){ int num = totalCount / pagesize; if(0 != totalCount % pagesize){ num += 1; } pageNum = num; } public int getPageSize() { return pageSize; } public void setPageSize(int pageSize) { this.pageSize = pageSize; } public int getPageNomber() { return pageNomber; } public void setPageNomber(int pageNomber) { this.pageNomber = pageNomber; } public int getTotalCount() { return totalCount; } public void setTotalCount(int totalCount) { this.totalCount = totalCount; } public int getPageNum() { return pageNum; } public void setPageNum(int pageNum) { this.pageNum = pageNum; } public List<T> getResultList() { return resultList; } public void setResultList(List<T> resultList) { this.resultList = resultList; } }

 

注解Table

 

 package com.normandy.position.common; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 针对于数据库表的配置的注解 * * 工程名称：NormandyPosition * 类型名称：Table * 概要： * <p> 目前主要用于配置数据库表名 </p> * 创建时间：2010-7-28 上午10:40:42 * 创建人：quzishen * 最后修改时间：2010-7-28 上午10:40:42 * 最后修改内容： * @version 1.0 */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Table { /**~~~~ 表名*/ String tableName() default("table"); }

 

其中的使用代码和单元测试代码如下：

 

假设我们现在要开发一个热报系统（所谓的热报就是CMS的一种实现方式，大致就是在后天填写数据，在前台某个页面的部分展示）

 

数据库结构：

 

DROP TABLE IF EXISTS `normandy`.`nor_quick_news`; CREATE TABLE `normandy`.`nor_quick_news` ( `ID` bigint(20) unsigned NOT NULL AUTO_INCREMENT, `NAME` varchar(45) CHARACTER SET gbk NOT NULL, `PROP1` varchar(16) CHARACTER SET gbk DEFAULT NULL, `PROP2` varchar(32) CHARACTER SET gbk DEFAULT NULL, `PROP3` varchar(32) CHARACTER SET gbk DEFAULT NULL, `PROP4` varchar(64) CHARACTER SET gbk DEFAULT NULL, `PROP5` varchar(64) CHARACTER SET gbk DEFAULT NULL, `PROP6` varchar(128) CHARACTER SET gbk DEFAULT NULL, `PROP7` varchar(128) CHARACTER SET gbk DEFAULT NULL, `PROP8` varchar(256) CHARACTER SET gbk DEFAULT NULL, `PROP9` varchar(256) CHARACTER SET gbk DEFAULT NULL, PRIMARY KEY (`ID`), KEY `Index_2` (`NAME`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1;

 

热报DAO interface

package com.normandy.position.dao; import java.util.List; import java.util.Map; import com.normandy.position.common.Paginal; import com.normandy.position.domain.NorQuickNews; /** * 热报操作接口 * * @author quzishen */ public interface NorQuickNewsDAO { /** * 增加一条热报 * * @param norQuickNews * 热报信息，主键ID为空 * @return 插入主键ID */ public int addQuickNews(NorQuickNews norQuickNews); /** * 根据ID查询热报 * * @param id * 主键 * @return 热报 */ public NorQuickNews queryQuickNewsById(long id); /** * 根据名称查询热报，需要业务上确保只能查到一条，否则抛错 * * @param name * @return */ public NorQuickNews queryQuickNewsByName(String name); /** * 查询最新的十条热报 * * @return */ public NorQuickNews queryLastestQuickNews(); /** * 根据name查询最新热报 * * @param name * @return */ public NorQuickNews queryLastedQuickNewsByName(String name); /** * 根据名称查询热报列表 * * @param name * @return */ public List<NorQuickNews> queryNorQuickNewsListByName(String name); /** * 根据名称查询热报列表 ,按时间倒序排列 * * @param name * @return */ public List<NorQuickNews> queryNorQuickNewsListByNameOrderByGmtCreate( String name); /** * 根据某个属性查询热报列表 * * @param propName * @param propValue * @return */ public List<NorQuickNews> queryNorQuickNewsByProp(String propName, String propValue); /** * 根据prop1查询所有热报 * * @param prop1Value * @return */ public List<NorQuickNews> queryNorQuickNewsBetweenIds(long id1, long id2); /** * 根据ID查询name * * @param id * @return */ public String queryQuickNewsNameById(long id); /** * 根据时间逆序查询ID、名称、时间 * * @return */ public List<Map<String, Object>> getQuickNewsIdAndNameOrderByTime(); /** * 根据prop查询ID/NAME/GMT_CREATE * * @param propValue * @return */ public List<Map<String, Object>> getQuickNewsIdAndNameByProp( String propName, String propValue); /** * 根据名字分页查询 * * @param name * @param pageNum * @param pageSize * @return */ public Paginal<NorQuickNews> queryQuickNewsByNameForPaging(String name, int pageNum, int pageSize); /** * 根据name和prop1分页查询 * @param name * @param prop1 * @param pageNum * @param pageSize * @return */ public Paginal<NorQuickNews> queryQuickNewsByNameAndProp1ForPaging( String name, String prop1, int pageNum, int pageSize); /** * 根据name分页查询ID，prop1,prop2 * @param name * @param pageNum * @param pageSize * @return */ public Paginal<Map<String, Object>> queryIdAndProp1Prop2ByName(String name, int pageNum, int pageSize); /** * 根据name查询数量 * @param name * @return */ public int getCountByName(String name); /** * 查询所有的不同的name数量 * @return */ public int distincCountByName(); /** * 根据ID修改 * @param id * @param norQuickNews * @return */ public int updateById(long id,NorQuickNews norQuickNews); /** * 根据ID修改prop * @param id * @param propMap * @return */ public int updatePropById(long id,Map<String,Object> propMap); /** * 根据name修改属性 * @param propName * @param propValue * @param name * @return */ public int updatePropByName(String propName, String propValue, String name); /** * 批量插入热报 * @param list */ public void batchInserQucikNews(List<NorQuickNews> list); /** * 批量更新，根据ID * @param list */ public void batchUpdateQuickNews(List<NorQuickNews> list); /** * 根据ID删除 * @param id */ public int deleteQuickNewsById(long id); /** * 根据name删除 * @param name * @return */ public int deleteQuickNewsByName(String name); }

 

其具体的实现类，继承了上述的抽象父类，并调用其中的方法，内部为了测试基本上调用了所有的父类API：

package com.normandy.position.dao; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import com.normandy.position.common.AbstractBaseDAO; import com.normandy.position.common.Paginal; import com.normandy.position.domain.NorQuickNews; /** * 热报DAO实现类 * * @author quzishen * */ public class NorQuickNewsDAOImpl extends AbstractBaseDAO implements NorQuickNewsDAO { /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#addQuickNews(com.normandy.position * .domain.NorQuickNews) */ public int addQuickNews(NorQuickNews norQuickNews) { return insertObject(norQuickNews); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#queryQuickNewsById(long) */ public NorQuickNews queryQuickNewsById(long id) { Map<String, Object> params = new HashMap<String, Object>(); params.put("id", id); return (NorQuickNews) queryForObject(params, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryQuickNewsByName(java.lang * .String) */ public NorQuickNews queryQuickNewsByName(String name) { Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return (NorQuickNews) queryForObject(params, NorQuickNews.class); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#queryLastestQuickNews() */ public NorQuickNews queryLastestQuickNews() { String sql = "select * from NOR_QUICK_NEWS order by gmt_create desc limit 1"; return (NorQuickNews) queryForObjectBySql(sql, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryLastedQuickNewsByName( * java.lang.String) */ public NorQuickNews queryLastedQuickNewsByName(String name) { String sql = "select * from NOR_QUICK_NEWS where name=#name# order by gmt_create desc limit 1"; Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return (NorQuickNews) queryForObjectBySql(sql, params, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryNorQuickNewsListByName * (java.lang.String) */ @SuppressWarnings("unchecked") public List<NorQuickNews> queryNorQuickNewsListByName(String name) { Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return queryForObjectList(params, NorQuickNews.class); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO# * queryNorQuickNewsListByNameOrderByGmtCreate(java.lang.String) */ @SuppressWarnings("unchecked") public List<NorQuickNews> queryNorQuickNewsListByNameOrderByGmtCreate( String name) { Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); Map<String, String> order = new HashMap<String, String>(); order.put("gmt_create", "desc"); return queryForObjectListOrderRow(params, NorQuickNews.class, order); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryNorQuickNewsByProp(java * .lang.String, java.lang.String) */ @SuppressWarnings("unchecked") public List<NorQuickNews> queryNorQuickNewsByProp(String propName, String propValue) { String sql = "select * from NOR_QUICK_NEWS where " + propName + " = ?"; Map<String, Object> params = new HashMap<String, Object>(); params.put(propName, propValue); return queryForObjectListBySql(sql, params, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryNorQuickNewsByProp1(java * .lang.String) */ @SuppressWarnings("unchecked") public List<NorQuickNews> queryNorQuickNewsBetweenIds(long id1, long id2) { String sql = "select * from NOR_QUICK_NEWS where id between #id1# and #id2#"; Map<String, Object> params = new HashMap<String, Object>(); params.put("id1", id1); params.put("id2", id2); return queryForObjectListBySqlWithPlaceHolder(sql, params, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryQuickNewsNameById(long) */ public String queryQuickNewsNameById(long id) { Map<String, Object> params = new HashMap<String, Object>(); params.put("id", id); List<String> fields = new ArrayList<String>(); fields.add("name"); List<Map<String, Object>> list = queryFieldsList(NorQuickNews.class, params, fields); if (null != list && 0 < list.size()) { String name = null == list.get(0).get("name") ? "" : list.get(0) .get("name").toString(); return name; } else { return null; } } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#getQuickNewsIdAndNameOrderByTime * () */ @SuppressWarnings("unchecked") public List<Map<String, Object>> getQuickNewsIdAndNameOrderByTime() { Map<String, String> orderTime = new HashMap<String, String>(); orderTime.put("gmt_create", "desc"); List<String> fields = new ArrayList<String>(); fields.add("id"); fields.add("name"); fields.add("gmt_create"); return queryFieldsListOrderRow(NorQuickNews.class, null, fields, orderTime); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#getQuickNewsIdAndNameByProp * (java.lang.String, java.lang.String) */ public List<Map<String, Object>> getQuickNewsIdAndNameByProp( String propName, String propValue) { String sql = "select id,name,gmt_create from NOR_QUICK_NEWS where " + propName + "=#propValue#"; Map<String, Object> params = new HashMap<String, Object>(); params.put("propValue", propValue); return queryFieldsListBySqlWithPlaceHolder(sql, params, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryQuickNewsByNameForPaging * (java.lang.String, int, int) */ @SuppressWarnings("unchecked") public Paginal<NorQuickNews> queryQuickNewsByNameForPaging(String name, int pageNum, int pageSize) { Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return queryObjectListForPaging(NorQuickNews.class, params, pageNum, pageSize); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO# * queryQuickNewsByNameAndProp1ForPaging(java.lang.String, java.lang.String, * int, int) */ @SuppressWarnings("unchecked") public Paginal<NorQuickNews> queryQuickNewsByNameAndProp1ForPaging( String name, String prop1, int pageNum, int pageSize) { String sql = "select * from NOR_QUICK_NEWS where name=#name# and prop1=#prop1#"; Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); params.put("prop1", prop1); return queryObjectListForPagingBySqlWithPlaceHolder(sql, params, NorQuickNews.class, pageNum, pageSize); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#queryIdAndProp1Prop2ByName( * java.lang.String, int, int) */ @SuppressWarnings("unchecked") public Paginal<Map<String, Object>> queryIdAndProp1Prop2ByName(String name, int pageNum, int pageSize) { String sql = "select id,prop1,prop2 from NOR_QUICK_NEWS where name=#name#"; Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return queryFieldsListForPagingbySqlWithPlaceHolder(sql, params, NorQuickNews.class, pageNum, pageSize); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#getCountByName(java.lang.String * ) */ public int getCountByName(String name) { Map<String, Object> params = new HashMap<String, Object>(); params.put("name", name); return queryCount(params, NorQuickNews.class); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#distincCountByName() */ public int distincCountByName() { String sql = "select count(1) from ( select distinct(name) from NOR_QUICK_NEWS) a"; return queryCount(sql); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#updateById(long, * com.normandy.position.domain.NorQuickNews) */ public int updateById(long id, NorQuickNews norQuickNews) { Map<String, Object> conditions = new HashMap<String, Object>(); conditions.put("ID", id); return updateObject(norQuickNews, conditions); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#updatePropById(long, * java.util.Map) */ public int updatePropById(long id, Map<String, Object> propMap) { Map<String, Object> conditions = new HashMap<String, Object>(); conditions.put("id", id); return updateField(propMap, conditions, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#updatePropByName(java.lang. * String, java.lang.String, java.lang.String) */ public int updatePropByName(String propName, String propValue, String name) { String sql = "update NOR_QUICK_NEWS set " + propName + "=#prop# where name=#name#"; Map<String, Object> conditions = new HashMap<String, Object>(); conditions.put("prop", propValue); conditions.put("name", name); return updateFieldBySqlWithPlaceHolder(sql, conditions, NorQuickNews.class); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#batchInserQucikNews(java.util * .List) */ public void batchInserQucikNews(List<NorQuickNews> list) { batchInsert(list, NorQuickNews.class, false); } /* * (non-Javadoc) * * @see * com.normandy.position.dao.NorQuickNewsDAO#batchUpdateQuickNews(java.util * .List) */ public void batchUpdateQuickNews(List<NorQuickNews> list) { batchUpdate(list, NorQuickNews.class); } /* * (non-Javadoc) * * @see com.normandy.position.dao.NorQuickNewsDAO#deleteById(long) */ public int deleteQuickNewsById(long id) { return deletebyId(id, NorQuickNews.class); } /* * (non-Javadoc) * @see com.normandy.position.dao.NorQuickNewsDAO#deleteQuickNewsByName(java.lang.String) */ public int deleteQuickNewsByName(String name) { String sql = "delete from NOR_QUICK_NEWS where name=#name#"; Map<String, Object> conditions = new HashMap<String, Object>(); conditions.put("name", name); return deleteBySqlWithPlaceHolder(sql, conditions); } }

 

热报DO类

package com.normandy.position.domain; import java.io.Serializable; import java.util.Date; import com.normandy.position.common.Table; /** * 热报DO，对应于数据库表NOR_QUICK_NEWS * @author quzishen */ @Table(tableName = "NOR_QUICK_NEWS") public class NorQuickNews implements Serializable { private static final long serialVersionUID = -4777096683339361256L; private long id; private String prop1; private String prop2; private String prop3; private String prop4; private String prop5; private String prop6; private String prop7; private String prop8; private String prop9; private String name; private Date gmt_Create; public long getId() { return id; } public void setId(long id) { this.id = id; } public String getProp1() { return prop1; } public void setProp1(String prop1) { this.prop1 = prop1; } public String getProp2() { return prop2; } public void setProp2(String prop2) { this.prop2 = prop2; } public String getProp3() { return prop3; } public void setProp3(String prop3) { this.prop3 = prop3; } public String getProp4() { return prop4; } public void setProp4(String prop4) { this.prop4 = prop4; } public String getProp5() { return prop5; } public void setProp5(String prop5) { this.prop5 = prop5; } public String getProp6() { return prop6; } public void setProp6(String prop6) { this.prop6 = prop6; } public String getProp7() { return prop7; } public void setProp7(String prop7) { this.prop7 = prop7; } public String getProp8() { return prop8; } public void setProp8(String prop8) { this.prop8 = prop8; } public String getProp9() { return prop9; } public void setProp9(String prop9) { this.prop9 = prop9; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getGmt_Create() { return gmt_Create; } public void setGmt_Create(Date gmt_Create) { this.gmt_Create = gmt_Create; } }

 

单元测试代码：

package test; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import junit.framework.TestCase; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.normandy.position.common.Paginal; import com.normandy.position.dao.NorQuickNewsDAO; import com.normandy.position.domain.NorQuickNews; /** * 热报DAO单元测试 * * @author quzishen * */ public class NorQuickNewsDAOTest extends TestCase { private NorQuickNewsDAO norQuickNewsDAO; @Override protected void setUp() throws Exception { super.setUp(); ApplicationContext applicationContext = new ClassPathXmlApplicationContext( "test/applicationContext.xml"); norQuickNewsDAO = (NorQuickNewsDAO) applicationContext .getBean("norQuickNewsDAO"); } public void testAdd() { NorQuickNews norQuickNews = new NorQuickNews(); norQuickNews.setProp1("prop1"); norQuickNews.setProp2("normandy"); norQuickNews.setProp3("future"); norQuickNews.setProp4("prop4"); norQuickNews.setProp5("prop5"); norQuickNews.setProp6("prop6"); norQuickNews.setProp7("prop7"); norQuickNews.setProp8("prop8"); norQuickNews.setProp9("prop9"); norQuickNews.setName("indexPublicInfo"); norQuickNews.setGmt_Create(new Date()); long id = norQuickNewsDAO.addQuickNews(norQuickNews); assertNotNull(id); System.out.println(id); } public void testQueryQuickNewsById() { NorQuickNews norQuickNews = norQuickNewsDAO.queryQuickNewsById(1); assertNotNull(norQuickNews); assertEquals(norQuickNews.getId(), 1); assertEquals(norQuickNews.getProp1(), "prop1"); assertEquals(norQuickNews.getProp2(), "normandy"); assertEquals(norQuickNews.getProp3(), "future"); assertEquals(norQuickNews.getProp4(), "1"); assertEquals(norQuickNews.getProp5(), "2"); assertEquals(norQuickNews.getProp6(), "3"); assertEquals(norQuickNews.getProp7(), "4"); assertEquals(norQuickNews.getProp8(), "5"); assertEquals(norQuickNews.getProp9(), "6"); assertEquals(norQuickNews.getName(), "name1"); } public void testQueryQuickNewsByName() { NorQuickNews norQuickNews = norQuickNewsDAO .queryQuickNewsByName("name1"); assertNotNull(norQuickNews); assertEquals(norQuickNews.getId(), 1); assertEquals(norQuickNews.getProp1(), "prop1"); assertEquals(norQuickNews.getProp2(), "normandy"); assertEquals(norQuickNews.getProp3(), "future"); assertEquals(norQuickNews.getProp4(), "1"); assertEquals(norQuickNews.getProp5(), "2"); assertEquals(norQuickNews.getProp6(), "3"); assertEquals(norQuickNews.getProp7(), "4"); assertEquals(norQuickNews.getProp8(), "5"); assertEquals(norQuickNews.getProp9(), "6"); assertEquals(norQuickNews.getName(), "name1"); } public void testQueryLastestQuickNews() { NorQuickNews norQuickNews = norQuickNewsDAO.queryLastestQuickNews(); assertNotNull(norQuickNews); System.out.println(norQuickNews.getId()); System.out.println(norQuickNews.getGmt_Create()); } public void testQueryLastedQuickNewsByName() { NorQuickNews norQuickNews = norQuickNewsDAO .queryLastedQuickNewsByName("indexPublicInfo"); assertNotNull(norQuickNews); System.out.println(norQuickNews.getId()); System.out.println(norQuickNews.getGmt_Create()); } public void testQueryNorQuickNewsListByName() { List<NorQuickNews> list = norQuickNewsDAO .queryNorQuickNewsListByName("indexPublicInfo"); assertNotNull(list); assertEquals(list.size(), 8); } public void testQueryNorQuickNewsListByNameOrderByGmtCreate() { List<NorQuickNews> list = norQuickNewsDAO .queryNorQuickNewsListByNameOrderByGmtCreate("indexPublicInfo"); assertNotNull(list); assertEquals(list.size(), 8); assertEquals(list.get(0).getId(), 12); } public void testQueryNorQuickNewsByProp() { List<NorQuickNews> list = norQuickNewsDAO.queryNorQuickNewsByProp( "prop1", "prop1"); assertNotNull(list); assertEquals(list.size(), 15); } public void testQueryNorQuickNewsByProp1() { List<NorQuickNews> list = norQuickNewsDAO.queryNorQuickNewsBetweenIds( 10, 14); assertNotNull(list); assertEquals(list.size(), 5); } public void testQueryQuickNewsNameById() { String name = norQuickNewsDAO.queryQuickNewsNameById(1); assertNotNull(name); assertEquals(name, "name1"); } public void testGetQuickNewsIdAndNameOrderByTime() { List<Map<String, Object>> list = norQuickNewsDAO .getQuickNewsIdAndNameOrderByTime(); assertNotNull(list); for (Map<String, Object> m : list) { assertNotNull(m.get("id")); assertNotNull(m.get("name")); assertNull(m.get("prop1")); } } public void testGetQuickNewsIdAndNameByProp() { List<Map<String, Object>> list = norQuickNewsDAO .getQuickNewsIdAndNameByProp("prop1", "prop1"); assertNotNull(list); for (Map<String, Object> m : list) { assertNotNull(m.get("id")); assertNotNull(m.get("name")); assertNull(m.get("prop1")); } } public void testQueryQuickNewsByNameForPaging() { Paginal<NorQuickNews> p = norQuickNewsDAO .queryQuickNewsByNameForPaging("indexPublicInfo", 1, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).getId(), 8); assertEquals(p.getResultList().get(1).getId(), 9); assertEquals(p.getResultList().get(2).getId(), 10); p = norQuickNewsDAO.queryQuickNewsByNameForPaging("indexPublicInfo", 2, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).getId(), 11); assertEquals(p.getResultList().get(1).getId(), 12); assertEquals(p.getResultList().get(2).getId(), 13); } public void testQueryQuickNewsByNameAndProp1ForPaging() { Paginal<NorQuickNews> p = norQuickNewsDAO .queryQuickNewsByNameAndProp1ForPaging("indexPublicInfo", "prop1", 1, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).getId(), 8); assertEquals(p.getResultList().get(1).getId(), 9); assertEquals(p.getResultList().get(2).getId(), 10); p = norQuickNewsDAO.queryQuickNewsByNameAndProp1ForPaging( "indexPublicInfo", "prop1", 2, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).getId(), 11); assertEquals(p.getResultList().get(1).getId(), 12); assertEquals(p.getResultList().get(2).getId(), 13); } public void testQueryIdAndProp1Prop2ByName() { Paginal<Map<String, Object>> p = norQuickNewsDAO .queryIdAndProp1Prop2ByName("indexPublicInfo", 1, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).get("id").toString(), "8"); p = norQuickNewsDAO.queryIdAndProp1Prop2ByName("indexPublicInfo", 2, 3); assertNotNull(p); assertNotNull(p.getResultList()); assertEquals(p.getResultList().size(), 3); assertEquals(p.getResultList().get(0).get("id").toString(), "11"); } public void testGetCountByName() { int sum = norQuickNewsDAO.getCountByName("indexPublicInfo"); assertEquals(sum, 8); } public void testDistincCountByName(){ int sum = norQuickNewsDAO.distincCountByName(); assertEquals(sum, 3); } public void testUpdateById(){ NorQuickNews norQuickNews = norQuickNewsDAO.queryQuickNewsById(3); norQuickNews.setName("love"); norQuickNews.setProp1("i love u"); norQuickNews.setProp2("i love u"); int id = norQuickNewsDAO.updateById(3, norQuickNews); assertNotNull(id); } public void testUpdatePropById(){ Map<String,Object> propMap = new HashMap<String,Object>(); propMap.put("prop5", "ok2go"); propMap.put("prop6", "ok2go"); int id = norQuickNewsDAO.updatePropById(5, propMap); assertNotNull(id); } public void testUpdatePropByName(){ int id = norQuickNewsDAO.updatePropByName("prop9", "ayaya", "indexPublicInfo"); assertNotNull(id); } public void testBatchInserQucikNews(){ List<NorQuickNews> list = new ArrayList<NorQuickNews>(); for(int i=0;i<20;i++){ NorQuickNews q = new NorQuickNews(); q.setProp1(i+"prop1"); q.setProp2(i+"prop2"); q.setProp3(i+"prop3"); q.setProp4(i+"prop4"); q.setProp5(i+"prop5"); q.setProp6(i+"prop6"); q.setProp7(i+"prop7"); q.setProp8(i+"prop8"); q.setProp9(i+"prop9"); q.setName("batchInsert"); q.setGmt_Create(new Date()); list.add(q); } norQuickNewsDAO.batchInserQucikNews(list); } public void testBatchUpdateQuickNews(){ List<NorQuickNews> list = norQuickNewsDAO.queryNorQuickNewsListByName("batchInsert"); for(NorQuickNews n:list){ n.setProp6("batchUpdate"); n.setGmt_Create(new Date()); } norQuickNewsDAO.batchUpdateQuickNews(list); } public void testDeleteQuickNewsById(){ int id = norQuickNewsDAO.deleteQuickNewsById(35); assertNotNull(id); assertEquals(id, 1); } public void testDeleteQuickNewsByName(){ int id = norQuickNewsDAO.deleteQuickNewsByName("love"); assertNotNull(id); assertEquals(id, 1); } }

 

（完）

 

因为第一章上了首页，很多朋友看了第一章的内容，感谢大家给予的理解和鼓励，愿与大家共同进步！

 

2010-08-02