SSH和SSM

这段时间工作量不是太大，自己又是小白，所以赶紧就抽点时间看了看SSM，因为楼主项目所用的框架一直是SSH，所以将一些心得体会记录一下，有什么不足的地方也希望大家能提出并加以补充。那先从SSH说起吧。
SSH是什么？spring+struts+hibernate。
spring又是谁？
它是一个集成了许多第三方框架的东东，其核心技术是IOC（控制反转，也称依赖注入）和AOP（面向切面编程）。
IOC是做什么的？
我理解为IOC是一种编程思想，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），依赖注入。下面是其中的一种依赖工厂。

    <!-- session工厂 -->      <bean id="sessionFactory"          class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">          <property name="dataSource">              <ref bean="dataSource" />          </property>          <property name="configLocation" value="classpath:hibernate.cfg.xml"/>        <!-- 自动扫描注解方式配置的hibernate类文件 -->          <property name="packagesToScan">              <list>                  <value>com.sh.entity</value>              </list>          </property>      </bean> 

AOP又是什么？
AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，客户端程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要创建出代理对象，至少需要目标类和Advice类。spring提供了这种支持，只需要在spring配置文件中配置这两个元素即可实现代理和aop功能。

 <!-- 配置事务管理器 -->      <bean id="transactionManager"          class="org.springframework.orm.hibernate4.HibernateTransactionManager">          <property name="sessionFactory" ref="sessionFactory" />      </bean>      <!-- 配置事务通知属性 -->      <tx:advice id="txAdvice" transaction-manager="transactionManager">          <!-- 定义事务传播属性 -->          <tx:attributes>              <tx:method name="insert*" propagation="REQUIRED" />              <tx:method name="update*" propagation="REQUIRED" />              <tx:method name="edit*" propagation="REQUIRED" />              <tx:method name="save*" propagation="REQUIRED" />              <tx:method name="add*" propagation="REQUIRED" />              <tx:method name="new*" propagation="REQUIRED" />              <tx:method name="set*" propagation="REQUIRED" />              <tx:method name="remove*" propagation="REQUIRED" />              <tx:method name="delete*" propagation="REQUIRED" />              <tx:method name="change*" propagation="REQUIRED" />              <tx:method name="get*" propagation="REQUIRED" read-only="true" />              <tx:method name="find*" propagation="REQUIRED" read-only="true" />              <tx:method name="load*" propagation="REQUIRED" read-only="true" />              <tx:method name="*" propagation="REQUIRED" read-only="false" />          </tx:attributes>      </tx:advice>      <!-- 配置事务切面 -->      <aop:config>          <aop:pointcut id="serviceOperation" expression="execution(* com.sh.service..*.*(..))" />          <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation" />    </aop:config>  

说了这么多，spring最主要的地方就是管理事务，而它管理事务有两种方式：第一种是基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。(个人觉得注解的方式更加的方便些)。这是在controller

@Controller("payAction")@Scope(value="prototype")

这里面有个scop，这是表示spring的作用域，有singleton(单例) ，prototype（原型） ，request，session，globalsession这几种，大部分我们用prototype。

再说下struts……….
在没有用框架之前，我们知道servlet,而struts就是一个大大的servlet，我们把这个这个Servlet命名为ActionServlet，或是ActionServlet的子类。我们可以在web.xml文件中将符合某种特征的所有请求交给这个Servlet处理，这个Servlet再参照一个配置文件（通常为/WEB-INF/struts-config.xml）将各个请求分别分配给不同的action去处理。

说一下struts的工作流程：Struts 2的工作流程与WebWork框架基本相同，所以说Struts2是WebWork的升级版本。

基本流程如下：1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被FilterDispatcher接收。3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。6、返回HTTP响应到客户端浏览器。

Struts的工作流程

Struts 2的工作流程与WebWork框架基本相同，所以说Struts2是WebWork的升级版本。
基本简要流程如下：1、客户端浏览器发出HTTP请求。2、根据web.xml配置，该请求被FilterDispatcher接收。3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。6、返回HTTP响应到客户端浏览器。

最后是hibernate
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，完成数据持久化的重任。

hibernate的工作原理流程：
原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory

为什么要用hibernate： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2.hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM（对象关系映射）实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

hibernate 在查询的时候是从实体类去查而不是表明。楼主在写项目的时候，习惯于将一些基本的关于hibernate的操作封装为basedao。

package com.sh.dao.impl;import java.io.Serializable;import java.util.List;import javax.annotation.Resource;import org.hibernate.Query;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.springframework.stereotype.Repository;import com.sh.dao.inter.BaseDao;import com.sh.entity.PageBean;@Repository("baseDao")@SuppressWarnings("all")public class BaseDaoImpl<T> implements BaseDao<T> {    @Resource    private SessionFactory sessionFactory;    public SessionFactory getSessionFactory() {        return sessionFactory;    }    public void setSessionFactory(SessionFactory sessionFactory) {        this.sessionFactory = sessionFactory;    }    private Session getCurrentSession() {        return sessionFactory.getCurrentSession();    }    @Override    public Serializable save(T o) {        return this.getCurrentSession().save(o);    }    @Override    public void delete(T o) {        this.getCurrentSession().delete(o);    }    @Override    public void update(T o) {        this.getCurrentSession().update(o);    }    @Override    public void saveOrUpdate(T o) {        this.getCurrentSession().saveOrUpdate(o);    }    @Override    public List<T> find(String hql) {        return this.getCurrentSession().createQuery(hql).list();    }    @Override    public List<T> find(String hql, Object[] param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.length > 0) {            for (int i = 0; i < param.length; i++) {                q.setParameter(i, param[i]);            }        }        return q.list();    }    @Override    public List<T> find(String hql, List<Object> param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.size() > 0) {            for (int i = 0; i < param.size(); i++) {                q.setParameter(i, param.get(i));            }        }        return q.list();    }    @Override    public List<T> find(String hql, Object[] param, PageBean pageBean) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.length > 0) {            for (int i = 0; i < param.length; i++) {                q.setParameter(i, param[i]);            }        }        return q.setFirstResult(pageBean.getStart()).setMaxResults(pageBean.getPageSize()).list();    }    @Override    public List<T> find(String hql, List<Object> param, PageBean pageBean) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.size() > 0) {            for (int i = 0; i < param.size(); i++) {                q.setParameter(i, param.get(i));            }        }        return q.setFirstResult(pageBean.getStart()).setMaxResults(pageBean.getPageSize()).list();    }    @Override    public List<T> find(String hql, PageBean pageBean) {        Query q = this.getCurrentSession().createQuery(hql);        return q.setFirstResult(pageBean.getStart()).setMaxResults(pageBean.getPageSize()).list();    }    @Override    public T get(Class<T> c, Serializable id) {        return (T) this.getCurrentSession().get(c, id);    }    @Override    public T get(String hql, Object[] param) {        List<T> l = this.find(hql, param);        if (l != null && l.size() > 0) {            return l.get(0);        } else {            return null;        }    }    @Override    public T get(String hql, List<Object> param) {        List<T> l = this.find(hql, param);        if (l != null && l.size() > 0) {            return l.get(0);        } else {            return null;        }    }    @Override    public Long count(String hql) {        return  (Long) this.getCurrentSession().createQuery(hql).uniqueResult();    }    @Override    public Long count(String hql, Object[] param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.length > 0) {            for (int i = 0; i < param.length; i++) {                q.setParameter(i, param[i]);            }        }        return (Long) q.uniqueResult();    }    @Override    public Long count(String hql, List<Object> param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.size() > 0) {            for (int i = 0; i < param.size(); i++) {                q.setParameter(i, param.get(i));            }        }        return (Long) q.uniqueResult();    }    @Override    public Integer executeHql(String hql) {        return this.getCurrentSession().createQuery(hql).executeUpdate();    }    @Override    public Integer executeHql(String hql, Object[] param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.length > 0) {            for (int i = 0; i < param.length; i++) {                q.setParameter(i, param[i]);            }        }        return q.executeUpdate();    }    @Override    public Integer executeHql(String hql, List<Object> param) {        Query q = this.getCurrentSession().createQuery(hql);        if (param != null && param.size() > 0) {            for (int i = 0; i < param.size(); i++) {                q.setParameter(i, param.get(i));            }        }        return q.executeUpdate();    }    @Override    public void merge(T o) {        // TODO Auto-generated method stub        this.getCurrentSession().merge(o);    }    @Override    public Integer executeSql(String sql) {        Query q = this.getCurrentSession().createSQLQuery(sql);        return q.executeUpdate();    }}

这里包含了hibernate的三种查询方式，可以根据不同需求灵活的去操作。
ssh就简洁说到这里，ssm抽时间总结。希望大家能够补充提出说明。