使用SSH框架来完成CRM系统流程总结

   今天是国庆节的第四天，也是中间一天。没有舍得出去玩，因为我觉得像这样的大块时间来的不容易，不用去上课，没有人干扰，用来学习自己喜欢的东西挺幸福的。我用将近一个星期的时间学习别人的CRM系统。自己也是刚学完SSH框架，用SSH框架来实现CRM系统。过程中犯下过许多错误。我把一些常遇到的错误已经发过博客。今天，我不想再再往下走，去学新的东西。我想停下来吸收吸收SSH中的东西。 

    关于的自己的CRM系统，我这次先不放代码，我需要完善一下。这次先来总结项目流程。

    话说SSH：前边已经提到过使用的框架就是SSH（spring+struts2+hibernate），顺带着稍微总结一下这三个框架吧，框架本来就是软件的半成品，初学者需要先掌握使用方法，其实最多的是配置的问题（配置有使用xml文件的形式，也可以采用注解开发的模式，各有好处，xml便于维护，注解用起来速度更快。一定不要把两个搞混了）。我觉得学习框架就像学习开车，一上来应该先学会开车，因为先学会开车了才能够给自己带来方便，至于车的构造，不应该是初学者去搞的（这里指框架的底层，更深层的是源码，但是具体流程还是要掌握一下的，只有掌握具体的流程，在调错的时候才能一针见血），等能够使用熟练了以后，就应该挖挖底层了，因为不想造车的司机不是好司机，如果作为初学者，不懂底层可以原谅，如果使用很长时间还不了解底层，就有点说不过去了。就像开了十年车，不知道车的构造，车出了问题，不知道哪里出的问题，这显得多么荒谬...

   分说：struts2，就是基于mvc设计模式的web应用框架，web层的框架，一般都是基于前端控制器模型来设计的。

   分说:hibernate，就是一个持久层的ORM框架。（ORM）(Object relational Mapping)对象关系映射。目的就是用来创建实体类和数据库中表的映射关系。达到操作对象就能操作数据库的目的。（这里都稍微总结一下吧，有点小跑题，不要慌，面包会有的..）

  分说：spring，EE开发的一站式框架。也正是spring将三个框架连接在一起，一起在项目中发力。spring的好处有：轻量，控制反转，面向切面，可以很方便的对程序进行扩展，方便解耦，AOP的编程支持，声明式事务支持，方便程序的测试，方便集成各种优秀的框架，降低javaEE开发API的难度。解耦合的思想很重要，后期方便维护和扩展。框架各管一层，spring又将框架连接起来。

   总结完了三个框架，下边来面包吧：

    不管是用什么框架，创建项目搭建必须的环境是第一步，我们需要引入jar包，这是为的项目能跑起来需需要的所有的jar包

antlr-2.7.7.jar
asm-3.3.jar
asm-commons-3.3.jar
asm-tree-3.3.jar
c3p0-0.9.2.1.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.apache.log4j-1.2.15.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
commons-beanutils-1.8.3.jar
commons-collections-3.2.1.jar
commons-fileupload-1.3.1.jar
commons-io-2.2.jar
commons-lang-2.5.jar
commons-lang3-3.2.jar
commons-logging-1.1.1.jar
dom4j-1.6.1.jar
ezmorph-1.0.6.jar
freemarker-2.3.22.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-c3p0-5.0.7.Final.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar
json-lib-2.4-jdk15.jar
jstl.jar
log4j-1.2.16.jar
log4j-api-2.2.jar
log4j-core-2.2.jar
mchange-commons-java-0.2.3.4.jar
mysql-connector-java-5.1.7-bin.jar
ognl-3.0.6.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.7.2.jar
spring-aop-4.2.4.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar
spring-expression-4.2.4.RELEASE.jar
spring-jdbc-4.2.4.RELEASE.jar
spring-orm-4.2.4.RELEASE.jar
spring-test-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar
spring-web-4.2.4.RELEASE.jar
standard.jar
struts2-core-2.3.24.jar
struts2-spring-plugin-2.3.24.jar
xwork-core-2.3.24.jar

    导入完了jar包以后，还需要引入配置文件，

1. 创建项目，环境的搭建：导入jar包
2. 引入配置文件
   1. Struts2的框架需要修改的是：
      • Web.xml

<!-- struts2的核心过滤器 -->

<filter> 

<filter-name>struts</filter-name>

<filter-class>org.apache.struts2.dispatcher.ng.filter.Strut sPrepareAndExecuteFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>struts</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

1. • • Struts.xml
   • spring的框架
     • Jdbc.properties
     • log4j.properties
     • applicationContext.xml
     • web.xml
   • Hibernate的框架
     • Hibernate.cfg.xml ---现在交给spring去管理了
2. 创建相关的包结构

3. 

 

 

   关于包的结构，与类的创建有需要注意的点，我们最好是采用接口+实现类的方式，这样也方便事务的管理。

     如果做功能比较齐全一点的项目，就像我做的CRM管理系统，

这里说一下封装继承的用法，和优点   （体现在dao层） 

 有几个模块的代码有大量的重复，比方说客户管理模块，联系人管理模块，拜访管理模块，都需要分页，都需要进行URCD操作，在dao层有很大一部分代码是重复的，就是你有我也有的地方，对于这个地方，我们就可以使用泛型，抽取出来公共的代码

实现步骤就是写一个公共的接口出来，其他模块的接口可以来继承这个接口，由于继承的优点所在，各个模块相同的部分给父亲，然后每个模块又继承父亲，父亲有的孩子都可以共享，这样就可以实现抽取代码，简化代码的目的。

比如我crm项目的抽取出来的通用接口

package com.xing.crm.dao;

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

import org.hibernate.criterion.DetachedCriteria;

/**
 * 通用的Dao接口
 * @author DELL
 *
 */
public interface BaseDao<T> {
    //保存的方法
    public void save(T t);
    //更新的方法
    public void update(T t);
    //删除的方法
    public void delete(T t);
    //查询一个的方法
    public T findById(Serializable id);
    //查询所有的方法
    public List<T> findAll();
    //统计个数的方法
    public Integer findCount(DetachedCriteria detachedCriteria);
    //分页查询的方法
    public List<T> findByPage(DetachedCriteria detachedCriteria,Integer begin, Integer pageSize);
}

   BaseDao接口的实现类：（注意我的实现类继承了hibernate的模板）

package com.xing.crm.dao.impl;

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

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.xing.crm.dao.BaseDao;

/**
 * 通用的Dao的实现类
 * 
 * @author DELL
 *
 */
public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {

    // 提供构造方法，在构造方法中传入具体类型的class
    private Class clazz;

    /**
     * 不想让子类中有带参数的构造方法，就必须在父类中提供无参构造，在无参构造中获取具体类型的Class 具体类型的Class是参数类型中的实际类型参数。
     * 
     * @param clazz
     */
    public BaseDaoImpl() {
        // 反射：第一步获得class
        Class clazz = this.getClass();// 获取正在被调用的类的Class
        // 获取参数化类型
        Type type = clazz.getGenericSuperclass();// 如果是CustomerImpl继承的BaseDaoImpl就获得BaseDaoImpl<Customer>
        // 将type强转换成参数化类型：
        ParameterizedType pType=(ParameterizedType) type;
        //通过参数化类型的方法获得实际类型的参数
        Type[] types= pType.getActualTypeArguments();//获得的参数数组
        //因为我们只有一个参数，所以只需要获得第一个参数即可
        this.clazz=(Class) types[0];//最后一步获得到实际类型参数Customer
    }

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

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

    @Override
    public void delete(T t) {
        this.getHibernateTemplate().delete(t);
    }

    @Override
    public T findById(Serializable id) {
        return (T) this.getHibernateTemplate().get(clazz, id);
    }

    // 查询所有的方法
    @Override
    public List<T> findAll() {
        return (List<T>) this.getHibernateTemplate().find("from " + clazz.getSimpleName());
    }

    // 统计个数的方法
    @Override
    public Integer findCount(DetachedCriteria detachedCriteria) {
        // 设置统计个数的条件
        detachedCriteria.setProjection(Projections.rowCount());
        List<Long> list = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
        if (list.size() > 0) {
            return list.get(0).intValue();
        }
        return null;
    }

    // 分页查询的方法
    @Override
    public List<T> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize) {
        detachedCriteria.setProjection(null);
        return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria, begin, pageSize);
    }

}

   接下来再写模块的dao层接口的时候，接口需要继承一下BaseDao接口。

接下来再写模块的dao层的实现类，注意仍然是继承BaseDaoImpl，就是继承通用接口的实现类

这样一来，好处就体现出来了，因为在我的模块实现类中一行代码都不需要写了。如果不这样写的话，有十个模块，同样的代码就需要写十遍，因为每一个模块的dao层的实现类都要这样来写。代码量直接就体现出来了。这正是体现封装和继承的优点。

需要注意的是，我抽取出来的是模块共同的代码，并不是说这样一来，dao层的实现类就真的一行代码都不需要了，如果某个模块有特殊的需求，那么就需要在dao层的实现类中单独来写了。

  接下来模块的service正常创建就可以

  但是action类要继承ActionSupport  并且实现ModelDriven接口