使用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

 

struts

org.apache.struts2.dispatcher.ng.filter.Strut sPrepareAndExecuteFilter

struts

/*

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 {     //保存的方法     public void save(T t);     //更新的方法     public void update(T t);     //删除的方法     public void delete(T t);     //查询一个的方法     public T findById(Serializable id);     //查询所有的方法     public List findAll();     //统计个数的方法     public Integer findCount(DetachedCriteria detachedCriteria);     //分页查询的方法     public List 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 extends HibernateDaoSupport implements BaseDao {

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

    /**      * 不想让子类中有带参数的构造方法，就必须在父类中提供无参构造，在无参构造中获取具体类型的Class 具体类型的Class是参数类型中的实际类型参数。      *       * @param clazz      */     public BaseDaoImpl() {         // 反射：第一步获得class         Class clazz = this.getClass();// 获取正在被调用的类的Class         // 获取参数化类型         Type type = clazz.getGenericSuperclass();// 如果是CustomerImpl继承的BaseDaoImpl就获得BaseDaoImpl         // 将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 findAll() {         return (List) this.getHibernateTemplate().find("from " + clazz.getSimpleName());     }

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

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

}

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

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

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

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

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

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