ssh Dao与Service的设计与实现

使用UML设计程序

使用 用例图 画出程序的功能模块（小人代表角色，椭圆代表功能）

第一步：画出实体类的关联关系

使用类图设计程序（关键）

单向箭头表示单向关联，没有箭头表示双向关联，线的属性（关联属性）

类的属性和方法一般隐藏

第二步：Dao的设计与实现

BaseDao定义每个Dao都会使用到的通用接口<<Interface>>

BaseDaoImpl实现BaseDao的抽象类（用斜体表示抽象，用虚线空心箭头表示实现接口）

每一个实体类都会有一个Dao的实现类（用实现空心箭头表示继承一个类，用虚线三角箭头表示引用一个类）

BaseDao<T>

package com.atguigu.surveypark.dao;

import java.util.List;

/**
 * BaseDao接口
 */
public interface BaseDao<T> {
	//写操作
	public void saveEntity(T t);
	public void saveOrUpdateEntity(T t);
	public void updateEntity(T t);
	public void deleteEntity(T t);
	public void batchEntityByHQL(String hql,Object...objects);
	
	//读操作
	public T loadEntity(Integer id);
	public T getEntity(Integer id);
	public List<T> findEntityByHQL(String hql,Object...objects);
}

BaseDaoImpl<T>

package com.atguigu.surveypark.dao.impl;

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

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.SessionFactory;

import com.atguigu.surveypark.dao.BaseDao;

/**
 * 抽象的dao实现,专门用于继承
 */
@SuppressWarnings("unchecked")
public abstract class BaseDaoImpl<T> implements BaseDao<T> {

	//注入sessionFactory
	@Resource
	private SessionFactory sf ;
	
	private Class<T> clazz ;
	
	public BaseDaoImpl(){
		//得到泛型话超类
		ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
		clazz = (Class<T>) type.getActualTypeArguments()[0];
	}
	
	public void saveEntity(T t) {
		sf.getCurrentSession().save(t);
	}

	public void saveOrUpdateEntity(T t) {
		sf.getCurrentSession().saveOrUpdate(t);
	}

	public void updateEntity(T t) {
		sf.getCurrentSession().update(t);
	}

	public void deleteEntity(T t) {
		sf.getCurrentSession().delete(t);
	}

	/**
	 * 按照HQL语句进行批量更新
	 */
	public void batchEntityByHQL(String hql, Object... objects) {
		Query q = sf.getCurrentSession().createQuery(hql);
		for(int i = 0 ; i < objects.length ; i ++){
			q.setParameter(i, objects[i]);
		}
		q.executeUpdate();
	}

	public T loadEntity(Integer id) {
		return (T) sf.getCurrentSession().load(clazz, id);
	}

	public T getEntity(Integer id) {
		return (T) sf.getCurrentSession().get(clazz, id);
	}

	public List<T> findEntityByHQL(String hql, Object... objects) {
		Query q = sf.getCurrentSession().createQuery(hql);
		for(int i = 0 ; i < objects.length ; i ++){
			q.setParameter(i, objects[i]);
		}
		return q.list();
	}
}

第三步：Service设计与实现

分两种情况：一种是单体Service（只操作一个Dao），一种是多体Service（操作多个Dao）

不是每一个Dao都有一个对应的Service

BaseService<T>：定义基本的接口，这个接口是所有的Service通用的

package com.atguigu.surveypark.service;

import java.util.List;

/**
 * 基本的dao接口
 */
public interface BaseService<T> {
	//写操作
	public void saveEntity(T t);
	public void saveOrUpdateEntity(T t);
	public void updateEntity(T t);
	public void deleteEntity(T t);
	public void batchEntityByHQL(String hql,Object...objects);
	
	//读操作
	public T loadEntity(Integer id);
	public T getEntity(Integer id);
	public List<T> findEntityByHQL(String hql,Object...objects);
}

BaseServiceImpl<T>：实现基本的接口

package com.atguigu.surveypark.service.impl;

import java.util.List;

import javax.annotation.Resource;

import com.atguigu.surveypark.dao.BaseDao;
import com.atguigu.surveypark.service.BaseService;

/**
 * 抽象的baseService,专门用于继承
 */
public abstract class BaseServiceImpl<T> implements BaseService<T> {

	private BaseDao<T> dao ;
	
	//注入dao
	@Resource
	public void setDao(BaseDao<T> dao) {
		this.dao = dao;
	}

	public void saveEntity(T t) {
		dao.saveEntity(t);
	}

	public void saveOrUpdateEntity(T t) {
		dao.saveOrUpdateEntity(t);
	}

	public void updateEntity(T t) {
		dao.updateEntity(t);
	}

	public void deleteEntity(T t) {
		dao.deleteEntity(t);
	}

	public void batchEntityByHQL(String hql, Object... objects) {
		dao.batchEntityByHQL(hql, objects);
	}

	public T loadEntity(Integer id) {
		return dao.loadEntity(id);
	}

	public T getEntity(Integer id) {
		return dao.getEntity(id);
	}

	public List<T> findEntityByHQL(String hql, Object... objects) {
		return dao.findEntityByHQL(hql, objects);
	}
}

UserService：定义一个扩展接口，这个接口的方法特定义User这个实体类。这里实现BaseServcie这个接口是为了面向接口编程。

package com.atguigu.surveypark.service;

import com.atguigu.surveypark.model.User;

/**
 * UserService
 */
public interface UserService extends BaseService<User> {
}

一个简单的示例：可以将UserServiceImpl类注入到BaseServcie这个接口，这样就可以调用BaseServcie的基本方法和扩展方法了

注意：需要覆盖父类的public void setDao(BaseDao<User> dao) {这个方法，因为@Resource先匹配名字再匹配类型，类型已经被BaseServiceImpl使用了一次，多个类使用同一个类型所以是不行的，覆盖这个方法然后使用特定的名字的类的dao进行注入

package com.atguigu.surveypark.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.atguigu.surveypark.dao.BaseDao;
import com.atguigu.surveypark.model.User;
import com.atguigu.surveypark.service.UserService;

@Service("userService")
public class UserServiceImpl extends BaseServiceImpl<User> implements
		UserService {

	@Resource(name="userDao")
	public void setDao(BaseDao<User> dao) {
		super.setDao(dao);
	}
	
}

第四步：action的设计与实现

BaseAction<T>

package com.atguigu.surveypark.struts2.action;

import java.lang.reflect.ParameterizedType;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.Preparable;

/**
 * 抽象action,专门用于继承
 */
public abstract class BaseAction<T> extends ActionSupport implements
		ModelDriven<T>, Preparable {

	private static final long serialVersionUID = 9180917383072055589L;

	public T model ;
	
	public BaseAction(){
		try {
			ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
			Class clazz = (Class) type.getActualTypeArguments()[0];
			model = (T) clazz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void prepare() throws Exception {
	}

	public T getModel(){
		return model ;
	}
}

一个简单的例子

package com.atguigu.surveypark.struts2.action;

import javax.annotation.Resource;

import org.apache.struts2.interceptor.validation.SkipValidation;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.atguigu.surveypark.model.User;
import com.atguigu.surveypark.service.UserService;
import com.atguigu.surveypark.util.DataUtil;
import com.atguigu.surveypark.util.ValidateUtil;

/**
 * 注册action
 */
@Controller
@Scope("prototype")
public class RegAction extends BaseAction<User> {

	private static final long serialVersionUID = 7351588309970506225L;
	
	private String confirmPassword ;
	
	//注入userService
	@Resource
	private UserService userService ;
	
	public String getConfirmPassword() {
		return confirmPassword;
	}

	public void setConfirmPassword(String confirmPassword) {
		this.confirmPassword = confirmPassword;
	}
	
	/**
	 * 到达注册页面
	 */
	@SkipValidation
	public String toRegPage(){
		return "regPage" ;
	}
	
	/**
	 * 进行用户注册
	 */
	public String doReg(){
		//密码加密
		model.setPassword(DataUtil.md5(model.getPassword()));
		userService.saveEntity(model);
		return SUCCESS ;
	}

	/**
	 * 校验
	 */
	public void validate() {
		//1.非空
		if(!ValidateUtil.isValid(model.getEmail())){
			addFieldError("email", "email是必填项!");
		}
		if(!ValidateUtil.isValid(model.getPassword())){
			addFieldError("password", "password是必填项!");
		}
		if(!ValidateUtil.isValid(model.getNickName())){
			addFieldError("nickName", "nickName是必填项!");
		}
		if(hasErrors()){
			return ;
		}
		//2.密码一致性
		if(!model.getPassword().equals(confirmPassword)){
			addFieldError("password", "密码不一致!");
			return  ;
		}
		//3.email占用
		if(userService.isRegisted(model.getEmail())){
			addFieldError("email", "email已占用!");
		}
	}
	
	
}