hibernate
Chinasb's Blog
首页
Google App Engine
Ralasafe
开发手册
Spring注解大全
OFC2
NoSQL实战
蚂蚁运动
Browsing: / Home / 2011 / 六月 / spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
Print Email Shortlink
spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
BY ETHAN ON 2011 年 06 月 01 日 IN JAVA
原文链接：http://blog.csdn.net/tom_221x/archive/2009/08/22/4473873.aspx
以前写的一个改进版泛型dao,在这里 。基本实现了0代码编写dao。现在又加入了spring jdbc的支持，使得dao即可以用实体对象进行数据存取，有可以用jdbc的底层化操作删除，更新。结构见图：
具体代码和上图对应:
DaoTest.java
01
package com.test;
02
import javax.annotation.Resource;
03
import org.junit.Test;
04
import org.junit.runner.RunWith;
05
import org.springframework.test.context.ContextConfiguration;
06
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
07
import com.hibernate.entityclass.Daotest;
08
import com.tinylight.dao.base.IBaseDao;
09
@RunWith(SpringJUnit4ClassRunner.class)
10
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
11
public class DaoTest {
12
13
@Resource(name="demoDao")
14
private IBaseDao<Daotest,Integer> demoDao;
15
16
@Test
17
public void test(){
18
19
}
20
}
BaseDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.base;
005
import java.io.Serializable;
006
import java.util.Iterator;
007
import java.util.List;
008
import org.hibernate.Query;
009
import org.hibernate.SQLQuery;
010
import org.hibernate.Session;
011
import org.hibernate.StatelessSession;
012
import org.springframework.orm.hibernate3.HibernateTemplate;
013
import com.tinylight.dao.hibernate.GenericDao;
014
import com.tinylight.dao.hibernate.GenericEntityDao;
015
import com.tinylight.dao.jdbc.SimpleJdbcDao;
016
import com.tinylight.dao.support.Page;
017
/**
018
* @author scott.Cgi
019
* @since 2009-5-12
020
* 提供dao的所有操作<br>
021
* 实现类由spring注入:<br>
022
* {@link com.tinylight.dao.hibernate.GenericEntityDao}
023
* {@link com.tinylight.dao.hibernate.GenericDao}
024
* {@link com.tinylight.dao.jdbc.SimpleJdbcDao}
025
*/
026
public class BaseDao<T,PK extends Serializable> implements IBaseDao<T,PK>{
027
protected Class<T> entityClass;// DAO所管理的Entity类型.
028
private GenericEntityDao<T,PK> gedao;
029
private GenericDao gdao;
030
private SimpleJdbcDao sjdao;
031
032
public Class<T> getEntityClass() {return entityClass;}
033
public void setEntityClass(Class<T> entityClass) {this.entityClass = entityClass;}
034
035
public GenericEntityDao<T, PK> getGedao() {return gedao;}
036
public void setGedao(GenericEntityDao<T, PK> gedao) {this.gedao = gedao;}
037
038
public GenericDao getGdao() {return gdao;}
039
public void setGdao(GenericDao gdao) {this.gdao = gdao;}
040
041
public SimpleJdbcDao getSjdao() {return sjdao;}
042
public void setSjdao(SimpleJdbcDao sjdao) {this.sjdao = sjdao;}
043
/**
044
*让spring提供构造函数注入
045
*/
046
public BaseDao(Class<T> type) {
047
this.entityClass = type;
048
}
049
050
public BaseDao(){}
051
052
public void clear() {
053
gdao.clear();
054
}
055
056
public Query createQuery(String hql, Object... values) {
057
return gdao.createQuery(hql, values);
058
}
059
060
public void delete(T entityObject) {
061
gedao.delete(entityObject);
062
}
063
064
public void deleteById(PK id) {
065
gedao.deleteById(id);
066
}
067
068
public void evict(T entityObject) {
069
gedao.evict(entityObject);
070
}
071
072
public List<T> find(String hql, Object... values) {
073
return gdao.find(hql, values);
074
}
075
076
public List<T> findByNamedParams(String hql, String[] paramNames,
077
Object... values) {
078
return gdao.findByNamedParams(hql, paramNames, values);
079
}
080
081
public void flush() {
082
gdao.flush();
083
}
084
085
public List<T> getAll() {
086
return gedao.getAll();
087
}
088
089
public T getById(PK id) {
090
return gedao.getById(id);
091
}
092
093
public Session getNativeHibernateSession() {
094
return gdao.getNativeHibernateSession();
095
}
096
097
public StatelessSession getNativeStatelessHibernateSession() {
098
return gdao.getNativeStatelessHibernateSession();
099
}
100
101
public HibernateTemplate getSpringHibernateTemplate() {
102
return gdao.getSpringHibernateTemplate();
103
}
104
105
public Iterator<T> iterator(String hql, Object... values) {
106
return gdao.iterator(hql, values);
107
}
108
109
public SimpleJdbcDao jdbc() {
110
return sjdao;
111
}
112
113
public T load(PK id) {
114
return gedao.load(id);
115
}
116
117
public void load(T entityObject, PK id) {
118
gedao.load(entityObject, id);
119
}
120
121
public T merge(T entityObject) {
122
return gedao.merge(entityObject);
123
}
124
125
public SQLQuery nativeSqlQuery(String sql) {
126
return gdao.nativeSqlQuery(sql);
127
}
128
129
public Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize,
130
Object... values) {
131
return gdao.pagedQuery(countHql,hql, pageNo, pageSize, values);
132
}
133
134
public Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize,
135
Object... values) {
136
return gdao.pagedQueryByStartNo(countHql,hql, startNo, pageSize, values);
137
}
138
139
public void refresh(T entityObject) {
140
gedao.refresh(entityObject);
141
}
142
143
public void save(T entityObject) {
144
gedao.save(entityObject);
145
}
146
147
}
IBaseDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.base;
005
import java.io.Serializable;
006
import java.util.Iterator;
007
import java.util.List;
008
import org.hibernate.Query;
009
import org.hibernate.SQLQuery;
010
import org.hibernate.Session;
011
import org.hibernate.StatelessSession;
012
import org.springframework.orm.hibernate3.HibernateTemplate;
013
import com.tinylight.dao.jdbc.SimpleJdbcDao;
014
import com.tinylight.dao.support.Page;
015
/**
016
* @author scott.Cgi
017
* @since 2009-5-12
018
*
019
*/
020
public interface IBaseDao<T,PK extends Serializable> {
021
/**
022
* 根据主键类型的id获取实体对象,立即执行查询返回对象,数据库没有匹配则返回null
023
*/
024
public T getById(PK id);
025
026
/**
027
* 获取实体类型的全部对象
028
*/
029
public List<T> getAll();
030
031
/**
032
* 获取实体对象的代理,如果数据库没有匹配则异常,实体类有关联其它对象则延时加载
033
* @param id
034
* @return
035
*/
036
public T load(PK id);
037
038
/**
039
* 把数据加载到指定的非持久化实例上
040
* @param entityObject
041
* @param id
042
*/
043
public void load(T entityObject,PK id);
044
045
/**
046
* 删除对象.
047
*/
048
public void delete(T entityObject);
049
050
/**
051
* 根据id删除对象
052
* @param id
053
*/
054
public void deleteById(PK id);
055
056
/**
057
* 强迫装载对象和它的集合,使用了触发器的数据字段比较适合使用
058
* @param entityObject
059
*/
060
public void refresh(T entityObject);
061
062
/**
063
* 消除与 Hibernate Session 的关联
064
* @param entityObject
065
*/
066
public void evict(T entityObject);
067
068
/**
069
* 保存对象.<br>
070
* 如果对象已在本session中持久化了,不做任何事。<br>
071
* 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
072
* 如果没有持久化标识属性,调用save()。<br>
073
* 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
074
* 如果是附带版本信息的(version或timestamp)且版本属性表明为新的实例化对象就save()。<br>
075
* 否则调用update()重新关联托管对象
076
* @param entityObject
077
*/
078
public void save(T entityObject);
079
080
/**
081
* 如果对象已在本session中持久化了,覆盖原有的<br>
082
* 如果session中没有对应对象,从数据库加载<br>
083
* 如果是脱管对象,则什么都不做
084
* @param entityObject
085
* @return
086
*/
087
public T merge(T entityObject);
088
089
/**
090
* 根据hql查询,直接使用HibernateTemplate的find函数.
091
* @param <T>
092
* @param hql
093
* @param values
094
* @return
095
*/
096
public List<T> find(String hql, Object... values);
097
098
/**
099
* 根据命名参数查询
100
* @param <T>
101
* @param hql 带有命名参数的hql语句
102
* @param paramNames 命名参数的名字
103
* @param values 命名参数的值<br>
104
* <b>例如:</b><br>
105
* findByNamedParams("from Test where t1 = :t",new String[]{"t"},tValue);
106
* @return
107
*/
108
public List<T> findByNamedParams(String hql,String[] paramNames,Object...values);
109
110
/**
111
* 创建Query对象.<br>
112
* 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
113
* @param hql
114
* @param values
115
* @return
116
*/
117
public Query createQuery(String hql,Object... values);
118
119
/**
120
* 执行一些必须的sql语句把内存中的对象同步到数据库中
121
*/
122
public void flush();
123
124
/**
125
* 清除对象缓存
126
*/
127
public void clear();
128
129
/**
130
* 返回iterator接口类型的结果
131
* @param <T>
132
* @param hql
133
* @param values
134
* @return
135
*/
136
public Iterator<T> iterator(String hql,Object...values);
137
138
/**
139
* @return 当前上下文的原生Hibernate session对象,依然受到spring事务管理不需要手动close
140
*/
141
public Session getNativeHibernateSession();
142
143
/**
144
* @return 当前上下文的原生Hibernate StatelessSession对象<br>
145
* 此对象不级联关联实例,忽略集合不触发Hibernate事件模型和拦截器,没有一级缓存,没有持久化上下文,接近JDBC.
146
*/
147
public StatelessSession getNativeStatelessHibernateSession();
148
149
/**
150
* 执行本地查询获得SQLQuery对象<br>
151
* 可以调用addEntity(*.class).list();获得对应实体list集合<br>
152
* addEntity.add(*.class).addJoin(*.class).list();获得一对多代理对象<br>
153
* 更多用法见google
154
* @param sql
155
* @return
156
*/
157
public SQLQuery nativeSqlQuery(String sql);
158
159
/**
160
* @param <T>
161
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
162
* @param hql
163
* @param pageNo 页面号
164
* @param pageSize 页面容量
165
* @param values
166
* @return
167
*/
168
public Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize, Object... values);
169
170
/**
171
* @param <T>
172
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
173
* @param hql
174
* @param startNo 分页从哪一条数据开始
175
* @param pageSize 页面容量
176
* @param values
177
* @return
178
*/
179
public Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize, Object... values);
180
181
/**
182
* @return 获得spring的HibernateTemplate拥有更多的功能
183
*/
184
public HibernateTemplate getSpringHibernateTemplate();
185
186
/**
187
* @return 获得jdbc操作的超绚酷dao
188
*/
189
public SimpleJdbcDao jdbc();
190
}
GenericDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.hibernate;
005
import java.util.Iterator;
006
import java.util.List;
007
import org.hibernate.Query;
008
import org.hibernate.SQLQuery;
009
import org.hibernate.Session;
010
import org.hibernate.StatelessSession;
011
import org.springframework.orm.hibernate3.HibernateTemplate;
012
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
013
import com.tinylight.dao.support.Page;
014
/**
015
* 继承自spring的HibernateDaoSupport<br>
016
* 提供了和具体实体类无关的数据库操作
017
* @author scott.Cgi
018
* @since 2009-5-10
019
*
020
*/
021
public class GenericDao extends HibernateDaoSupport {
022
023
/**
024
* 根据hql查询,直接使用HibernateTemplate的find函数.
025
* @param <T>
026
* @param hql
027
* @param values
028
* @return
029
*/
030
@SuppressWarnings("unchecked")
031
public <T> List<T> find(String hql, Object... values) {
032
return this.getHibernateTemplate().find(hql, values);
033
}
034
035
/**
036
* 根据命名参数查询
037
* @param <T>
038
* @param hql 带有命名参数的hql语句
039
* @param paramNames 命名参数的名字
040
* @param values 命名参数的值<br>
041
* <b>例如:</b><br>
042
* findByNamedParams("from Test where t1 = :t",new String[]{"t"},tValue);
043
* @return
044
*/
045
@SuppressWarnings("unchecked")
046
public <T> List<T> findByNamedParams(String hql,String[] paramNames,Object...values){
047
return this.getHibernateTemplate().findByNamedParam(hql, paramNames, values);
048
}
049
050
/**
051
* 创建Query对象.<br>
052
* 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
053
* @param hql
054
* @param values
055
* @return
056
*/
057
public Query createQuery(String hql,Object... values) {
058
//这里的false表示不创建session保证,当前操作在spring同一个事务的管理下
059
Query query = this.getSession(false).createQuery(hql);
060
if (values != null) {
061
for (int i = 0; i < values.length; i++) {
062
query.setParameter(i, values[i]);
063
}
064
}
065
return query;
066
}
067
068
/**
069
* 执行一些必须的sql语句把内存中的对象同步到数据库中
070
*/
071
public void flush() {
072
this.getHibernateTemplate().flush();
073
}
074
075
/**
076
* 清除对象缓存
077
*/
078
public void clear() {
079
this.getHibernateTemplate().clear();
080
}
081
082
/**
083
* 返回iterator接口类型的结果
084
* @param <T>
085
* @param hql
086
* @param values
087
* @return
088
*/
089
@SuppressWarnings("unchecked")
090
public <T> Iterator<T> iterator(String hql,Object...values){
091
return this.getHibernateTemplate().iterate(hql, values);
092
}
093
094
/**
095
* @return 当前上下文的原生Hibernate session对象,依然受到spring事务管理不需要手动close
096
*/
097
public Session getNativeHibernateSession(){
098
return this.getSessionFactory().getCurrentSession();
099
}
100
101
/**
102
* @return 当前上下文的原生Hibernate StatelessSession对象<br>
103
* 此对象不级联关联实例,忽略集合不触发Hibernate事件模型和拦截器,没有一级缓存,没有持久化上下文,接近JDBC.
104
*/
105
public StatelessSession getNativeStatelessHibernateSession(){
106
return this.getSessionFactory().openStatelessSession();
107
}
108
109
/**
110
* 执行本地查询获得SQLQuery对象<br>
111
* 可以调用addEntity(*.class).list();获得对应实体list集合<br>
112
* addEntity.add(*.class).addJoin(*.class).list();获得一对多代理对象<br>
113
* 更多用法见google
114
* @param sql
115
* @return
116
*/
117
public SQLQuery nativeSqlQuery(String sql){
118
return this.getSession(false).createSQLQuery(sql);
119
}
120
121
/**
122
* @param <T>
123
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
124
* @param hql
125
* @param pageNo 页面号
126
* @param pageSize 页面容量
127
* @param values
128
* @return
129
*/
130
@SuppressWarnings("unchecked")
131
public <T> Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize, Object... values) {
132
// Count查询
133
List<T> countlist = this.getHibernateTemplate().find(countHql, values);
134
long totalCount = (Long) countlist.get(0);
135
if (totalCount < 1)
136
return new Page<T>();
137
// 当前页的开始数据索引
138
long startIndex = Page.getStartOfPage(pageNo, pageSize);
139
Query query = this.createQuery(hql, values);
140
List<T> list = query.setFirstResult((int) startIndex).setMaxResults(pageSize).list();
141
return new Page<T>(startIndex, totalCount, pageSize, list);
142
}
143
144
/**
145
* @param <T>
146
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
147
* @param hql
148
* @param startNo 分页从哪一条数据开始
149
* @param pageSize 页面容量
150
* @param values
151
* @return
152
*/
153
@SuppressWarnings("unchecked")
154
public <T> Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize, Object... values){
155
// Count查询
156
List<T> countlist = getHibernateTemplate().find(countHql, values);
157
long totalCount = (Long) countlist.get(0);
158
if (totalCount < 1)
159
return new Page();
160
161
int startIndex = startNo;
162
Query query = createQuery(hql, values);
163
List<T> list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
164
return new Page<T>(startIndex, totalCount, pageSize, list);
165
}
166
167
/**
168
* @return 获得spring的HibernateTemplate拥有更多的功能
169
*/
170
public HibernateTemplate getSpringHibernateTemplate(){
171
return this.getHibernateTemplate();
172
}
173
}
GenericEntityDao.java
view sourceprint?
001
/**
002
*
003
*/
004
package com.tinylight.dao.hibernate;
005
import java.io.Serializable;
006
import java.util.List;
007
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
008
/**
009
* 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类.<br>
010
* 子类只要在类定义时指定所管理Entity的Class<br>
011
* 即拥有对单个Entity对象的CRUD操作.
012
* @author scott.Cgi
013
* @since 2009-5-11
014
*
015
*/
016
public class GenericEntityDao<T,PK extends Serializable> extends HibernateDaoSupport {
017
018
protected Class<T> entityClass;// DAO所管理的Entity类型.
019
public void setEntityClass(Class<T> type){//注入实体类型
020
this.entityClass=type;
021
}
022
public Class<T> getEntityClass(){
023
return this.entityClass;
024
}
025
026
public GenericEntityDao(){}
027
public GenericEntityDao(Class<T> entityClass){this.entityClass = entityClass;}
028
/**
029
* 根据主键类型的id获取实体对象,立即执行查询返回对象,数据库没有匹配则返回null
030
*/
031
@SuppressWarnings("unchecked")
032
public T getById(PK id) {
033
return (T)this.getHibernateTemplate().get(this.entityClass, id);
034
}
035
036
/**
037
* 获取实体类型的全部对象
038
*/
039
@SuppressWarnings("unchecked")
040
public List<T> getAll() {
041
return (List<T>)(this.getHibernateTemplate().loadAll(this.entityClass));
042
}
043
044
/**
045
* 获取实体对象的代理,如果数据库没有匹配则异常,实体类有关联其它对象则延时加载
046
* @param id
047
* @return
048
*/
049
@SuppressWarnings("unchecked")
050
public T load(PK id){
051
return (T)this.getHibernateTemplate().load(this.entityClass, id);
052
}
053
054
/**
055
* 把数据加载到指定的非持久化实例上
056
* @param entityObject
057
* @param id
058
*/
059
public void load(T entityObject,PK id){
060
this.getHibernateTemplate().load(entityObject, id);
061
}
062
063
/**
064
* 删除对象.
065
*/
066
public void delete(T entityObject) {
067
this.getHibernateTemplate().delete(entityObject);
068
}
069
070
/**
071
* 根据id删除对象
072
* @param id
073
*/
074
public void deleteById(PK id){
075
this.delete(this.getById(id));
076
}
077
078
/**
079
* 强迫装载对象和它的集合,使用了触发器的数据字段比较适合使用
080
* @param entityObject
081
*/
082
public void refresh(T entityObject){
083
this.getHibernateTemplate().refresh(entityObject);
084
}
085
086
/**
087
* 消除与 Hibernate Session 的关联
088
* @param entityObject
089
*/
090
public void evict(T entityObject){
091
this.getHibernateTemplate().evict(entityObject);
092
}
093
094
/**
095
* 保存对象.<br>
096
* 如果对象已在本session中持久化了,不做任何事。<br>
097
* 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
098
* 如果没有持久化标识属性,调用save()。<br>
099
* 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
100
* 如果是附带版本信息的(version或timestamp)且版本属性表明为新的实例化对象就save()。<br>
101
* 否则调用update()重新关联托管对象
102
* @param entityObject
103
*/
104
public void save(T entityObject){
105
this.getHibernateTemplate().saveOrUpdate(entityObject);
106
}
107
108
/**
109
* 如果对象已在本session中持久化了,覆盖原有的<br>
110
* 如果session中没有对应对象,从数据库加载<br>
111
* 如果是脱管对象,则什么都不做
112
* @param entityObject
113
* @return
114
*/
115
@SuppressWarnings("unchecked")
116
public T merge(T entityObject){
117
return (T)this.getHibernateTemplate().merge(entityObject);
118
}
119
120
}
SimpleJdbcDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.jdbc;
005
import java.sql.Connection;
006
import java.sql.SQLException;
007
import org.springframework.jdbc.core.JdbcTemplate;
008
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
009
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;
010
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
011
import org.springframework.jdbc.datasource.DataSourceUtils;
012
import org.springframework.jdbc.support.GeneratedKeyHolder;
013
import org.springframework.jdbc.support.KeyHolder;
014
import org.springframework.jdbc.support.rowset.SqlRowSet;
015
/**
016
* 继承spring的SimpleJdbcDaoSupport
017
* 提供对数据库jdbc级别的操作
018
* 内部使用spring的SimpleJdbcTemplate与JdbcTemplate
019
* @author scott.Cgi
020
* @since 2009-5-7
021
*/
022
public class SimpleJdbcDao extends SimpleJdbcDaoSupport {
023
024
/**
025
* 提供对表的更改和删除操作
026
* @param sql 要执行的sql语句
027
* @param args 变参
028
* @return 影响的行数
029
*/
030
public int update(String sql,Object...args){
031
return this.getSimpleJdbcTemplate().update(sql, args);
032
}
033
034
/**
035
* 批量更新多条记录
036
* @param sql 多条sql组成的数组(不带参数的)
037
* @see 带参数的见: <br>
038
* getJdbcTemplate().batchUpdate(String[] sql,BatchPreparedStatementSetter pss)
039
* @return 影响行数数组
040
*/
041
public int[] batchUpdate(String[] sql){
042
return this.getJdbcTemplate().batchUpdate(sql);
043
}
044
045
/**
046
* 获取行数
047
* @param countSql 计算行数的sql语句
048
* @return
049
*/
050
public long countRows(String countSql){
051
return this.getJdbcTemplate().queryForLong(countSql);
052
}
053
054
/**
055
* 获取本地的Connection对象
056
* @return
057
*/
058
public Connection getNativeConn(){
059
060
//从当前线程绑定的数据连接获取连接
061
Connection conn = DataSourceUtils.getConnection(this.getJdbcTemplate().getDataSource());
062
try {
063
conn = this.getJdbcTemplate().getNativeJdbcExtractor().getNativeConnection(conn);
064
} catch (SQLException e) {
065
e.printStackTrace();
066
return null;
067
}
068
069
return conn;
070
}
071
072
/**
073
* 获得断开数据库连接的行集,大结果集会消耗内存,受到maxSize的限制
074
* @param sql 要执行的sql语句带?占位符
075
* @param params 填充占位符的数组
076
* @param types 填充参数类型(java.sql.Types中的常量)
077
* 例如:new int[]{Types.VARCHAR,Types.DATE}
078
* @return 影响的行数<br>
079
* <b>注:</b> params和types同时为空,sql为不带?占位符;仅仅types为空时,由spring去猜测类型
080
*/
081
public SqlRowSet queryForRowSet(String sql,Object[] params,int[] types){
082
083
if(params != null && types != null){
084
return this.getJdbcTemplate().queryForRowSet(sql, params, types);
085
}else if(params != null && types == null){
086
return this.getJdbcTemplate().queryForRowSet(sql, params);
087
}else {
088
return this.getJdbcTemplate().queryForRowSet(sql);
089
}
090
}
091
092
/**
093
* 提供对表的更改和删除操作
094
* @param hql 使用了命名参数的sql语句
095
* @param sps 例如:<br>
096
* new BeanPropertySqlParamterSource(javaBean其属性要和命名参数对应);<br>
097
* new MapSqlParameterSource().add("命名参数",参数对应的值).add()...可以链式调用
098
* @return KeyHolder主键持有者对象;如果是新增数据,KeyHolder持有新增的主键值<br>
099
* 有3个方法可调用:<br>getKey()一个数字主键<br>
100
* getKeys()复合主键Map结构<br>
101
* getKeyList()多个主键由多个Map组成的List
102
*/
103
public KeyHolder updateNamedParamer(String hql,SqlParameterSource sps){
104
KeyHolder keyHolder = new GeneratedKeyHolder();
105
this.getSimpleJdbcTemplate().getNamedParameterJdbcOperations().update(hql, sps, keyHolder);
106
return keyHolder;
107
}
108
109
/**
110
* 执行sql语句,如创建表等
111
* @param sql
112
*/
113
public void executeSql(String sql){
114
this.getJdbcTemplate().execute(sql);
115
}
116
117
/**
118
* @return 获得spring的JdbcTemplate使用更多功能
119
*/
120
public JdbcTemplate getSpringJdbcTemplate(){
121
return this.getJdbcTemplate();
122
}
123
124
/**
125
* 引入jdk5.0语法的JdbcTemplate的简化版本
126
* @return 获得spring的SimpleJdbcTemplate使用更多功能
127
*/
128
public SimpleJdbcTemplate getSpringSimplaJdbcTemplate(){
129
return this.getSimpleJdbcTemplate();
130
}
131
}
Page.java
001
package com.tinylight.dao.support;
002
import java.io.Serializable;
003
import java.util.Collections;
004
import java.util.List;
005
/**
006
* 分页对象.包含当前页数据及分页信息如总记录数.
007
*
008
* @author scott.Cgi
009
* @since 2008-6-29
010
*/
011
public class Page<T> implements Serializable {
012
private static final long serialVersionUID = -5624189033006412710L;
013
private static long DEFAULT_PAGE_SIZE = 20;
014
private long pageSize = DEFAULT_PAGE_SIZE; // 每页的记录数
015
private long start; // 当前页第一条数据在List中的位置,从0开始
016
private List<T> data = Collections.emptyList(); // 当前页中存放的记录
017
private long totalCount = 0; // 总记录数
018
/**
019
* 构造方法，只构造空页.
020
*/
021
public Page() {
022
this(0l, 0l, DEFAULT_PAGE_SIZE, Collections.<T>emptyList());
023
}
024
/**
025
* 默认构造方法.
026
*
027
* @param start 本页数据在数据库中的起始位置
028
* @param totalSize 数据库中总记录条数
029
* @param pageSize 本页容量
030
* @param data 本页包含的数据
031
*/
032
public Page(long start, long totalSize, long pageSize, List<T> data) {
033
this.pageSize = pageSize;
034
this.start = start;
035
this.totalCount = totalSize;
036
this.data = data;
037
}
038
/**
039
* 取总记录数.
040
*/
041
public long getTotalCount() {
042
return this.totalCount;
043
}
044
/**
045
* 取总页数.
046
*/
047
public long getTotalPageCount() {
048
if (totalCount % pageSize == 0)
049
return totalCount / pageSize;
050
else
051
return totalCount / pageSize + 1;
052
}
053
/**
054
* 取每页数据容量.
055
*/
056
public Long getPageSize() {
057
return pageSize;
058
}
059
/**
060
* 取当前页中的记录.
061
*/
062
public List<T> getResult() {
063
return data;
064
}
065
/**
066
* 取该页当前页码,页码从1开始.
067
*/
068
public long getCurrentPageNo() {
069
return start / pageSize + 1;
070
}
071
/**
072
* 该页是否有下一页.
073
*/
074
public boolean hasNextPage() {
075
return this.getCurrentPageNo() < this.getTotalPageCount();
076
}
077
/**
078
* 该页是否有上一页.
079
*/
080
public boolean hasPreviousPage() {
081
return this.getCurrentPageNo() > 1;
082
}
083
/**
084
* 获取任一页第一条数据在数据集的位置，每页条数使用默认值.
085
*
086
*/
087
protected static long getStartOfPage(long pageNo) {
088
return getStartOfPage(pageNo, DEFAULT_PAGE_SIZE);
089
}
090
/**
091
* 获取任一页第一条数据在数据集的位置.
092
*
093
* @param pageNo 从1开始的页号
094
* @param pageSize 每页记录条数
095
* @return 该页第一条数据
096
*/
097
public static long getStartOfPage(long pageNo, long pageSize) {
098
return (pageNo - 1) * pageSize;
099
}
100
}
applicationContext-annotation.xml
01
<?xml version="1.0" encoding="UTF-8" ?>
02
<beans xmlns="http://www.springframework.org/schema/beans"
03
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
05
xmlns:context="http://www.springframework.org/schema/context"
06
xmlns:aop="http://www.springframework.org/schema/aop"
07
xsi:schemaLocation="http://www.springframework.org/schema/beans
08
09
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
10
11
http://www.springframework.org/schema/context
12
13
http://www.springframework.org/schema/context/spring-context-2.5.xsd
14
15
http://www.directwebremoting.org/schema/spring-dwr
16
17
http://www.directwebremoting.org/schema/spring-dwr-2.0.xsd
18
19
http://www.springframework.org/schema/aop
20
21
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
22
23
<context:annotation-config/>
24
</beans>
applicationContext-list.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
03
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
04
xmlns:context="http://www.springframework.org/schema/context"
05
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
06
<description>导入applicationContext文件列表,可随时通过注释disable不需要的模块</description>
07
<!-- 导入spring aop配置文件 -->
08
<import resource="applicationContext-tx.xml" />
09
<!-- 导入spring dao配置文件 -->
10
<import resource="tinylight-dao.xml" />
11
12
</beans>
applicationContext-tx.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<!-- 使用aop/tx命名空间 -->
03
<beans xmlns="http://www.springframework.org/schema/beans"
04
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
05
xmlns:aop="http://www.springframework.org/schema/aop"
06
xmlns:tx="http://www.springframework.org/schema/tx"
07
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
08
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
09
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
10
<!-- 配置事务管理器bean,使用HibernateTransactionManager事务管理器 -->
11
<bean id="txManager"
12
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
13
<!-- 为事务管理器注入sessionFactory" -->
14
<property name="sessionFactory">
15
<ref bean="sessionFactory" />
16
</property>
17
</bean>
18
<!-- 通过aop定义事务增强切面 -->
19
<aop:config>
20
<!-- 使用强大的切点表达式语言轻松定义目标方法 -->
21
<aop:pointcut id="serviceMethod"
22
expression="execution(* com.tinylight.dao.base.IBaseDao.*(..))" />
23
<!-- 引用事务增强 -->
24
<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
25
</aop:config>
26
<!-- 事务增强 -->
27
<tx:advice id="txAdvice" transaction-manager="txManager">
28
<!-- 属性事务定义 -->
29
<tx:attributes>
30
<!--OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。
31
然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，
32
在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。
33
在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。
34
也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，
35
并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有 -->
36
<tx:method name="*" />
37
</tx:attributes>
38
</tx:advice>
39
40
</beans>
applicationContext.xml
001
<?xml version="1.0" encoding="UTF-8"?>
002
<beans xmlns="http://www.springframework.org/schema/beans"
003
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
004
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
005
<!-- 使用外部文件配置数据源的属性 -->
006
<bean
007
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
008
<property name="locations">
009
<list>
010
<!-- 外部文件地址 -->
011
<value>classpath:database_conn.properties</value>
012
</list>
013
</property>
014
<property name="fileEncoding" value="utf-8" />
015
</bean>
016
<!-- 配置数据源 -->
017
<bean id="dataSource"
018
class="com.mchange.v2.c3p0.ComboPooledDataSource"
019
destroy-method="close">
020
<property name="driverClass" value="${driverClassName}" />
021
<property name="jdbcUrl" value="${url}"/>
022
<property name="user" value="${username}"/>
023
<property name="password" value="${password}"/>
024
025
<!--连接池中保留的最小连接数。-->
026
<property name="minPoolSize" value="5" />
027
028
<!--连接池中保留的最大连接数。Default: 15 -->
029
<property name="maxPoolSize" value="20" />
030
031
<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
032
<property name="initialPoolSize" value="10" />
033
034
<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
035
<property name="maxIdleTime" value="60" />
036
037
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
038
<property name="acquireIncrement" value="5" />
039
040
<!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
041
属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
042
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
043
<property name="maxStatements" value="0"/>
044
<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
045
<property name="idleConnectionTestPeriod" value="60"/>
046
047
<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
048
<property name="acquireRetryAttempts" value="0" />
049
<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
050
保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
051
获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
052
<property name="breakAfterAcquireFailure" value="true" />
053
054
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
055
时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
056
等方法来提升连接测试的性能。Default: false -->
057
<property name="testConnectionOnCheckout" value="false" />
058
</bean>
059
<!-- hibernate3 sessionfactory配置
060
使用AnnotationSessionFactoryBean创建基于JPA注解的SessionFactory-->
061
<bean id="sessionFactory"
062
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
063
<!-- 引用数据源 -->
064
<property name="dataSource">
065
<ref bean="dataSource" />
066
</property>
067
<property name="namingStrategy">
068
<bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
069
</property>
070
<!-- hibernate的属性具体见hibernate文档 -->
071
<property name="hibernateProperties">
072
<props>
073
<prop key="hibernate.dialect">
074
org.hibernate.dialect.MySQLDialect
075
</prop>
076
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
077
<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
078
<!-- 非0值 指定jdbc抓取数量的大小调用Statement.setFetchSize() -->
079
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
080
<!-- jdbc批量更新 建议5到30 -->
081
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
082
<!--说明一下：如果不设置查询缓存，那么hibernate只会缓存使用load()方法获得的单个持久化对象
083
如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()
084
等方法获得的数据结果集的话就需要设置hibernate.cache.use_query_cache true 才行 -->
085
<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
086
<prop key="hibernate.cache.provider_class">
087
org.hibernate.cache.EhCacheProvider
088
</prop>
089
<prop key="hibernate.cache.provider_configuration_file_resource_path">
090
${hibernate.ehcache_config_file}
091
</prop>
092
</props>
093
</property>
094
095
<property name="packagesToScan" value="com.hibernate.entityclass" />
096
</bean>
097
098
<!-- 加载spring功能列表文件 -->
099
<import resource="applicationContext-list.xml"/>
100
</beans>
database_conn.properties
01
#jdbc settings
02
driverClassName=org.gjt.mm.mysql.Driver
03
url=jdbc\:mysql\://127.0.0.1\:3306/mytest
04
username=root
05
password=123456
06
#hibernate settings
07
hibernate.show_sql=true
08
hibernate.format_sql=true
09
hibernate.cache.use_query_cache=false
10
hibernate.jdbc.fetch_size=10
11
hibernate.jdbc.batch_size=5
12
hibernate.ehcache_config_file=ehcache.xml
ehcache.xml
01
<ehcache>
02
<!-- Sets the path to the directory where cache .data files are created.
03
04
If the path is a Java System Property it is replaced by
05
its value in the running VM.
06
07
The following properties are translated:
08
user.home - User's home directory
09
user.dir - User's current working directory
10
java.io.tmpdir - Default temp file path -->
11
<diskStore path="java.io.tmpdir" />
12
<!--Default Cache configuration. These will applied to caches programmatically created through
13
the CacheManager.
14
15
The following attributes are required:
16
17
maxElementsInMemory - Sets the maximum number of objects that will be created in memory
18
eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the
19
element is never expired.
20
overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
21
has reached the maxInMemory limit.
22
23
The following attributes are optional:
24
timeToIdleSeconds - Sets the time to idle for an element before it expires.
25
i.e. The maximum amount of time between accesses before an element expires
26
Is only used if the element is not eternal.
27
Optional attribute. A value of 0 means that an Element can idle for infinity.
28
The default value is 0.
29
timeToLiveSeconds - Sets the time to live for an element before it expires.
30
i.e. The maximum time between creation time and when an element expires.
31
Is only used if the element is not eternal.
32
Optional attribute. A value of 0 means that and Element can live for infinity.
33
The default value is 0.
34
diskPersistent - Whether the disk store persists between restarts of the Virtual Machine.
35
The default value is false.
36
diskExpiryThreadIntervalSeconds- The number of seconds between runs of the disk expiry thread. The default value
37
is 120 seconds.
38
-->
39
<cache name="org.hibernate.cache.StandardQueryCache"
40
maxElementsInMemory="50"
41
eternal="false"
42
timeToIdleSeconds="3600"
43
timeToLiveSeconds="7200"
44
overflowToDisk="true" />
45
<cache name="org.hibernate.cache.UpdateTimestampsCache"
46
maxElementsInMemory="5000"
47
eternal="true"
48
overflowToDisk="true" />
49
<!--
50
默认的Cache配置。用来实现CacheManager.add(String cacheName)创建的缓存
51
memoryStoreEvictionPolicy:内存存储与释放策略。有三个值：
52
LRU －least recently used
53
LFU －least frequently used
54
FIFO－first in first out, the oldest element by creation time
55
diskPersistent ：是否持久化磁盘缓存。
56
当这个属性的值为true时，系统在初始化的时候会在磁盘中查找文件名为cache名称
57
后缀名为index的的文件，如CACHE_FUNC.index
58
-->
59
<defaultCache maxElementsInMemory="10000"
60
eternal="false"
61
timeToIdleSeconds="120"
62
timeToLiveSeconds="120"
63
overflowToDisk="true"
64
diskPersistent="false"
65
diskExpiryThreadIntervalSeconds="120"
66
memoryStoreEvictionPolicy="LFU"
67
/>
68
<!-- See http://ehcache.sourceforge.net/documentation/#mozTocId258426 for how to configure caching for your objects -->
69
</ehcache>
log4j.properties
01
log4j.rootLogger=INFO, stdout, logfile
02
log4j.logger.org.springframework=WARN
03
log4j.logger.org.hibernate=WARN
04
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
05
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
06
log4j.appender.stdout.layout.ConversionPattern=[%d] %-5p \: %m%n
07
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
08
log4j.appender.logfile.File=${webAppRootKey}/superDao.log
09
log4j.appender.logfile.MaxFileSize=512KB
10
# Keep three backup files.
11
log4j.appender.logfile.MaxBackupIndex=3
12
# Pattern to output: date priority [category] - message
13
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
14
log4j.appender.logfile.layout.ConversionPattern=[%d] %p [%c] - %m%n
tinyLight-dao.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<beans xmlns="http://www.springframework.org/schema/beans"
03
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
05
<description>tinyLight Dao配置</description>
06
<!-- 定义JdbcTemplate Bean(线程安全,执行底层sql语句) -->
07
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
08
<!-- 设置数据源 -->
09
<property name="dataSource" ref="dataSource" />
10
<!-- 设置jdbcTemplate创建的statement查询数据时最大的超时时间,默认0 -->
11
<property name="queryTimeout" value="0" />
12
<!-- 设置底层ResultSet每次从数据库返回的行数,默认0,Oracle默认100 -->
13
<property name="fetchSize" value="0" />
14
<!-- 设置底层ResultSet从数据库返回的最大行数,默认0 -->
15
<property name="maxRows" value="0" />
16
<!-- 是否忽略sql警告信息,默认true,false JdbcTemplate将会抛出SQLWarningException -->
17
<property name="ignoreWarnings" value="true" />
18
<property name="nativeJdbcExtractor" ref="nativeJdbcExtractor" />
19
</bean>
20
<!-- 定义DBCP数据源的JDBC本地对象抽取器 -->
21
<bean id="nativeJdbcExtractor" lazy-init="true"
22
class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" />
23
<!-- 定义封装了jdbc操作数据的dao -->
24
<bean id="simpleJdbcDao" class="com.tinylight.dao.jdbc.SimpleJdbcDao">
25
<property name="jdbcTemplate" ref="jdbcTemplate" />
26
</bean>
27
<!-- 定义了与实体相关的dao -->
28
<bean id="genericEntityDao" class="com.tinylight.dao.hibernate.GenericEntityDao"
29
scope="prototype" lazy-init="true">
30
<property name="sessionFactory">
31
<ref bean="sessionFactory" />
32
</property>
33
</bean>
34
<!-- 定义了与实体无关的dao -->
35
<bean id="genericDao" class="com.tinylight.dao.hibernate.GenericDao">
36
<property name="sessionFactory">
37
<ref bean="sessionFactory" />
38
</property>
39
</bean>
40
<!--使用泛型DAO作为抽象基类-->
41
<bean id="baseDao" class="com.tinylight.dao.base.BaseDao"
42
abstract="true" depends-on="genericEntityDao,genericDao">
43
<property name="gedao">
44
<ref bean="genericEntityDao" />
45
</property>
46
<property name="gdao">
47
<ref bean="genericDao" />
48
</property>
49
<property name="sjdao">
50
<ref bean="simpleJdbcDao"/>
51
</property>
52
</bean>
53
<!--
54
当然这里也可以不必为每一个实体类的配置像下面这样的代码，
55
那就要在spring注解注入dao到service类的时候，加上下面这个方法：
56
/**
57
* spring bean的后处理器,如果子类是spring初始化的bean,则在初始化后设置注解dao的实体类类型
58
* @throws IllegalArgumentException
59
* @throws IllegalAccessException
60
*/
61
@PostConstruct
62
@SuppressWarnings("unchecked")
63
protected void preparedDao() throws IllegalArgumentException, IllegalAccessException{
64
Class<? extends BaseService> cl = this.getClass();
65
for(Field f : cl.getDeclaredFields()){
66
log.info("Service类注解属性名称 = {},类型 = {}",f.getName(),f.getGenericType());
67
if(f.isAnnotationPresent(Resource.class) && f.getAnnotation(Resource.class).name().equals("baseDao")){
68
f.setAccessible(true);//修改private修饰权限
69
Type[] params = ((ParameterizedType)f.getGenericType()).getActualTypeArguments();
70
log.info("实体类的参数类型 = {}",params[0].toString());
71
((IBaseDao<?,?>)f.get(this)).changeEntityClass((Class)params[0]);//设置实体类类型
72
f.setAccessible(false);//恢复private修饰权限
73
}
74
}
75
}
76
这样就可以为每一个实体类加下面这段xml配置了，当然dao是不在学要写一条代码啦
77
-->
78
79
<!-- 配置实体Demodata的DAO -->
80
<bean id="demoDao" parent="baseDao">
81
<constructor-arg>
82
<value>com.hibernate.entityclass.Daotest</value>
83
</constructor-arg>
84
</bean>
85
86
</beans>
这个svn有源代码，有兴趣可以看看.
http://xeducation.googlecode.com/svn/trunk
是myeclipse的工程
Share this on: Mixx Delicious Digg Facebook Twitter
DAOHibernateJDBCSpring
Related StoriesMost Popular
Linux系统信息查看命令大全
MySQL架构方案
Struts2 注解功能
Struts2 零配置方法总结
Spring与Memcache的集成
Apache Mina ProtocolCodecFilter Introduction
Leave a Reply
Name *
Email *
Website
Comment
有人回复时邮件通知我
首页
Google App Engine
Ralasafe
开发手册
Spring注解大全
OFC2
NoSQL实战
蚂蚁运动
Browsing: / Home / 2011 / 六月 / spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
Print Email Shortlink
spring2.5整合hibernate3.3的泛型Dao并加入spring jdbc的支持
BY ETHAN ON 2011 年 06 月 01 日 IN JAVA
原文链接：http://blog.csdn.net/tom_221x/archive/2009/08/22/4473873.aspx
以前写的一个改进版泛型dao,在这里 。基本实现了0代码编写dao。现在又加入了spring jdbc的支持，使得dao即可以用实体对象进行数据存取，有可以用jdbc的底层化操作删除，更新。结构见图：
具体代码和上图对应:
DaoTest.java
01
package com.test;
02
import javax.annotation.Resource;
03
import org.junit.Test;
04
import org.junit.runner.RunWith;
05
import org.springframework.test.context.ContextConfiguration;
06
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
07
import com.hibernate.entityclass.Daotest;
08
import com.tinylight.dao.base.IBaseDao;
09
@RunWith(SpringJUnit4ClassRunner.class)
10
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
11
public class DaoTest {
12
13
@Resource(name="demoDao")
14
private IBaseDao<Daotest,Integer> demoDao;
15
16
@Test
17
public void test(){
18
19
}
20
}
BaseDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.base;
005
import java.io.Serializable;
006
import java.util.Iterator;
007
import java.util.List;
008
import org.hibernate.Query;
009
import org.hibernate.SQLQuery;
010
import org.hibernate.Session;
011
import org.hibernate.StatelessSession;
012
import org.springframework.orm.hibernate3.HibernateTemplate;
013
import com.tinylight.dao.hibernate.GenericDao;
014
import com.tinylight.dao.hibernate.GenericEntityDao;
015
import com.tinylight.dao.jdbc.SimpleJdbcDao;
016
import com.tinylight.dao.support.Page;
017
/**
018
* @author scott.Cgi
019
* @since 2009-5-12
020
* 提供dao的所有操作<br>
021
* 实现类由spring注入:<br>
022
* {@link com.tinylight.dao.hibernate.GenericEntityDao}
023
* {@link com.tinylight.dao.hibernate.GenericDao}
024
* {@link com.tinylight.dao.jdbc.SimpleJdbcDao}
025
*/
026
public class BaseDao<T,PK extends Serializable> implements IBaseDao<T,PK>{
027
protected Class<T> entityClass;// DAO所管理的Entity类型.
028
private GenericEntityDao<T,PK> gedao;
029
private GenericDao gdao;
030
private SimpleJdbcDao sjdao;
031
032
public Class<T> getEntityClass() {return entityClass;}
033
public void setEntityClass(Class<T> entityClass) {this.entityClass = entityClass;}
034
035
public GenericEntityDao<T, PK> getGedao() {return gedao;}
036
public void setGedao(GenericEntityDao<T, PK> gedao) {this.gedao = gedao;}
037
038
public GenericDao getGdao() {return gdao;}
039
public void setGdao(GenericDao gdao) {this.gdao = gdao;}
040
041
public SimpleJdbcDao getSjdao() {return sjdao;}
042
public void setSjdao(SimpleJdbcDao sjdao) {this.sjdao = sjdao;}
043
/**
044
*让spring提供构造函数注入
045
*/
046
public BaseDao(Class<T> type) {
047
this.entityClass = type;
048
}
049
050
public BaseDao(){}
051
052
public void clear() {
053
gdao.clear();
054
}
055
056
public Query createQuery(String hql, Object... values) {
057
return gdao.createQuery(hql, values);
058
}
059
060
public void delete(T entityObject) {
061
gedao.delete(entityObject);
062
}
063
064
public void deleteById(PK id) {
065
gedao.deleteById(id);
066
}
067
068
public void evict(T entityObject) {
069
gedao.evict(entityObject);
070
}
071
072
public List<T> find(String hql, Object... values) {
073
return gdao.find(hql, values);
074
}
075
076
public List<T> findByNamedParams(String hql, String[] paramNames,
077
Object... values) {
078
return gdao.findByNamedParams(hql, paramNames, values);
079
}
080
081
public void flush() {
082
gdao.flush();
083
}
084
085
public List<T> getAll() {
086
return gedao.getAll();
087
}
088
089
public T getById(PK id) {
090
return gedao.getById(id);
091
}
092
093
public Session getNativeHibernateSession() {
094
return gdao.getNativeHibernateSession();
095
}
096
097
public StatelessSession getNativeStatelessHibernateSession() {
098
return gdao.getNativeStatelessHibernateSession();
099
}
100
101
public HibernateTemplate getSpringHibernateTemplate() {
102
return gdao.getSpringHibernateTemplate();
103
}
104
105
public Iterator<T> iterator(String hql, Object... values) {
106
return gdao.iterator(hql, values);
107
}
108
109
public SimpleJdbcDao jdbc() {
110
return sjdao;
111
}
112
113
public T load(PK id) {
114
return gedao.load(id);
115
}
116
117
public void load(T entityObject, PK id) {
118
gedao.load(entityObject, id);
119
}
120
121
public T merge(T entityObject) {
122
return gedao.merge(entityObject);
123
}
124
125
public SQLQuery nativeSqlQuery(String sql) {
126
return gdao.nativeSqlQuery(sql);
127
}
128
129
public Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize,
130
Object... values) {
131
return gdao.pagedQuery(countHql,hql, pageNo, pageSize, values);
132
}
133
134
public Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize,
135
Object... values) {
136
return gdao.pagedQueryByStartNo(countHql,hql, startNo, pageSize, values);
137
}
138
139
public void refresh(T entityObject) {
140
gedao.refresh(entityObject);
141
}
142
143
public void save(T entityObject) {
144
gedao.save(entityObject);
145
}
146
147
}
IBaseDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.base;
005
import java.io.Serializable;
006
import java.util.Iterator;
007
import java.util.List;
008
import org.hibernate.Query;
009
import org.hibernate.SQLQuery;
010
import org.hibernate.Session;
011
import org.hibernate.StatelessSession;
012
import org.springframework.orm.hibernate3.HibernateTemplate;
013
import com.tinylight.dao.jdbc.SimpleJdbcDao;
014
import com.tinylight.dao.support.Page;
015
/**
016
* @author scott.Cgi
017
* @since 2009-5-12
018
*
019
*/
020
public interface IBaseDao<T,PK extends Serializable> {
021
/**
022
* 根据主键类型的id获取实体对象,立即执行查询返回对象,数据库没有匹配则返回null
023
*/
024
public T getById(PK id);
025
026
/**
027
* 获取实体类型的全部对象
028
*/
029
public List<T> getAll();
030
031
/**
032
* 获取实体对象的代理,如果数据库没有匹配则异常,实体类有关联其它对象则延时加载
033
* @param id
034
* @return
035
*/
036
public T load(PK id);
037
038
/**
039
* 把数据加载到指定的非持久化实例上
040
* @param entityObject
041
* @param id
042
*/
043
public void load(T entityObject,PK id);
044
045
/**
046
* 删除对象.
047
*/
048
public void delete(T entityObject);
049
050
/**
051
* 根据id删除对象
052
* @param id
053
*/
054
public void deleteById(PK id);
055
056
/**
057
* 强迫装载对象和它的集合,使用了触发器的数据字段比较适合使用
058
* @param entityObject
059
*/
060
public void refresh(T entityObject);
061
062
/**
063
* 消除与 Hibernate Session 的关联
064
* @param entityObject
065
*/
066
public void evict(T entityObject);
067
068
/**
069
* 保存对象.<br>
070
* 如果对象已在本session中持久化了,不做任何事。<br>
071
* 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
072
* 如果没有持久化标识属性,调用save()。<br>
073
* 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
074
* 如果是附带版本信息的(version或timestamp)且版本属性表明为新的实例化对象就save()。<br>
075
* 否则调用update()重新关联托管对象
076
* @param entityObject
077
*/
078
public void save(T entityObject);
079
080
/**
081
* 如果对象已在本session中持久化了,覆盖原有的<br>
082
* 如果session中没有对应对象,从数据库加载<br>
083
* 如果是脱管对象,则什么都不做
084
* @param entityObject
085
* @return
086
*/
087
public T merge(T entityObject);
088
089
/**
090
* 根据hql查询,直接使用HibernateTemplate的find函数.
091
* @param <T>
092
* @param hql
093
* @param values
094
* @return
095
*/
096
public List<T> find(String hql, Object... values);
097
098
/**
099
* 根据命名参数查询
100
* @param <T>
101
* @param hql 带有命名参数的hql语句
102
* @param paramNames 命名参数的名字
103
* @param values 命名参数的值<br>
104
* <b>例如:</b><br>
105
* findByNamedParams("from Test where t1 = :t",new String[]{"t"},tValue);
106
* @return
107
*/
108
public List<T> findByNamedParams(String hql,String[] paramNames,Object...values);
109
110
/**
111
* 创建Query对象.<br>
112
* 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
113
* @param hql
114
* @param values
115
* @return
116
*/
117
public Query createQuery(String hql,Object... values);
118
119
/**
120
* 执行一些必须的sql语句把内存中的对象同步到数据库中
121
*/
122
public void flush();
123
124
/**
125
* 清除对象缓存
126
*/
127
public void clear();
128
129
/**
130
* 返回iterator接口类型的结果
131
* @param <T>
132
* @param hql
133
* @param values
134
* @return
135
*/
136
public Iterator<T> iterator(String hql,Object...values);
137
138
/**
139
* @return 当前上下文的原生Hibernate session对象,依然受到spring事务管理不需要手动close
140
*/
141
public Session getNativeHibernateSession();
142
143
/**
144
* @return 当前上下文的原生Hibernate StatelessSession对象<br>
145
* 此对象不级联关联实例,忽略集合不触发Hibernate事件模型和拦截器,没有一级缓存,没有持久化上下文,接近JDBC.
146
*/
147
public StatelessSession getNativeStatelessHibernateSession();
148
149
/**
150
* 执行本地查询获得SQLQuery对象<br>
151
* 可以调用addEntity(*.class).list();获得对应实体list集合<br>
152
* addEntity.add(*.class).addJoin(*.class).list();获得一对多代理对象<br>
153
* 更多用法见google
154
* @param sql
155
* @return
156
*/
157
public SQLQuery nativeSqlQuery(String sql);
158
159
/**
160
* @param <T>
161
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
162
* @param hql
163
* @param pageNo 页面号
164
* @param pageSize 页面容量
165
* @param values
166
* @return
167
*/
168
public Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize, Object... values);
169
170
/**
171
* @param <T>
172
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
173
* @param hql
174
* @param startNo 分页从哪一条数据开始
175
* @param pageSize 页面容量
176
* @param values
177
* @return
178
*/
179
public Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize, Object... values);
180
181
/**
182
* @return 获得spring的HibernateTemplate拥有更多的功能
183
*/
184
public HibernateTemplate getSpringHibernateTemplate();
185
186
/**
187
* @return 获得jdbc操作的超绚酷dao
188
*/
189
public SimpleJdbcDao jdbc();
190
}
GenericDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.hibernate;
005
import java.util.Iterator;
006
import java.util.List;
007
import org.hibernate.Query;
008
import org.hibernate.SQLQuery;
009
import org.hibernate.Session;
010
import org.hibernate.StatelessSession;
011
import org.springframework.orm.hibernate3.HibernateTemplate;
012
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
013
import com.tinylight.dao.support.Page;
014
/**
015
* 继承自spring的HibernateDaoSupport<br>
016
* 提供了和具体实体类无关的数据库操作
017
* @author scott.Cgi
018
* @since 2009-5-10
019
*
020
*/
021
public class GenericDao extends HibernateDaoSupport {
022
023
/**
024
* 根据hql查询,直接使用HibernateTemplate的find函数.
025
* @param <T>
026
* @param hql
027
* @param values
028
* @return
029
*/
030
@SuppressWarnings("unchecked")
031
public <T> List<T> find(String hql, Object... values) {
032
return this.getHibernateTemplate().find(hql, values);
033
}
034
035
/**
036
* 根据命名参数查询
037
* @param <T>
038
* @param hql 带有命名参数的hql语句
039
* @param paramNames 命名参数的名字
040
* @param values 命名参数的值<br>
041
* <b>例如:</b><br>
042
* findByNamedParams("from Test where t1 = :t",new String[]{"t"},tValue);
043
* @return
044
*/
045
@SuppressWarnings("unchecked")
046
public <T> List<T> findByNamedParams(String hql,String[] paramNames,Object...values){
047
return this.getHibernateTemplate().findByNamedParam(hql, paramNames, values);
048
}
049
050
/**
051
* 创建Query对象.<br>
052
* 对于需要first,max,fetchsize,cache,cacheRegion等诸多设置的函数,可以在返回Query后自行设置.
053
* @param hql
054
* @param values
055
* @return
056
*/
057
public Query createQuery(String hql,Object... values) {
058
//这里的false表示不创建session保证,当前操作在spring同一个事务的管理下
059
Query query = this.getSession(false).createQuery(hql);
060
if (values != null) {
061
for (int i = 0; i < values.length; i++) {
062
query.setParameter(i, values[i]);
063
}
064
}
065
return query;
066
}
067
068
/**
069
* 执行一些必须的sql语句把内存中的对象同步到数据库中
070
*/
071
public void flush() {
072
this.getHibernateTemplate().flush();
073
}
074
075
/**
076
* 清除对象缓存
077
*/
078
public void clear() {
079
this.getHibernateTemplate().clear();
080
}
081
082
/**
083
* 返回iterator接口类型的结果
084
* @param <T>
085
* @param hql
086
* @param values
087
* @return
088
*/
089
@SuppressWarnings("unchecked")
090
public <T> Iterator<T> iterator(String hql,Object...values){
091
return this.getHibernateTemplate().iterate(hql, values);
092
}
093
094
/**
095
* @return 当前上下文的原生Hibernate session对象,依然受到spring事务管理不需要手动close
096
*/
097
public Session getNativeHibernateSession(){
098
return this.getSessionFactory().getCurrentSession();
099
}
100
101
/**
102
* @return 当前上下文的原生Hibernate StatelessSession对象<br>
103
* 此对象不级联关联实例,忽略集合不触发Hibernate事件模型和拦截器,没有一级缓存,没有持久化上下文,接近JDBC.
104
*/
105
public StatelessSession getNativeStatelessHibernateSession(){
106
return this.getSessionFactory().openStatelessSession();
107
}
108
109
/**
110
* 执行本地查询获得SQLQuery对象<br>
111
* 可以调用addEntity(*.class).list();获得对应实体list集合<br>
112
* addEntity.add(*.class).addJoin(*.class).list();获得一对多代理对象<br>
113
* 更多用法见google
114
* @param sql
115
* @return
116
*/
117
public SQLQuery nativeSqlQuery(String sql){
118
return this.getSession(false).createSQLQuery(sql);
119
}
120
121
/**
122
* @param <T>
123
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
124
* @param hql
125
* @param pageNo 页面号
126
* @param pageSize 页面容量
127
* @param values
128
* @return
129
*/
130
@SuppressWarnings("unchecked")
131
public <T> Page<T> pagedQuery(String countHql,String hql, int pageNo, int pageSize, Object... values) {
132
// Count查询
133
List<T> countlist = this.getHibernateTemplate().find(countHql, values);
134
long totalCount = (Long) countlist.get(0);
135
if (totalCount < 1)
136
return new Page<T>();
137
// 当前页的开始数据索引
138
long startIndex = Page.getStartOfPage(pageNo, pageSize);
139
Query query = this.createQuery(hql, values);
140
List<T> list = query.setFirstResult((int) startIndex).setMaxResults(pageSize).list();
141
return new Page<T>(startIndex, totalCount, pageSize, list);
142
}
143
144
/**
145
* @param <T>
146
* @param countHql 计算数据总条数的hql语句(就是带count(*)的hql)
147
* @param hql
148
* @param startNo 分页从哪一条数据开始
149
* @param pageSize 页面容量
150
* @param values
151
* @return
152
*/
153
@SuppressWarnings("unchecked")
154
public <T> Page<T> pagedQueryByStartNo(String countHql,String hql, int startNo, int pageSize, Object... values){
155
// Count查询
156
List<T> countlist = getHibernateTemplate().find(countHql, values);
157
long totalCount = (Long) countlist.get(0);
158
if (totalCount < 1)
159
return new Page();
160
161
int startIndex = startNo;
162
Query query = createQuery(hql, values);
163
List<T> list = query.setFirstResult(startIndex).setMaxResults(pageSize).list();
164
return new Page<T>(startIndex, totalCount, pageSize, list);
165
}
166
167
/**
168
* @return 获得spring的HibernateTemplate拥有更多的功能
169
*/
170
public HibernateTemplate getSpringHibernateTemplate(){
171
return this.getHibernateTemplate();
172
}
173
}
GenericEntityDao.java
view sourceprint?
001
/**
002
*
003
*/
004
package com.tinylight.dao.hibernate;
005
import java.io.Serializable;
006
import java.util.List;
007
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
008
/**
009
* 负责为单个Entity对象提供CRUD操作的Hibernate DAO基类.<br>
010
* 子类只要在类定义时指定所管理Entity的Class<br>
011
* 即拥有对单个Entity对象的CRUD操作.
012
* @author scott.Cgi
013
* @since 2009-5-11
014
*
015
*/
016
public class GenericEntityDao<T,PK extends Serializable> extends HibernateDaoSupport {
017
018
protected Class<T> entityClass;// DAO所管理的Entity类型.
019
public void setEntityClass(Class<T> type){//注入实体类型
020
this.entityClass=type;
021
}
022
public Class<T> getEntityClass(){
023
return this.entityClass;
024
}
025
026
public GenericEntityDao(){}
027
public GenericEntityDao(Class<T> entityClass){this.entityClass = entityClass;}
028
/**
029
* 根据主键类型的id获取实体对象,立即执行查询返回对象,数据库没有匹配则返回null
030
*/
031
@SuppressWarnings("unchecked")
032
public T getById(PK id) {
033
return (T)this.getHibernateTemplate().get(this.entityClass, id);
034
}
035
036
/**
037
* 获取实体类型的全部对象
038
*/
039
@SuppressWarnings("unchecked")
040
public List<T> getAll() {
041
return (List<T>)(this.getHibernateTemplate().loadAll(this.entityClass));
042
}
043
044
/**
045
* 获取实体对象的代理,如果数据库没有匹配则异常,实体类有关联其它对象则延时加载
046
* @param id
047
* @return
048
*/
049
@SuppressWarnings("unchecked")
050
public T load(PK id){
051
return (T)this.getHibernateTemplate().load(this.entityClass, id);
052
}
053
054
/**
055
* 把数据加载到指定的非持久化实例上
056
* @param entityObject
057
* @param id
058
*/
059
public void load(T entityObject,PK id){
060
this.getHibernateTemplate().load(entityObject, id);
061
}
062
063
/**
064
* 删除对象.
065
*/
066
public void delete(T entityObject) {
067
this.getHibernateTemplate().delete(entityObject);
068
}
069
070
/**
071
* 根据id删除对象
072
* @param id
073
*/
074
public void deleteById(PK id){
075
this.delete(this.getById(id));
076
}
077
078
/**
079
* 强迫装载对象和它的集合,使用了触发器的数据字段比较适合使用
080
* @param entityObject
081
*/
082
public void refresh(T entityObject){
083
this.getHibernateTemplate().refresh(entityObject);
084
}
085
086
/**
087
* 消除与 Hibernate Session 的关联
088
* @param entityObject
089
*/
090
public void evict(T entityObject){
091
this.getHibernateTemplate().evict(entityObject);
092
}
093
094
/**
095
* 保存对象.<br>
096
* 如果对象已在本session中持久化了,不做任何事。<br>
097
* 如果另一个seesion拥有相同的持久化标识,抛出异常。<br>
098
* 如果没有持久化标识属性,调用save()。<br>
099
* 如果持久化标识表明是一个新的实例化对象,调用save()。<br>
100
* 如果是附带版本信息的(version或timestamp)且版本属性表明为新的实例化对象就save()。<br>
101
* 否则调用update()重新关联托管对象
102
* @param entityObject
103
*/
104
public void save(T entityObject){
105
this.getHibernateTemplate().saveOrUpdate(entityObject);
106
}
107
108
/**
109
* 如果对象已在本session中持久化了,覆盖原有的<br>
110
* 如果session中没有对应对象,从数据库加载<br>
111
* 如果是脱管对象,则什么都不做
112
* @param entityObject
113
* @return
114
*/
115
@SuppressWarnings("unchecked")
116
public T merge(T entityObject){
117
return (T)this.getHibernateTemplate().merge(entityObject);
118
}
119
120
}
SimpleJdbcDao.java
001
/**
002
*
003
*/
004
package com.tinylight.dao.jdbc;
005
import java.sql.Connection;
006
import java.sql.SQLException;
007
import org.springframework.jdbc.core.JdbcTemplate;
008
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
009
import org.springframework.jdbc.core.simple.SimpleJdbcDaoSupport;
010
import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
011
import org.springframework.jdbc.datasource.DataSourceUtils;
012
import org.springframework.jdbc.support.GeneratedKeyHolder;
013
import org.springframework.jdbc.support.KeyHolder;
014
import org.springframework.jdbc.support.rowset.SqlRowSet;
015
/**
016
* 继承spring的SimpleJdbcDaoSupport
017
* 提供对数据库jdbc级别的操作
018
* 内部使用spring的SimpleJdbcTemplate与JdbcTemplate
019
* @author scott.Cgi
020
* @since 2009-5-7
021
*/
022
public class SimpleJdbcDao extends SimpleJdbcDaoSupport {
023
024
/**
025
* 提供对表的更改和删除操作
026
* @param sql 要执行的sql语句
027
* @param args 变参
028
* @return 影响的行数
029
*/
030
public int update(String sql,Object...args){
031
return this.getSimpleJdbcTemplate().update(sql, args);
032
}
033
034
/**
035
* 批量更新多条记录
036
* @param sql 多条sql组成的数组(不带参数的)
037
* @see 带参数的见: <br>
038
* getJdbcTemplate().batchUpdate(String[] sql,BatchPreparedStatementSetter pss)
039
* @return 影响行数数组
040
*/
041
public int[] batchUpdate(String[] sql){
042
return this.getJdbcTemplate().batchUpdate(sql);
043
}
044
045
/**
046
* 获取行数
047
* @param countSql 计算行数的sql语句
048
* @return
049
*/
050
public long countRows(String countSql){
051
return this.getJdbcTemplate().queryForLong(countSql);
052
}
053
054
/**
055
* 获取本地的Connection对象
056
* @return
057
*/
058
public Connection getNativeConn(){
059
060
//从当前线程绑定的数据连接获取连接
061
Connection conn = DataSourceUtils.getConnection(this.getJdbcTemplate().getDataSource());
062
try {
063
conn = this.getJdbcTemplate().getNativeJdbcExtractor().getNativeConnection(conn);
064
} catch (SQLException e) {
065
e.printStackTrace();
066
return null;
067
}
068
069
return conn;
070
}
071
072
/**
073
* 获得断开数据库连接的行集,大结果集会消耗内存,受到maxSize的限制
074
* @param sql 要执行的sql语句带?占位符
075
* @param params 填充占位符的数组
076
* @param types 填充参数类型(java.sql.Types中的常量)
077
* 例如:new int[]{Types.VARCHAR,Types.DATE}
078
* @return 影响的行数<br>
079
* <b>注:</b> params和types同时为空,sql为不带?占位符;仅仅types为空时,由spring去猜测类型
080
*/
081
public SqlRowSet queryForRowSet(String sql,Object[] params,int[] types){
082
083
if(params != null && types != null){
084
return this.getJdbcTemplate().queryForRowSet(sql, params, types);
085
}else if(params != null && types == null){
086
return this.getJdbcTemplate().queryForRowSet(sql, params);
087
}else {
088
return this.getJdbcTemplate().queryForRowSet(sql);
089
}
090
}
091
092
/**
093
* 提供对表的更改和删除操作
094
* @param hql 使用了命名参数的sql语句
095
* @param sps 例如:<br>
096
* new BeanPropertySqlParamterSource(javaBean其属性要和命名参数对应);<br>
097
* new MapSqlParameterSource().add("命名参数",参数对应的值).add()...可以链式调用
098
* @return KeyHolder主键持有者对象;如果是新增数据,KeyHolder持有新增的主键值<br>
099
* 有3个方法可调用:<br>getKey()一个数字主键<br>
100
* getKeys()复合主键Map结构<br>
101
* getKeyList()多个主键由多个Map组成的List
102
*/
103
public KeyHolder updateNamedParamer(String hql,SqlParameterSource sps){
104
KeyHolder keyHolder = new GeneratedKeyHolder();
105
this.getSimpleJdbcTemplate().getNamedParameterJdbcOperations().update(hql, sps, keyHolder);
106
return keyHolder;
107
}
108
109
/**
110
* 执行sql语句,如创建表等
111
* @param sql
112
*/
113
public void executeSql(String sql){
114
this.getJdbcTemplate().execute(sql);
115
}
116
117
/**
118
* @return 获得spring的JdbcTemplate使用更多功能
119
*/
120
public JdbcTemplate getSpringJdbcTemplate(){
121
return this.getJdbcTemplate();
122
}
123
124
/**
125
* 引入jdk5.0语法的JdbcTemplate的简化版本
126
* @return 获得spring的SimpleJdbcTemplate使用更多功能
127
*/
128
public SimpleJdbcTemplate getSpringSimplaJdbcTemplate(){
129
return this.getSimpleJdbcTemplate();
130
}
131
}
Page.java
001
package com.tinylight.dao.support;
002
import java.io.Serializable;
003
import java.util.Collections;
004
import java.util.List;
005
/**
006
* 分页对象.包含当前页数据及分页信息如总记录数.
007
*
008
* @author scott.Cgi
009
* @since 2008-6-29
010
*/
011
public class Page<T> implements Serializable {
012
private static final long serialVersionUID = -5624189033006412710L;
013
private static long DEFAULT_PAGE_SIZE = 20;
014
private long pageSize = DEFAULT_PAGE_SIZE; // 每页的记录数
015
private long start; // 当前页第一条数据在List中的位置,从0开始
016
private List<T> data = Collections.emptyList(); // 当前页中存放的记录
017
private long totalCount = 0; // 总记录数
018
/**
019
* 构造方法，只构造空页.
020
*/
021
public Page() {
022
this(0l, 0l, DEFAULT_PAGE_SIZE, Collections.<T>emptyList());
023
}
024
/**
025
* 默认构造方法.
026
*
027
* @param start 本页数据在数据库中的起始位置
028
* @param totalSize 数据库中总记录条数
029
* @param pageSize 本页容量
030
* @param data 本页包含的数据
031
*/
032
public Page(long start, long totalSize, long pageSize, List<T> data) {
033
this.pageSize = pageSize;
034
this.start = start;
035
this.totalCount = totalSize;
036
this.data = data;
037
}
038
/**
039
* 取总记录数.
040
*/
041
public long getTotalCount() {
042
return this.totalCount;
043
}
044
/**
045
* 取总页数.
046
*/
047
public long getTotalPageCount() {
048
if (totalCount % pageSize == 0)
049
return totalCount / pageSize;
050
else
051
return totalCount / pageSize + 1;
052
}
053
/**
054
* 取每页数据容量.
055
*/
056
public Long getPageSize() {
057
return pageSize;
058
}
059
/**
060
* 取当前页中的记录.
061
*/
062
public List<T> getResult() {
063
return data;
064
}
065
/**
066
* 取该页当前页码,页码从1开始.
067
*/
068
public long getCurrentPageNo() {
069
return start / pageSize + 1;
070
}
071
/**
072
* 该页是否有下一页.
073
*/
074
public boolean hasNextPage() {
075
return this.getCurrentPageNo() < this.getTotalPageCount();
076
}
077
/**
078
* 该页是否有上一页.
079
*/
080
public boolean hasPreviousPage() {
081
return this.getCurrentPageNo() > 1;
082
}
083
/**
084
* 获取任一页第一条数据在数据集的位置，每页条数使用默认值.
085
*
086
*/
087
protected static long getStartOfPage(long pageNo) {
088
return getStartOfPage(pageNo, DEFAULT_PAGE_SIZE);
089
}
090
/**
091
* 获取任一页第一条数据在数据集的位置.
092
*
093
* @param pageNo 从1开始的页号
094
* @param pageSize 每页记录条数
095
* @return 该页第一条数据
096
*/
097
public static long getStartOfPage(long pageNo, long pageSize) {
098
return (pageNo - 1) * pageSize;
099
}
100
}
applicationContext-annotation.xml
01
<?xml version="1.0" encoding="UTF-8" ?>
02
<beans xmlns="http://www.springframework.org/schema/beans"
03
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
05
xmlns:context="http://www.springframework.org/schema/context"
06
xmlns:aop="http://www.springframework.org/schema/aop"
07
xsi:schemaLocation="http://www.springframework.org/schema/beans
08
09
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
10
11
http://www.springframework.org/schema/context
12
13
http://www.springframework.org/schema/context/spring-context-2.5.xsd
14
15
http://www.directwebremoting.org/schema/spring-dwr
16
17
http://www.directwebremoting.org/schema/spring-dwr-2.0.xsd
18
19
http://www.springframework.org/schema/aop
20
21
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
22
23
<context:annotation-config/>
24
</beans>
applicationContext-list.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
03
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
04
xmlns:context="http://www.springframework.org/schema/context"
05
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
06
<description>导入applicationContext文件列表,可随时通过注释disable不需要的模块</description>
07
<!-- 导入spring aop配置文件 -->
08
<import resource="applicationContext-tx.xml" />
09
<!-- 导入spring dao配置文件 -->
10
<import resource="tinylight-dao.xml" />
11
12
</beans>
applicationContext-tx.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<!-- 使用aop/tx命名空间 -->
03
<beans xmlns="http://www.springframework.org/schema/beans"
04
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
05
xmlns:aop="http://www.springframework.org/schema/aop"
06
xmlns:tx="http://www.springframework.org/schema/tx"
07
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
08
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
09
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
10
<!-- 配置事务管理器bean,使用HibernateTransactionManager事务管理器 -->
11
<bean id="txManager"
12
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
13
<!-- 为事务管理器注入sessionFactory" -->
14
<property name="sessionFactory">
15
<ref bean="sessionFactory" />
16
</property>
17
</bean>
18
<!-- 通过aop定义事务增强切面 -->
19
<aop:config>
20
<!-- 使用强大的切点表达式语言轻松定义目标方法 -->
21
<aop:pointcut id="serviceMethod"
22
expression="execution(* com.tinylight.dao.base.IBaseDao.*(..))" />
23
<!-- 引用事务增强 -->
24
<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
25
</aop:config>
26
<!-- 事务增强 -->
27
<tx:advice id="txAdvice" transaction-manager="txManager">
28
<!-- 属性事务定义 -->
29
<tx:attributes>
30
<!--OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。
31
然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，
32
在请求过后再接除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。
33
在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。
34
也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，
35
并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有 -->
36
<tx:method name="*" />
37
</tx:attributes>
38
</tx:advice>
39
40
</beans>
applicationContext.xml
001
<?xml version="1.0" encoding="UTF-8"?>
002
<beans xmlns="http://www.springframework.org/schema/beans"
003
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
004
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
005
<!-- 使用外部文件配置数据源的属性 -->
006
<bean
007
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
008
<property name="locations">
009
<list>
010
<!-- 外部文件地址 -->
011
<value>classpath:database_conn.properties</value>
012
</list>
013
</property>
014
<property name="fileEncoding" value="utf-8" />
015
</bean>
016
<!-- 配置数据源 -->
017
<bean id="dataSource"
018
class="com.mchange.v2.c3p0.ComboPooledDataSource"
019
destroy-method="close">
020
<property name="driverClass" value="${driverClassName}" />
021
<property name="jdbcUrl" value="${url}"/>
022
<property name="user" value="${username}"/>
023
<property name="password" value="${password}"/>
024
025
<!--连接池中保留的最小连接数。-->
026
<property name="minPoolSize" value="5" />
027
028
<!--连接池中保留的最大连接数。Default: 15 -->
029
<property name="maxPoolSize" value="20" />
030
031
<!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
032
<property name="initialPoolSize" value="10" />
033
034
<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
035
<property name="maxIdleTime" value="60" />
036
037
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
038
<property name="acquireIncrement" value="5" />
039
040
<!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
041
属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
042
如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
043
<property name="maxStatements" value="0"/>
044
<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
045
<property name="idleConnectionTestPeriod" value="60"/>
046
047
<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
048
<property name="acquireRetryAttempts" value="0" />
049
<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
050
保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
051
获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
052
<property name="breakAfterAcquireFailure" value="true" />
053
054
<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
055
时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
056
等方法来提升连接测试的性能。Default: false -->
057
<property name="testConnectionOnCheckout" value="false" />
058
</bean>
059
<!-- hibernate3 sessionfactory配置
060
使用AnnotationSessionFactoryBean创建基于JPA注解的SessionFactory-->
061
<bean id="sessionFactory"
062
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
063
<!-- 引用数据源 -->
064
<property name="dataSource">
065
<ref bean="dataSource" />
066
</property>
067
<property name="namingStrategy">
068
<bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
069
</property>
070
<!-- hibernate的属性具体见hibernate文档 -->
071
<property name="hibernateProperties">
072
<props>
073
<prop key="hibernate.dialect">
074
org.hibernate.dialect.MySQLDialect
075
</prop>
076
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
077
<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
078
<!-- 非0值 指定jdbc抓取数量的大小调用Statement.setFetchSize() -->
079
<prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
080
<!-- jdbc批量更新 建议5到30 -->
081
<prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
082
<!--说明一下：如果不设置查询缓存，那么hibernate只会缓存使用load()方法获得的单个持久化对象
083
如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()
084
等方法获得的数据结果集的话就需要设置hibernate.cache.use_query_cache true 才行 -->
085
<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
086
<prop key="hibernate.cache.provider_class">
087
org.hibernate.cache.EhCacheProvider
088
</prop>
089
<prop key="hibernate.cache.provider_configuration_file_resource_path">
090
${hibernate.ehcache_config_file}
091
</prop>
092
</props>
093
</property>
094
095
<property name="packagesToScan" value="com.hibernate.entityclass" />
096
</bean>
097
098
<!-- 加载spring功能列表文件 -->
099
<import resource="applicationContext-list.xml"/>
100
</beans>
database_conn.properties
01
#jdbc settings
02
driverClassName=org.gjt.mm.mysql.Driver
03
url=jdbc\:mysql\://127.0.0.1\:3306/mytest
04
username=root
05
password=123456
06
#hibernate settings
07
hibernate.show_sql=true
08
hibernate.format_sql=true
09
hibernate.cache.use_query_cache=false
10
hibernate.jdbc.fetch_size=10
11
hibernate.jdbc.batch_size=5
12
hibernate.ehcache_config_file=ehcache.xml
ehcache.xml
01
<ehcache>
02
<!-- Sets the path to the directory where cache .data files are created.
03
04
If the path is a Java System Property it is replaced by
05
its value in the running VM.
06
07
The following properties are translated:
08
user.home - User's home directory
09
user.dir - User's current working directory
10
java.io.tmpdir - Default temp file path -->
11
<diskStore path="java.io.tmpdir" />
12
<!--Default Cache configuration. These will applied to caches programmatically created through
13
the CacheManager.
14
15
The following attributes are required:
16
17
maxElementsInMemory - Sets the maximum number of objects that will be created in memory
18
eternal - Sets whether elements are eternal. If eternal, timeouts are ignored and the
19
element is never expired.
20
overflowToDisk - Sets whether elements can overflow to disk when the in-memory cache
21
has reached the maxInMemory limit.
22
23
The following attributes are optional:
24
timeToIdleSeconds - Sets the time to idle for an element before it expires.
25
i.e. The maximum amount of time between accesses before an element expires
26
Is only used if the element is not eternal.
27
Optional attribute. A value of 0 means that an Element can idle for infinity.
28
The default value is 0.
29
timeToLiveSeconds - Sets the time to live for an element before it expires.
30
i.e. The maximum time between creation time and when an element expires.
31
Is only used if the element is not eternal.
32
Optional attribute. A value of 0 means that and Element can live for infinity.
33
The default value is 0.
34
diskPersistent - Whether the disk store persists between restarts of the Virtual Machine.
35
The default value is false.
36
diskExpiryThreadIntervalSeconds- The number of seconds between runs of the disk expiry thread. The default value
37
is 120 seconds.
38
-->
39
<cache name="org.hibernate.cache.StandardQueryCache"
40
maxElementsInMemory="50"
41
eternal="false"
42
timeToIdleSeconds="3600"
43
timeToLiveSeconds="7200"
44
overflowToDisk="true" />
45
<cache name="org.hibernate.cache.UpdateTimestampsCache"
46
maxElementsInMemory="5000"
47
eternal="true"
48
overflowToDisk="true" />
49
<!--
50
默认的Cache配置。用来实现CacheManager.add(String cacheName)创建的缓存
51
memoryStoreEvictionPolicy:内存存储与释放策略。有三个值：
52
LRU －least recently used
53
LFU －least frequently used
54
FIFO－first in first out, the oldest element by creation time
55
diskPersistent ：是否持久化磁盘缓存。
56
当这个属性的值为true时，系统在初始化的时候会在磁盘中查找文件名为cache名称
57
后缀名为index的的文件，如CACHE_FUNC.index
58
-->
59
<defaultCache maxElementsInMemory="10000"
60
eternal="false"
61
timeToIdleSeconds="120"
62
timeToLiveSeconds="120"
63
overflowToDisk="true"
64
diskPersistent="false"
65
diskExpiryThreadIntervalSeconds="120"
66
memoryStoreEvictionPolicy="LFU"
67
/>
68
<!-- See http://ehcache.sourceforge.net/documentation/#mozTocId258426 for how to configure caching for your objects -->
69
</ehcache>
log4j.properties
01
log4j.rootLogger=INFO, stdout, logfile
02
log4j.logger.org.springframework=WARN
03
log4j.logger.org.hibernate=WARN
04
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
05
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
06
log4j.appender.stdout.layout.ConversionPattern=[%d] %-5p \: %m%n
07
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
08
log4j.appender.logfile.File=${webAppRootKey}/superDao.log
09
log4j.appender.logfile.MaxFileSize=512KB
10
# Keep three backup files.
11
log4j.appender.logfile.MaxBackupIndex=3
12
# Pattern to output: date priority [category] - message
13
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
14
log4j.appender.logfile.layout.ConversionPattern=[%d] %p [%c] - %m%n
tinyLight-dao.xml
01
<?xml version="1.0" encoding="UTF-8"?>
02
<beans xmlns="http://www.springframework.org/schema/beans"
03
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
04
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
05
<description>tinyLight Dao配置</description>
06
<!-- 定义JdbcTemplate Bean(线程安全,执行底层sql语句) -->
07
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
08
<!-- 设置数据源 -->
09
<property name="dataSource" ref="dataSource" />
10
<!-- 设置jdbcTemplate创建的statement查询数据时最大的超时时间,默认0 -->
11
<property name="queryTimeout" value="0" />
12
<!-- 设置底层ResultSet每次从数据库返回的行数,默认0,Oracle默认100 -->
13
<property name="fetchSize" value="0" />
14
<!-- 设置底层ResultSet从数据库返回的最大行数,默认0 -->
15
<property name="maxRows" value="0" />
16
<!-- 是否忽略sql警告信息,默认true,false JdbcTemplate将会抛出SQLWarningException -->
17
<property name="ignoreWarnings" value="true" />
18
<property name="nativeJdbcExtractor" ref="nativeJdbcExtractor" />
19
</bean>
20
<!-- 定义DBCP数据源的JDBC本地对象抽取器 -->
21
<bean id="nativeJdbcExtractor" lazy-init="true"
22
class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" />
23
<!-- 定义封装了jdbc操作数据的dao -->
24
<bean id="simpleJdbcDao" class="com.tinylight.dao.jdbc.SimpleJdbcDao">
25
<property name="jdbcTemplate" ref="jdbcTemplate" />
26
</bean>
27
<!-- 定义了与实体相关的dao -->
28
<bean id="genericEntityDao" class="com.tinylight.dao.hibernate.GenericEntityDao"
29
scope="prototype" lazy-init="true">
30
<property name="sessionFactory">
31
<ref bean="sessionFactory" />
32
</property>
33
</bean>
34
<!-- 定义了与实体无关的dao -->
35
<bean id="genericDao" class="com.tinylight.dao.hibernate.GenericDao">
36
<property name="sessionFactory">
37
<ref bean="sessionFactory" />
38
</property>
39
</bean>
40
<!--使用泛型DAO作为抽象基类-->
41
<bean id="baseDao" class="com.tinylight.dao.base.BaseDao"
42
abstract="true" depends-on="genericEntityDao,genericDao">
43
<property name="gedao">
44
<ref bean="genericEntityDao" />
45
</property>
46
<property name="gdao">
47
<ref bean="genericDao" />
48
</property>
49
<property name="sjdao">
50
<ref bean="simpleJdbcDao"/>
51
</property>
52
</bean>
53
<!--
54
当然这里也可以不必为每一个实体类的配置像下面这样的代码，
55
那就要在spring注解注入dao到service类的时候，加上下面这个方法：
56
/**
57
* spring bean的后处理器,如果子类是spring初始化的bean,则在初始化后设置注解dao的实体类类型
58
* @throws IllegalArgumentException
59
* @throws IllegalAccessException
60
*/
61
@PostConstruct
62
@SuppressWarnings("unchecked")
63
protected void preparedDao() throws IllegalArgumentException, IllegalAccessException{
64
Class<? extends BaseService> cl = this.getClass();
65
for(Field f : cl.getDeclaredFields()){
66
log.info("Service类注解属性名称 = {},类型 = {}",f.getName(),f.getGenericType());
67
if(f.isAnnotationPresent(Resource.class) && f.getAnnotation(Resource.class).name().equals("baseDao")){
68
f.setAccessible(true);//修改private修饰权限
69
Type[] params = ((ParameterizedType)f.getGenericType()).getActualTypeArguments();
70
log.info("实体类的参数类型 = {}",params[0].toString());
71
((IBaseDao<?,?>)f.get(this)).changeEntityClass((Class)params[0]);//设置实体类类型
72
f.setAccessible(false);//恢复private修饰权限
73
}
74
}
75
}
76
这样就可以为每一个实体类加下面这段xml配置了，当然dao是不在学要写一条代码啦
77
-->
78
79
<!-- 配置实体Demodata的DAO -->
80
<bean id="demoDao" parent="baseDao">
81
<constructor-arg>
82
<value>com.hibernate.entityclass.Daotest</value>
83
</constructor-arg>
84
</bean>
85
86
</beans>
这个svn有源代码，有兴趣可以看看.
http://xeducation.googlecode.com/svn/trunk
是myeclipse的工程
Share this on: Mixx Delicious Digg Facebook Twitter
DAOHibernateJDBCSpring
Related StoriesMost Popular
Linux系统信息查看命令大全
MySQL架构方案
Struts2 注解功能
Struts2 零配置方法总结
Spring与Memcache的集成
Apache Mina ProtocolCodecFilter Introduction
Leave a Reply
Name *
Email *
Website
Comment
有人回复时邮件通知我