Struts2.1.6+Spring2.5.6+Hibernate3.3.2+mysql整合+分页模板(2)

六、定义基本类

1）定义Action基本类-主要定义request，session等

 

BaseAction.java

package ssh.base;

import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.interceptor.ApplicationAware;
import org.apache.struts2.interceptor.RequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.interceptor.SessionAware;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

public class BaseAction extends ActionSupport implements RequestAware,SessionAware, ApplicationAware,ServletResponseAware{
	private static final long serialVersionUID = 4818541693118631758L;
	public Map<String, Object> request;	//一般少用，因为value stack里就是request
	public Map<String, Object> session;
	public Map<String, Object> application;//基本不用。可以放数据库或者放在一个CLASS里面
	public HttpServletResponse response;


//ServletActionContext.getRequest()同样也可以直接去的request

	public void setRequest(Map<String, Object> request) {
		this.request=request;
	}
	
	public void setSession(Map<String, Object> session) {
		this.session=session;
	}

	public void setApplication(Map<String, Object> application) {
		this.application=application;
	}

	public void setServletResponse(HttpServletResponse response) {
		this.response=response;
	}
}

  

 

2)定义接口DAO类，主要定义CURD，分页等基本相同的接口

 

DAO.java

package ssh.base;

import java.util.LinkedHashMap;
import ssh.utils.QueryResult;

public interface DAO {

	//保存数据
	public void save(Object entity);

	//更新数据
	public void update(Object entity);

	//删除单条记录
	public <T> void delete(Class<T> entityClass,Object entityId);	

	//删除多条记录
	public <T> void delete(Class<T> entityClass,Object[] entityIds);

	//查找指定ID的实体类数据
	public <T> T find(Class<T> entityClass,Object entityId);	//在方法上定义泛型需要在方法上写<X>,，第一个T是定义泛型，第2个T是返回类型
	
	/**
	 * 获得分页数据
	 * QueryResult<T> 泛型定义在类上。因为需要返回查询的数据List,和查询的总条数，所以需要自定义类型返回2个数据
	 * @param <T>	泛型
	 * @param entityClass 实体类
	 * @param firstIndex 开始索引
	 * @param maxResult 需要获取的记录数
	 * @param wherejpql where条件语句
	 * @param queryParams 条件语句参数
	 * @param orderby 排序,LinkedHashMap先进先出，使用这个是因为先进去的放到第一位，order by key1 desc,key2 asc	
	 * @return
	 */
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstIndex, int maxResult,	String wherejpql,Object[] queryParams,LinkedHashMap<String, String> orderby);
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstIndex, int maxResult,String wherejpql,Object[] queryParams);
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstIndex, int maxResult,LinkedHashMap<String, String> orderby);
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstIndex, int maxResult);
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass);
}

 

 

 3)定义实现DAO基本接口的DAOImpl的实现类，供其他实现类直接继承

    而且必须写@Component注入给Spring管理，然后注入hibernateTemplate,使用protected，其他类继承后可以直接使用

 

DaoSupport.java

package ssh.base;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.LinkedHashMap;
import java.util.List;
import javax.annotation.Resource;
import javax.persistence.Entity;
import ssh.utils.QueryResult;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;

//定义抽象类继承DAO，抽象出所有实体通用的方法，方便其他类继承就可以了,abstract定义了只能继承。
@Component	//放到Spring里，让Spring管理
public abstract class DaoSupport implements DAO {
	
	//注入hibernateTemplate,使用protected，其他类继承后可以直接使用
	public HibernateTemplate hibernateTemplate;
	
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}

	@Resource 		//注入hibernateTemplate
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}
	
	
	/**保存数据 
	 * 调用方法：save(new User("shazhuzhu",20)
	 */
	public void save(Object entity) {
		hibernateTemplate.save(entity);
	}
	
	
	/**更新数据 
	 * 调用方法：update(new User(1,"shazhuzhu",20); 其中1为ID
	 */
	public void update(Object entity) {
		hibernateTemplate.update(entity);	//把游离状态的实体BENA同步到数据库
	}
	
	
	/**删除单条记录
	 * 调用方法：delete(User.class,1); 其中1为ID
	 */
	public <T> void delete(Class<T> entityClass,Object entityid) {
		delete(entityClass, new Object[]{entityid});	//调用下面的方法
	
	}
	
	
	//删除多条记录
	public <T> void delete(Class<T> entityClass,Object[] entityids) {
		for(Object id:entityids){
			T t=find(entityClass,id);	////调用下面的find方法先把实体类查找出来，然后在DEL,这样才能通过ID删除数据
			if(t!=null)					//先判断需要删除的数据是否存在
			hibernateTemplate.delete(t);		
		}
	}
	
	
	/**查询指定ID的记录
	 * 调用方法：find(User.class,1); 其中1为ID
	 */
	@SuppressWarnings("unchecked")
	public <T> T find(Class<T> entityClass, Object entityId) {	
		return (T) hibernateTemplate.get(entityClass,(Serializable) entityId);
	}
	
	
	/**
	 * 获得分页数据
	 * QueryResult<T> 泛型定义在类上。因为需要返回查询的数据List,和查询的总条数，所以需要自定义类型返回2个数据
	 * @param <T>	泛型
	 * @param entityClass 实体类
	 * @param firstIndex 开始索引 firstIndex和maxResult都为-1时代表不分页
	 * @param maxResult 需要获取的记录数
	 * @param wherejpql where条件语句
	 * @param queryParams 条件语句参数
	 * @param orderby 排序,LinkedHashMap先进先出，使用这个是因为先进去的放到第一位，order by key1 desc,key2 asc	
	 * @return
	 * 
	 * 调用方法
	 * LinkedHashMap<String , String> orderby=new LinkedHashMap<String, String>();
	 * orderby.put("id", "asc");
	 * QueryResult<TestVo> qr=testDAO.getScrollData(TestVo.class, 1, 10,"o.name=? and o.title=?",new Object[]{"a","1"},orderby);
	 * for (TestVo q : qr.getResultlist()) {
	 * 		System.out.println(q.getName());
	 * }
	 * System.out.println(qr.getTotalrecord());
	 */
	@SuppressWarnings("unchecked")	//不检查类型，不然会有黄色线提示错误。
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult,
			String wherejpql,Object[] queryParams,LinkedHashMap<String, String> orderby) {
		
		QueryResult qr = new QueryResult<T>();	//定义保存数据类型
		String entityname = getEntityName(entityClass);	//获取实体类名称，方法下面定义了
		
		String hql="select o from "+entityname+" o " + (wherejpql==null? "" :"where " + wherejpql) + buildOrderby(orderby);
		System.out.println(hql);
		qr.setResultlist(getListForPage(hql, firstindex, maxresult, queryParams));	//调用hibernateTemplate的扩张方法进行分页处理
		
		String hql2="select count(o) from "+entityname+" o " + (wherejpql==null? "" :"where " + wherejpql);
		Long total=(Long) hibernateTemplate.find(hql2,queryParams).get(0);			//查询总记录数
		
		qr.setTotalrecord(total);
		return qr;
	}
	
	
	 /**
	 * HibernateTemplate 只支持 .setMaxResults(int) 方法。
     * 因此，做 Spring+Hibernate 分页处理要使用到一个接口 org.springframework.orm.hibernate3.HibernateCallback
	 * 来灵活操作数据库，该接口中有一个未实现的方法 Object doInHibernate (Session session)，用以获得并利用 session 进行操作(自动创建、销毁)。

     * 分页通用方法
     * @param sql           HQL查询语句
     * @param firstindex    起始记录下标
     * @param maxresult     读取记录数
     * @return              List 结果集
     */
    @SuppressWarnings("unchecked")
	public  List getListForPage(final String hql, final int firstindex, final int maxresult,final Object[] queryParams) {
        try {
            List list = hibernateTemplate.executeFind(new HibernateCallback() {
				
				@Override
				public Object doInHibernate(Session session) throws HibernateException,SQLException {  
					Query query =  session.createQuery(hql);
					
					if(firstindex!=-1 && maxresult!=-1){	//方便设置-1时不分页
						query.setFirstResult(firstindex);
						query.setMaxResults(maxresult);
					}
					setQueryParams(query, queryParams);		//调用下面方法插入where传递过来的参数
					return  query.list();
				}
			});
            return list;
        } catch (RuntimeException re) {
            throw re;
        }
    }
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult,LinkedHashMap<String, String> orderby) {
		return getScrollData(entityClass,firstindex,maxresult,null,null,orderby);
	}
	
	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult,String wherejpql,Object[] queryParams) {
		return getScrollData(entityClass,firstindex,maxresult,wherejpql,queryParams,null);
	}

	public <T> QueryResult<T> getScrollData(Class<T> entityClass,int firstindex, int maxresult) {
		return getScrollData(entityClass,firstindex,maxresult,null,null,null);
	}

	public <T> QueryResult<T> getScrollData(Class<T> entityClass) {
		return getScrollData(entityClass,-1,-1);	//主方法定义-1为不分页
	}



	/**
	 * 获取实体类的名称
	 * @param <T>
	 * @param entityClass
	 * @return
	 */
	protected <T> String getEntityName(Class<T> entityClass) {
		String entityname=entityClass.getSimpleName();			//如果实体类上面的@Entity(name=xxx)没有指定名称，直接为默认类名称
		Entity entity=entityClass.getAnnotation(Entity.class);	//获取@Entity注解
		if(entity.name()!=null&&!"".equals(entity.name())){		//判断注解的name是否为空
			entityname=entity.name();
		}
		return entityname;
	}
	
	
	/**
	 * 组装order by语句
	 * @param orderby
	 * @return  //	order by o.key desc,key2 asc
	 */
	protected String buildOrderby(LinkedHashMap<String, String> orderby){
		StringBuffer orderbyql=new StringBuffer("");
		if(orderby!=null && orderby.size()>0 ){
			orderbyql.append(" order by ");
			for(String key:orderby.keySet()){	//取得Map的Key的集合
				orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");	
			}
			orderbyql.deleteCharAt(orderbyql.length()-1);
		}
		return orderbyql.toString();
	}

	/**
	 * 为Where语句传递参数
	 * @param query
	 * @param queryParams
	 * o.key = ?1 and o.name=?2 这是错误的，JPA的问号索引是从1开始的，而HibernateTemplate是从0开始的，HibernateTemplate执行HQL语句时，HQL的语句中'?'号面是不带数字的
	 * o.key = ? and o.name=? 正确
	 */
	protected void setQueryParams(Query query,Object[] queryParams) {
		if(queryParams!=null && queryParams.length>0){
			for(int i=0;i<queryParams.length;i++){		//JPA的问号索引是从1开始的，而HibernateTemplate是从0开始的	
				query.setParameter(i, queryParams[i]);	//如果是JPA:i+1
			}
		}
	}
	
}

  

 

 

七、写实体类的接口-继承基本接口DAO

 

UserDAO.java

package ssh.DAO;

import ssh.base.DAO;

public interface UserDAO extends DAO {
	//因为继承了基本接口DAO，基本接口DAO已经定义了CURD和分页功能
}

 

 

 

八、写实体类的实现类-继承基本实现类DAOSupport，并继承UserDAO接口

 

UserDAOImpl.java

package ssh.DAOImpl;


import org.springframework.stereotype.Component;
import ssh.DAO.UserDAO;
import ssh.base.DaoSupport;

@Component
public class UserDAOImpl extends DaoSupport implements UserDAO {
//基本实现类DaoSupport已经实现基本的CURD和分页功能
}

 

 

九、定义Service的实现

    1)在类前加入@Component，让spring对其初始化

    2)用@Resource把userDAO注入进来

 

UserService.java

package ssh.service;

import java.util.LinkedHashMap;
import javax.annotation.Resource;
import ssh.utils.QueryResult;
import org.springframework.stereotype.Component;
import ssh.DAO.UserDAO;
import ssh.model.User;

@Component
public class UserService {
	private UserDAO userDAO;
	
	public UserDAO getUserDAO() {
		return userDAO;
	}

	@Resource
	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}

	public void save(User user){
		userDAO.save(user);		
	}
	
	public void update(User user){
		userDAO.update(user);
	}
	
	public void delete(int id){
		userDAO.delete(User.class,id);
	}
	
	public User find(int id){
		return userDAO.find(User.class, id);
	}
	
	/*
	 * 获取分页数据
	 */
	public QueryResult<User> getScrollData(int firstindex, int maxresult,String wherejpql,Object[] queryParams,LinkedHashMap<String, String> orderby) {
		
		QueryResult<User> qr=userDAO.getScrollData(User.class, firstindex, maxresult, wherejpql, queryParams, orderby);
		return qr;	
	}
}

 

 

（待续）