ssh底层方法抽取步骤-CSDN博客

本文链接：https://blog.csdn.net/Night_X/article/details/85219519

先上图，代码在下面
通用dao层的定义
通用dao层接口

通用dao层实现类

通用dao层的使用
继承通用dao层接口

继承通用dao层实现类，实现自己的接口

通用业务层定义
通用业务层接口

通用业务层实现类

通用业务层的使用
继承通用业务层接口

继承通用业务层实现类，实现自己的接口

通用控制层定义

继承通用控制层

下面是详细代码啦

文章目录

dao层
业务层
控制层
- 通用控制层定义
- 继承通用控制层

dao层

通用dao层定义

通用dao层接口

public interface BaseDao<T> {
	
	/**
	 * 	条件查询
	 * @author Zoe
	 * @date 2018年12月22日下午9:42:29
	 * @return
	 */
	List<T> getList(T t1,T t2,Object param);
	
	/**
	 * 	分页_条件查询
	 * @author Zoe
	 * @date 2018年12月22日下午9:42:21
	 * @param t1
	 * @param t2
	 * @param params
	 * @param firstResult
	 * @param maxResults
	 * @return
	 */
	List<T> getListByPage(T t1, T t2, Object params, int firstResult, int maxResults);
	
	/**
	 * 	获取分页_条件查询总记录数
	 * @author Zoe
	 * @date 2018年12月22日下午9:43:01
	 * @param t1
	 * @param t2
	 * @param params
	 * @return
	 */
	Long getCount(T t1, T t2, Object params);
	
	/**
	 * 	添加
	 * @author Zoe
	 * @date 2018年12月22日下午9:43:13
	 * @param t
	 */
	void add(T t);
	
	/**
	 * 	根据编号删除对象
	 * @author Zoe
	 * @date 2018年12月22日下午9:43:22
	 * @param uuid
	 */
	void delete(long uuid);
	
	/**
	 * 	根据编号查找对象
	 * @author Zoe
	 * @date 2018年12月22日下午9:43:43
	 * @param uuid
	 * @return
	 */
	T get(long uuid);
	
	/**
	 * 	更新
	 * @author Zoe
	 * @date 2018年12月22日下午9:43:53
	 * @param t
	 */
	void update(T t);
}

通用dao实现类

public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {

	private Class<T> entityClass;
	
	/**
	 * 	反射泛型
	 */
	public BaseDaoImpl() {
		// 通过子类获取该类, this表示调用该类的类，即该类的子类
		Type baseDaoImplClass = this.getClass().getGenericSuperclass();
		// 获取该类中的泛型
		ParameterizedType pType = (ParameterizedType) baseDaoImplClass; 
		// 获取本类的泛型数组
		Type[] types = pType.getActualTypeArguments();
		// 获取已知位置的泛型
		entityClass = (Class<T>) types[0];
	}

	/**
	 * @author Zoe
	 * @date 2018年12月22日下午9:46:42
	 * @return
	 */
	@Override
	public List<T> getList(T t1,T t2,Object param) {
		DetachedCriteria dc = getDetachedCriteria(t1,t2,param);
		return (List<T>) this.getHibernateTemplate().findByCriteria(dc);
	}
	
	/**
	 * @author Zoe
	 * @date 2018年12月22日下午9:45:36
	 * @param t1
	 * @param t2
	 * @param params
	 * @param firstResult
	 * @param maxResults
	 * @return
	 */
	@Override
	public List<T> getListByPage(T t1, T t2, Object param, int firstResult, int maxResults) {
		DetachedCriteria dc = getDetachedCriteria(t1,t2,param);
		return (List<T>) this.getHibernateTemplate().findByCriteria(dc,firstResult, maxResults);
	}
	/**
	 * @author Zoe
	 * @date 2018年12月21日下午9:00:25
	 * @param criteria
	 * @return
	 */
	@Override
	public Long getCount(T t1, T t2, Object param) {
		DetachedCriteria criteria = getDetachedCriteria(t1,t2,param);
		// 查询总记录数
		criteria.setProjection(Projections.rowCount());
		return (Long) getHibernateTemplate().findByCriteria(criteria).get(0);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月21日下午10:49:38
	 * @param t
	 */
	@Override
	public void add(T t) {
		getHibernateTemplate().save(t);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月22日下午3:59:55
	 * @param uuid
	 */
	@Override
	public void delete(long uuid) {
		// 将对象转换为持久态（可以自动更新数据库）
		T t2 = getHibernateTemplate().get(entityClass, uuid);
		getHibernateTemplate().delete(t2);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月22日下午7:36:02
	 * @param uuid
	 * @return
	 */
	@Override
	public T get(long uuid) {
		return getHibernateTemplate().get(entityClass, uuid);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月22日下午8:06:36
	 * @param t
	 */
	@Override
	public void update(T t) {
		getHibernateTemplate().update(t);
	}
	/**
	 *	由子类实现
	 * @author Zoe
	 * @date 2018年12月21日下午9:03:03
	 * @param t1
	 * @return
	 */
	public DetachedCriteria getDetachedCriteria(T t1, T t2, Object param) {
		return null;
	}
}

通用dao层的使用

继承通用dao层接口

public interface DepDao extends BaseDao<Dep> {}

继承通用dao层实现类，实现自己的接口

public class DepDaoImpl extends BaseDaoImpl<Dep> implements DepDao {
	/**
	 * 部门条件查询公共方法
	 * @author Zoe
	 * @date 2018年12月21日下午9:03:03
	 * @param dep1
	 * @return
	 */
	@Override
	public DetachedCriteria getDetachedCriteria(Dep dep1, Dep dep2, Object param) {
		DetachedCriteria criteria = DetachedCriteria.forClass(Dep.class);
		if( null != dep1) {
			if(null != dep1.getName() && dep1.getName().trim().length() > 0) {
				criteria.add(Restrictions.like("name", dep1.getName(), MatchMode.ANYWHERE));
			}
			if(null != dep1.getTele() && dep1.getTele().trim().length() > 0) {
				criteria.add(Restrictions.like("tele", dep1.getTele(), MatchMode.ANYWHERE));
			}
		}
		return criteria;
	}
}

业务层

通用业务层定义

通用业务层接口

public interface BaseBiz<T> {
	
	/**
	 * 	条件查询
	 * @author Zoe
	 * @date 2018年12月21日下午2:44:17
	 * @return
	 */
	List<T> getList(T t1, T t2, Object param);
	
	/**
	 * 	分页_条件查询
	 * @author Zoe
	 * @date 2018年12月21日下午8:43:20
	 * @param t1
	 * @param rows 
	 * @param firstResult 
	 * @return
	 */
	List<T> getListByPage(T t1, T t2, Object param, int firstResult, int maxResults);
	
	/**
	 * 	获取分页_条件查询总记录数
	 * @author Zoe
	 * @date 2018年12月21日下午9:08:19
	 * @param t1
	 * @return
	 */
	Long getCount(T t1, T t2, Object param);
	
	/**
	 * 添加
	 * @author Zoe
	 * @date 2018年12月21日下午10:50:29
	 * @param t
	 */
	void add(T t);

	/**
	 * 根据编号删除对象
	 * @author Zoe
	 * @date 2018年12月22日下午3:59:00
	 * @param id
	 */
	void delete(long id);
	
	/**
	 * 	根据编号查找对象
	 * @author Zoe
	 * @date 2018年12月22日下午7:36:57
	 * @param id
	 * @return
	 */
	T get(long id);
	
	/**
	 * 	更新
	 * @author Zoe
	 * @date 2018年12月22日下午8:07:20
	 * @param t
	 */
	void update(T t);
}

通用业务层实现类

public class BaseBizImpl<T> implements BaseBiz<T> {
	private BaseDao<T> baseDao;

	/**
	 * @param baseDao the baseDao to set
	 */
	public void setBaseDao(BaseDao<T> baseDao) {
		this.baseDao = baseDao;
	}

	/**
	 * @author Zoe
	 * @date 2018年12月21日下午2:45:36
	 * @return
	 */
	@Override
	public List<T> getList(T t1, T t2, Object param) {
		return baseDao.getList(t1, t2, param);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月21日下午8:43:40
	 * @param dep1
	 * @return
	 */
	@Override
	public List<T> getListByPage(T t1, T t2, Object param, int firstResult, int maxResults) {
		return baseDao.getListByPage(t1, t2, param, firstResult, maxResults);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月21日下午9:08:33
	 * @param dep1
	 * @return
	 */
	@Override
	public Long getCount(T dep1, T dep2, Object params) {
		return baseDao.getCount(dep1, dep1, params);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月21日下午10:50:43
	 * @param dep
	 */
	@Override
	public void add(T dep) {
		baseDao.add(dep);
	}
	/**
	 * @author Zoe
	 * @date 2018年12月22日下午3:59:20
	 * @param id
	 */
	@Override
	public void delete(long id) {
		baseDao.delete(id);
	}

	/**
	 * @author Zoe
	 * @date 2018年12月22日下午7:37:26
	 * @param id
	 * @return
	 */
	@Override
	public T get(long id) {
		return baseDao.get(id);
	}
	/**
	 * @author Zoe
	 * @date 2018年12月22日下午8:07:36
	 * @param dep
	 */
	@Override
	public void update(T dep) {
		baseDao.update(dep);
	}

}

通用业务层的使用

继承通用业务层接口

public interface DepBiz extends BaseBiz<Dep> {}

继承通用业务层实现类，实现自己的接口

public class DepBizImpl extends BaseBizImpl<Dep> implements DepBiz {
	
	private DepDao depDao;

	/**
	 * @param depDao the depDao to set
	 */
	public void setDepDao(DepDao depDao) {
		this.depDao = depDao;
		super.setBaseDao(depDao);
	}
}

控制层

通用控制层定义

省略了普通的setter，getter方法

public class BaseAction<T> {
	private BaseBiz<T> baseBiz;

	/**
	 * @param baseBiz the baseBiz to set
	 */
	public void setBaseBiz(BaseBiz<T> baseBiz) {
		this.baseBiz = baseBiz;
	}
	private T t;
	// 属性驱动_条件查询
	private T t1;
	private T t2;
	private Object param;
	// 页码
	private int page;
	// 每页记录数
	private int rows;
	private long id;
	/**
	 * 	条件查询
	 * @author Zoe
	 * @date 2018年12月21日下午2:53:51
	 */
	public void list() {
		List<T> list = baseBiz.getList(t1, t2, param);
		// 序列化list为json对象
		String string = JSON.toJSONString(list);
		HttpServletResponse response = ServletActionContext.getResponse();
		response.setContentType("text/html;charset=utf-8");
		try {
			// 将序列化后的后台数据响应给前台页面
			response.getWriter().write(string);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 	条件查询
	 * @author Zoe
	 * @date 2018年12月21日下午8:44:37
	 */
	public void getList() {
		// 设置后台分页查询开始位置
		int firstResult = (page - 1) * rows;
		
		List<T> list = baseBiz.getListByPage(t1, t2, param, firstResult, rows);
		
		long total = baseBiz.getCount(t1, t2, param);
		
		Map<String, Object> mapData = new HashMap<String, Object>();
		mapData.put("total", total);
		mapData.put("rows", list);
		
		String string = JSON.toJSONString(mapData);
		write(string);
	}

	/**
	 * 	添加
	 * @author Zoe
	 * @date 2018年12月21日下午10:48:28
	 */
	public void add() {
		try {
			baseBiz.add(t);
			ajaxReturn(true, "添加成功");
		} catch (Exception e) {
			e.printStackTrace();
			ajaxReturn(false, "添加失败");
		}
	}
	
	/**
	 * 根据编号删除对象
	 * @author Zoe
	 * @date 2018年12月22日下午3:32:06
	 */
	public void delete() {
		try {
			baseBiz.delete(id);
			ajaxReturn(true, "删除成功");
		} catch (Exception e) {
			e.printStackTrace();
			ajaxReturn(false, "删除失败");
		}
	}
	
	/**
	 * 	根据编号查找对象
	 * @author Zoe
	 * @date 2018年12月22日下午7:37:56
	 */
	public void get() {
		T t = baseBiz.get(id);
		// 给后台数据添加前缀，使其与前端表单中的name属性值保持一致，以保证前端数据正常显示
		mapData(JSON.toJSONString(t), "t");
	}
	
	/**
	 * 给后台数据添加前缀，使其与前端表单中的name属性值保持一致，以保证前端数据正常显示
	 * //{"name":"管理员组","tele":"000011","uuid":1} 
	 * {"t.name":"管理员组","t.tele":"000011","t.uuid":1} 
	 * @author Zoe
	 * @date 2018年12月22日下午7:55:12
	 * @param jsonString
	 * @param prefix 要加上的前缀
	 */
	public void mapData(String jsonString, String prefix) {
		Map<String, Object> map = JSON.parseObject(jsonString);
		Map<String, Object> data = new HashMap<String, Object>();
		for (String key : map.keySet()) {
			data.put(prefix + "." + key, map.get(key));
		}
		write(JSON.toJSONString(data));
	}
	
	/**
	 * 	更新
	 * @author Zoe
	 * @date 2018年12月22日下午8:08:07
	 */
	public void update() {
		try {
			baseBiz.update(t);
			ajaxReturn(true, "修改成功");
		} catch (Exception e) {
			e.printStackTrace();
			ajaxReturn(false, "修改失败");
		}
	}
	/**
	 * 返回给前台的信息
	 * @author Zoe
	 * @date 2018年12月21日下午10:59:48
	 * @param success
	 * @param message
	 */
	public void ajaxReturn(boolean success, String message) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("success", success);
		map.put("message", message);
		
		write(JSON.toJSONString(map));
	}
	/**
	 * 返回后台响应数据到前台
	 * @author Zoe
	 * @date 2018年12月21日下午9:15:19
	 * @param mapData
	 */
	public void write(String jsonString) {
		HttpServletResponse response = ServletActionContext.getResponse();
		response.setContentType("text/html;charset=utf-8");
		try {
			// 将序列化后的后台数据响应给前台页面
			response.getWriter().write(jsonString);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

继承通用控制层

public class DepAction extends BaseAction<Dep> {

	private DepBiz depBiz;

	/**
	 * @param depBiz the depBiz to set
	 */
	public void setDepBiz(DepBiz depBiz) {
		this.depBiz = depBiz;
		super.setBaseBiz(this.depBiz);
	}
}