【Java EE 学习 69 下】【数据采集系统第一天】【实体类分析和Base类书写】

之前SSH框架已经搭建完毕，现在进行实体类的分析和Base类的书写。Base类是抽象类，专门用于继承。

一、实体类关系分析

　　既然是数据采集系统，首先调查实体（Survey）是一定要有的，一个调查有多个页面(Page)，一个页面有多个问题(Question)，所以还要有页面和问题实体。参与完成调查之后一定还会生成若干个答案，所以还有答案实体（Answer），当然还有参与的用户（User），管理员是特殊的User，只需要登陆的时候进行判断即可。

　　分析实体类型是比较简单的，最重要的是设计，怎样设计才能满足调查中所需要的各种字段要求？各个实体之间是否有关系，如果有关系是否需要做双向关联(hibernate配置文件中声明)？。

　　首先从User实体开始分析，一个用户可以参与多个调查，一个调查可以被多个用户参与，所以User和Survey实体之间是典型的多对多关系。既然有有关系了，那么是否需要做双向关联？我们经常做的是根据User对象拿到该User对象拥有的所有Survey，我们基本上不会用到根据Survey对象取得User对象，所以我们只需要做User到Survey的多对多映射关系即可。以上的分析是错误的。这里的User和Survey之间的关系是创建的关系，而不是参与调查的关系。所以一个用户能够创建多个调查，但是一个调查只能被一个用户创建，所以调查和用户之间是多对一关系。虽然我们会通过User对象获取Survey对象集合，但是我们并不会经常这么做，而且这么做有一个致命的缺点，那就是会增加Session的存储压力。为了减小Session的存储压力，我们只做Survey到User的多对一单向关联，不做User到Survey的多对一关联。

　　Survey实体和Page以及User均有关系，但是不做到User的多对多关系的映射。Survey和Page之间是一对多的关系，一个页面只能出现在一个Survey中，但是一个Survey中能够有多个Page。既然两者有关系，是需要做两者的双向关联关系还是单向关联关系？我们会根据Survey对象获取该对象的所有Page,也会根据该Page获取该页面属于哪一个Survey对象，所以我们需要做双向关联关系，即做Survey到Page的一对多映射和做Page到Survey的多对一映射。

　　Page实体和Question同理，我们需要做Page到Quesiton的一对多映射，也需要做Question到Page的多对一映射。

　　Answer实体暂时不作考虑。

二、实体属性分析

　　1.Question分析（最复杂）

　　　　为了能够使用该Question对象保存住所有九种类型的选项，Quesiton中的属性能够表示出这九种类型。

　　　　九种类型的题型（排列顺序不能改变，因为需要通过该位置获取问题的类别）：

　　　　　　第一类：非矩阵式横向单选按钮、非矩阵式纵向单选按钮、非矩阵式横向复选按钮、非矩阵式纵向复选按钮

　　　　　　第二类：非矩阵式下拉列表

　　　　　　第三类：非矩阵式文本框

　　　　　　第四类：矩阵式单选按钮、矩阵式复选按钮

　　　　　　第五类：矩阵式下拉列表

　　private transient Integer questionId;                //问题的ID
    /**
     * 题型分为0-8一共九种类型
     */
    private int questionType;            //问题的题型
    private String title;            //问题的标题
    private String optionText;            //问题的选项
    private String[]optionTextArr;                                                //问题选项的集合
    
    private boolean other;            //其他项
    //其他项可能是无、文本框、下拉列表框
    private String otherType;        //其他项的样式
    private String otherSelectOptions;    //其他项如果是下拉列表框的话使用该项作为内容
    private String[] otherSelectOptionArr;                                        //该字段对应着其他项是多选框的情况，这里存放着拆分之后的字符串数组
    
    private String matrixRowTitles;        //矩阵式行标题集
    private String[] matrixRowTitleArr;                                            //矩阵式行标题集数组
    private String matrixColTitles;        //矩阵式列标题集
    private String[] matrixColTitleArr;                                            //矩阵式列标题集数组
    private String matrixSelectOptions;        //矩阵式下拉选项集
    private String []matrixSelectOptionArr;                                        //矩阵式下拉列表
    
    //Question和Page之间是多对一的关系
    private Page page;        

　　　　　　对于每一个问题来说，不可能每个属性都用的到，但是必须要这么写，否则就需要针对每一种提醒设计一种Question实体，那样就麻烦了。

　　2.Page

    private transient Integer pageId;            //页面id
    private String title="未命名";        //页面标题
    private String description;    //页面描述
    
    //page和调查之间是多对一的关系
    private transient Survey survey;
    //page和Question之间是一对多的关系
    private Set<Question> questions=new HashSet<Question>();
    private float orderNo;        //排序的优先级,默认值和pageId相同    

　　　　需要说明一个字段是orderNo，该字段的用处是排序，默认值和pageId相同，这个将会在以后的复制/移动页的功能中使用到。

　　3.Survey分析（复杂）

private Integer surveyId;            //对应着调查id
    private String title="未命名";        //对应着调查名称
    private String preText="上一页";        //对应着翻页的上一个提示
    private String nextText="下一页";    //对应着下一页的提示
    private String exitText="退出";        //对应着退出的提示
    private String doneText="完成";    //对应着完成的提示文本
    private Date createDate=new Date();    //对应着创建的日期
    private String logoPath;            //使用该字段保存图标的位置，保存的是相对位置
    //调查和用户之间是多对一的关系
    private User user;
    //调查和Page之间是一对多的关系
    private transient Set<Page>pages=new HashSet<Page>();
    
    //添加一个调查是否可用的字段，表示打开或者关闭调查
    private boolean closed;
    
    /**
     * TODO 在数据库库中没有定义，但是需要在配置文件中定义并带到前端页面中使用
     */
    private float maxOrderNo;            //最小页序
    private float minOrderNo;            //最大页序
    
    //定义几个常量，方便判断是哪种类型的提交
    private  String submit_next="下一页";
    private String submit_pre="上一页";
    private String submit_done="提交";
    private String submit_exit="退出";

　　4.Use类分析

private Integer userId;                //用户id
    private String password;        //用户密码
    private String nickName;        //用户昵称
    private String email;            //用户邮件
    private Date registerDate;        //用户注册日期
    private Set<Role>roles;
    private Boolean superAdmin;    //判定是否是超级管理员的标识字段
    private long[]rightSum;        //进行权限判定的关键,注意这里一定要使用基本数据类型，否则会有问题，因为包装类型的默认值不是0，是null

　　　　该类在项目初期中只用到了一部分属性，像是基本的userId、password等，剩下的roles、superAdmin、rightSum在权限管理模块中会使用到。

　　5.hibernate映射文件略。

三、Base类书写。

　　1.BaseDao书写

 　　　　针对每一个实体，我们都需要写一个DAO操作对应的数据库中的表，将所有的DAO中的公共方法抽象出来放到一个抽象类中是一个比较好的方法，这样能够极大的重用代码。当然，我们还需要使用一个接口对该抽象类进行规范。

　　　　DAO接口规范：

package com.kdyzm.dao.base;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

public interface BaseDao <T>{
    //写操作
    public void saveEntity(T t);
    public void updateEntity(T t);
    public void saveOrUpdateEntity(T t);
    public void deleteEntiry(T t);
    
    //按照hql批处理
    public void batchEntityByHql(String hql,Object ...objects);
    
    //查询方法
    public T getEntityById(Serializable id);
    public T loadEntiryById(Serializable id);
    public List<T> findEntityByHQL(String hql,Object ...objects);
    public Object findUniqueResult(String hql,Object ...objects);
    public Collection<T> findAllEntities();
    public void executeSql(String sql,Object ...objects);
    public Collection<T> findAllEntitiesBySql(String sql,Object ...objects);
}

　　　　实现类（抽象）：

package com.kdyzm.dao.base.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;

import javax.annotation.Resource;

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

import com.kdyzm.dao.base.BaseDao;
/***
 * BaseDaoImpl类必须是抽象类,实现已经定义好的接口
 * @author kdyzm
 *
 * @param <T>
 */
@SuppressWarnings("unchecked")
public abstract class BaseDaoImpl<T> implements BaseDao<T> {
    //手下需要两个成员变量，这两个成员变量的赋值，一个是通过spring容器管理，一个是通过泛型动态获取
    @Resource(name="sessionFactory")
    public SessionFactory sessionFactory;
    private Class<T> clazz;
    
    //在默认构造方法中调用相关程序获取真实的泛型类型
    public BaseDaoImpl() {
        ParameterizedType parameterizedType=(ParameterizedType) this.getClass().getGenericSuperclass();
        clazz=(Class<T>) parameterizedType.getActualTypeArguments()[0];
    }
    @Override
    public void saveEntity(T t) {
        System.out.println("将要保存"+t);
        this.sessionFactory.getCurrentSession().save(t);
    }

    @Override
    public void updateEntity(T t) {
        this.sessionFactory.getCurrentSession().update(t);
    }

    @Override
    public void saveOrUpdateEntity(T t) {
        this.sessionFactory.getCurrentSession().saveOrUpdate(t);
    }

    @Override
    public void deleteEntiry(T t) {
        this.sessionFactory.getCurrentSession().delete(t);
    }

    //批量处理更新的方法重点是使用Query对象
    @Override
    public void batchEntityByHql(String hql, Object... objects) {
        Query query=this.sessionFactory.getCurrentSession().createQuery(hql);
        for(int i=0;i<objects.length;i++){
            query.setParameter(i, objects[i]);
        }
        query.executeUpdate();
    }

    @Override
    public T getEntityById(Serializable id) {
        return (T) this.sessionFactory.getCurrentSession().get(clazz,id);
    }

    @Override
    public T loadEntiryById(Serializable id) {
        return (T) this.sessionFactory.getCurrentSession().load(clazz, id);
    }

    @Override
    public List<T> findEntityByHQL(String hql, Object... objects) {
        Query query=this.sessionFactory.getCurrentSession().createQuery(hql);
        for(int i=0;i<objects.length;i++){
            query.setParameter(i, objects[i]);
        }
        return query.list();
    }
    @Override
    public Object findUniqueResult(String hql, Object... objects) {
        Query query=this.sessionFactory.getCurrentSession().createQuery(hql);
        for(int i=0;i<objects.length;i++){
            query.setParameter(i, objects[i]);
        }
        return query.uniqueResult();
    }
    @Override
    public Collection<T> findAllEntities(){
        String hql="from "+clazz.getSimpleName();
        return this.sessionFactory.getCurrentSession().createQuery(hql).list();
    }
    //直接执行sql语句的方法
    @Override
    public void executeSql(String sql, Object... objects) {
        SQLQuery sqlQuery=this.sessionFactory.getCurrentSession().createSQLQuery(sql);
        for(int i=0;i<objects.length;i++){
            sqlQuery.setParameter(i, objects[i]);
        }
        sqlQuery.executeUpdate();
    }
    //根据sql语句得到List集合的方法
    @Override
    public Collection<T> findAllEntitiesBySql(String sql, Object... objects) {
        SQLQuery sqlQuery=this.sessionFactory.getCurrentSession().createSQLQuery(sql);
        for(int i=0;i<objects.length;i++){
            sqlQuery.setParameter(i, objects[i]);
        }
        sqlQuery.addEntity(clazz);
        return sqlQuery.list();
    }
}

　　　　　　实现类需要解决的问题：实现所有的公共方法是其功能要求，想要实现这一点，就必须解决一个最重要的问题，如何获取泛型类型，所有的DAO都会提供一个泛型给父类，即BaseDaoImpl，父类必须知道该类型是什么，在构造方法中获取该类型是最合适的：

//在默认构造方法中调用相关程序获取真实的泛型类型
    public BaseDaoImpl() {
        ParameterizedType parameterizedType=(ParameterizedType) this.getClass().getGenericSuperclass();
        clazz=(Class<T>) parameterizedType.getActualTypeArguments()[0];
    }

　　　　这样clazz对象就保存到了类中的成员变量，其它方法就能够直接使用该对象了。

　　2.BaseService书写

　　　　BaseService接口中的方法和DAO中的方法相同，实现类中直接调用DAO中的方法

package com.kdyzm.service.base;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

public interface BaseService<T> {
    //写操作
    public void saveEntity(T t);
    public void updateEntity(T t);
    public void saveOrUpdateEntity(T t);
    public void deleteEntiry(T t);
    
    //按照hql批处理
    public void batchEntityByHql(String hql,Object ...objects);
    
    //查询方法
    public T getEntityById(Serializable id);
    public T loadEntiryById(Serializable id);
    public List<T> findEntityByHQL(String hql,Object ...objects);
    public Collection<T> findAllEntities();
    
    public void executeSql(String sql,Object ...objects);
    public Collection<T> findAllEntitiesBySQl(String sql,Object ...objects);
}

　　　　BaseServiceImpl实现：实现类中有一个BaseDao<T>类型的成员变量，所有的DAO都实现了BaseDao接口，所以直接使用该接口来引用子类对象是可以的，但是拿到泛型的方式并不是DAO中的实现方式，而是直接由实现类通过set方法传递过来。

    public BaseDao<T> baseDao;
    public void setBaseDao(BaseDao<T> baseDao) {
        this.baseDao = baseDao;
    }    

四、针对各种DAO和Service的实现类略。

五、测试

　　1.实现加入log4j的配置文件到classpath，方便查看控制台输出。

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
log4j.logger.org.hibernate=info

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

　　2.测试类

public class TestUserService {
        private static ApplicationContext ac = null ;
        
        @BeforeClass
        public static void iniAC(){
            ac = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
        }
        
        @Test
        public void insertUser(){
            UserService us = (UserService) ac.getBean("userService");
            User u = new User();
            u.setEmail("kdyzm@foxmail.com");
            u.setPassword("123456");
            us.saveEntity(u);
        }
    }