Spring-hibernate-BaseDao

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 
<!--1, 打开Spring的annotation -->
<context:annotation-config/>
<!-- 2, 设定Spring去那些包中找annotation -->
<context:component-scan base-package="com.yangw.spring" />

<!--
使用dbcp没有成功, 加的是commons-dbcp-1.4.jar
class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
-->
<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<context:property-placeholder location="jdbc.properties"/>

<!--创建sessionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >
<!-- class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" -->
<property name="dataSource" ref="dataSource"/>
<!--  基于XML配置文件的形式
<property name="mappingResources">
<list>
<value>product.hbm.xml</value>
</list>
</property>
-->
<!-- 自动去包中找hbm文件或者设置了annotation的类-->
<property name="packagesToScan" value="com.yangw.spring.model" />
<!-- 将hibernate配置文件放到单独的配置文件中的方式-->
<!--
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
-->
<property name="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update
hibernate.format_sql=false
</value>
</property>
</bean>

<!-- 配置Spring事务处理 -->
<!-- 1,创建事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 2, 配置AOP，Spring是通过AOP进行事务管理的-->
<aop:config>
<!-- 设置PointCut表示哪些方法要加入事务-->
<aop:pointcut id="allMethods"
expression="execution(* com.yangw.spring.dao.*.*(..))"/>
<!-- 通过advisor来确定具体加入事务控制的方法 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods"/>
</aop:config>
<!--3, 配置哪些方法要加入事务 -->

<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="get*" read-only="true" />
<tx:method name="count*" read-only="true" />
<tx:method name="is*" read-only="true" />
<tx:method name="has*" read-only="true" />
<!-- 所有方法都加入事务 -->
<tx:method name="*"  />
</tx:attributes>
</tx:advice>
</beans>

package com.yangw.spring.dao;

import java.util.List;
/**
* IBaseDao接口是所有Dao公共的操作
* @author Administrator
* @param <T>
*/
public interface IBaseDao<T> {

public void add(T t);

public void update(T t);

public void delete(int id);

public T load(int id);

public List<T> list(String hql,Object[] args);

}

package com.yangw.spring.dao;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
*
* 把所有公共方法都写到BaseDao，所有Dao都继承 BaseDao即可，这样就实现了大量的基础方法
* 如果Dao中有特殊的方法，再次具体的Dao中进行实现
* @author Administrator
*
* @param <T>
*/
public class BaseDao<T> extends HibernateDaoSupport implements IBaseDao<T> {

//注入SessionFactory
@Resource(name="sessionFactory")
public void setSuperSessionFactory(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}

private Class<T> entityClass;
/**
* 获取T对象的Class
* @return
*/
@SuppressWarnings({ "unused", "unchecked" })
private Class<T> getEntityClass(){
if(entityClass==null){
entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
return entityClass;

}

@Override
public void add(T t) {
super.getHibernateTemplate().save(t);
}

@Override
public void update(T t) {
super.getHibernateTemplate().update(t);
}

@Override
public void delete(int id) {
//先加载对象再删除
super.getHibernateTemplate().delete(this.load(id));
}

@Override
public T load(int id) {
return super.getHibernateTemplate().get(getEntityClass(), id);

}

/**
* 这个方法的弊端：
* 1， select * from User 这样的语句不行
* 2， 查询结果是Object[],需要自己额外处理
*/
@SuppressWarnings("unchecked")
@Override
public List<T> list(String hql, Object[] args) {

//select * 的处理，可以利用反射来做

Query query=this.getSession().createQuery(hql);
for(int i=0;i<args.length;i++){
query.setParameter(i, args[i]);
}
return listToBean(query.list(),hql);
//    return query.list();
}

/**
* 自己写代码，作映射
* @param list
* @param hql
* @return
*/
private  List<T> listToBean(List<Object[]> list,String hql){

//"select "占7个长度
String[] columns=hql.substring(7, hql.indexOf("from")).split("\\s*,\\s*");
List<T> resultList=new ArrayList<T>();

List<Field> fields=new ArrayList<Field>();
//测试发现：getDeclaredField(column)获取的是基本类型值
//测试发现：getField(column)获取的是非基本类型值
Field[] fieldsTemp=getEntityClass().getDeclaredFields(); //获取所有的列

//得到每次需要的列

for(int i=0;i<fieldsTemp.length;i++){
String temp=fieldsTemp[i].getName(); //属性名
boolean flag=false; //假设当前这个不是要或者的属性名
for(String column:columns){
if(column.equals(temp)){
flag=true;
break;
}
}
if(flag){
fields.add(fieldsTemp[i]);
}
}

try {
for(int i=0;i<list.size();i++){
Object[] objs=list.get(i);
T tclass=getEntityClass().newInstance();
for(int j=0;j<fields.size();j++){
fields.get(j).setAccessible(true);
fields.get(j).set(tclass,objs[j]);
}
resultList.add(tclass);
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}

return resultList;
}

}

package com.yangw.spring.dao;

import com.yangw.spring.model.User;

public interface IUserDao extends IBaseDao<User>{

//此时的IUserDao只需要写特殊的一些方法，让子类去实现
//假设下面这个是IUserDao中的特殊方法
public void add(User user,int gid);
}

package com.yangw.spring.dao;

import org.springframework.stereotype.Repository;

import com.yangw.spring.model.User;

@Repository("userDao")
public class UserDao extends BaseDao<User> implements IUserDao {

@Override
public void add(User user, int gid) {

System.out.println("cccc");
}

}

package com.yangw.spring.test;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yangw.spring.dao.IUserDao;
import com.yangw.spring.model.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
/**
* 当使用了@RunWith,@ContextConfiguration注解之后，就可以直接在Test中进行依赖注入
* @author Administrator
*/
public class TestHibernate {

@Resource(name="userDao")
private IUserDao userDao;

@Test
public void testAdd(){

User user=new User();
user.setName("zhaoliu");
user.setAge(22);
userDao.add(user);
}

@Test
public void testLoad(){

User user = (User) userDao.load(4);
System.out.println(user);
}

@Test
public void testList(){

List<User> lists = userDao.list("select age, name from User where name=?", new  Object[]{"wangwu"});

for(int i=0;i<lists.size();i++){
System.out.println("-->"+lists.get(i).getAge());
}
}

}