【详细】总结JavaWeb开发中SSH框架开发问题（用心总结，不容错过）

在做JavaWeb的SSH框架开发的时候，遇到过很多的细节问题，这里大概记录下

我使用的IDE是Eclipse（老版本）三大框架：Spring4、Struts2、Hibernate5

1.web.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>Blog</display-name>
    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>
    <!-- 让spring随web启动而创建的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 配置spring配置文件位置参数 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 扩大session作用范围 -->
    <filter>
        <filter-name>openSessionInView</filter-name>
        <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <!-- struts2核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>openSessionInView</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>
</web-app>

1.ContextLoaderListener的作用：

ContextLoaderListener监听器的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。

因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。

在ContextLoaderListener中关联了ContextLoader这个类，所以整个加载配置过程由ContextLoader来完成。

通俗简单理解：必须要配置这个，用来读取Spring配置文件

2.contextConfigLocation的作用：

配置spring配置文件位置参数，这里我Spring的XML配置文件在src下，直接写即可

3.OpenSessionInViewFilter的作用：

Spring为我们解决Hibernate的Session的关闭与开启问题。

Hibernate 允许对关联对象、属性进行延迟加载，但是必须保证延迟加载的操作限于同一个 Hibernate Session 范围之内进行。

如果 Service 层返回一个启用了延迟加载功能的领域对象给 Web 层，当 Web 层访问到那些需要延迟加载的数据时，由于加载领域对象的 Hibernate Session 已经关闭，这些导致延迟加载数据的访问异常

比如抛出这种异常：

org.hibernate.LazyInitializationException:(LazyInitializationException.java:42)
 - failed to lazily initialize a collection of role: cn.easyjava.bean.product.ProductType.childtypes, no session or session was closed
org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: cn.easyjava.bean.product.ProductType.childtypes, 
no session or session was closed

用来把一个Hibernate Session和一次完整的请求过程对应的线程相绑定。目的是为了实现"Open Session in View"的模式。例如： 它允许在事务提交之后延迟加载显示所需要的对象。

而Spring为我们提供的OpenSessionInViewFilter过滤器为我们很好的解决了这个问题。

OpenSessionInViewFilter的主要功能是用来把一个Hibernate Session和一次完整的请求过程对应的线程相绑定。

目的是为了实现"Open Session in View"的模式。例如： 它允许在事务提交之后延迟加载显示所需要的对象

OpenSessionInViewFilter 过滤器将 Hibernate Session 绑定到请求线程中，它将自动被 Spring 的事务管理器探测到。

所以 OpenSessionInViewFilter 适用于 Service 层使用HibernateTransactionManager进行事务管理的环境，也可以用于非事务只读的数据操作中

通俗简单解释：有时候数据库查到的结果返回到jsp页面会抛异常，配置好这个就可以解决。在前端页面显示完相应的结果再关闭session

其他注意事项：

1.strust2核心过滤器一定要写在最后边

2.开头我这里设置的session有效时间60（单位：分钟）

接下来Spring配置文件:

命名什么都可以，我取名applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

    <!-- 读取db.properties文件 -->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置c3p0连接池 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 核心事务管理器 -->
    <bean name="transactionManager"
        class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <!-- 配置通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="persist*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="true" />
            <tx:method name="*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="false" />
        </tx:attributes>
    </tx:advice>
    <!-- 配置将通知织入目标对象 -->
    <aop:config>
        <aop:pointcut expression="execution(* service.impl.*ServiceImpl.*(..))"
            id="txPc" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
    </aop:config>

    <!-- 在spring配置中放置hibernate配置信息 -->
    <bean name="sessionFactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置hibernate基本信息 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect
                </prop>

                <!-- 可选配置 -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
        <property name="mappingDirectoryLocations" value="classpath:domain"></property>
    </bean>
    <!-- action -->
    <!-- 注意:Action对象作用范围一定是多例的（prototype）.这样才符合struts2架构 -->
    <bean name="userAction" class="web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>
    <!-- service -->
    <bean name="userService" class="service.impl.UserServiceImpl">
        <property name="userdao" ref="userDao"></property>
    </bean>
    <!-- dao -->
    <bean name="userDao" class="dao.impl.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
</beans>

这里解释下Spring配置文件以及易错处：

1.数据库参数我写在一个db.properties文件种，方便开发中修改

2.接下来配置c3p0连接池，虽然不使用也可以，但是hibernate推荐使用

3.transactionManager这个bean，管理事务嵌套，开启，关闭，资源线程同步，提交，回滚

初步了解， HibernateTransactionManager这个类提供 sessionFactory的管理。

为了实现数据同步，在HibernateTransactionManager内部会进行Hibernate session的open和close，并将打开的Hibernaate sesion关联到当前的Application session。

在Application中则通过getCurrentSession方式获取争取的打开的Hibernate session，  从而解决某些方面的线程安全及同步问题。

通俗解释，这里配置的意义在于：只有配置好这一项，才可以在DAO层使用HibernateTemplate，方便数据库操作

4.配置通知和AOP方面，见我以前文章：

http://www.cnblogs.com/xuyiqing/p/8463598.html

http://www.cnblogs.com/xuyiqing/p/8464465.html

这里大概解释下：

例如这里：

            <tx:method name="get*" isolation="REPEATABLE_READ"
                propagation="REQUIRED" read-only="true" />

这一句的意思是：所有DAO层方法，在生效前，先通过这里的“通知”，如果是get开头的方法，只能查询数据库，无法修改

这里的两个参数：isolation="REPEATABLE_READ"事务隔离级别，暂不做解释，开发中只选择这一项

propagation="REQUIRED"事务传播行为，暂不做解释，开发中只选择这一项

最后一个属性，是否只读：如果是查询类方法，应该设置为只读，如果是增删更新操作，应该设置为false

下面：expression="execution(* service.impl.*ServiceImpl.*(..))这里是通配方法，为所有service包的实现类中的所有方法配置切点

后边是一个增强AOP配置，配好即可，没什么解释的

5.在spring配置中放置hibernate配置信息：

先注入上面配置好的c3p0连接池，再配置Hibernate

<prop key="hibernate.hbm2ddl.auto">update</prop>的意思是，每一次生成表的时候如果表存在则覆盖，表不存在的话新建一张表，这种方式是最常用的

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>使用MySQL方言，我使用MySQL开发，所有使用这个配置

<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:domain"></property>

这里的意思：hibernate需要一些元数据配置，我把这些配置写在了一个domain包中

最后的三层结构的bean配置就不多解释了

附：db.properties

jdbc.jdbcUrl=jdbc:mysql:///blog?useUnicode=true&characterEncoding=utf-8&autoReconnect=true
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456

url设置的时候需要注意下：这里有个大坑，当时解决了几天。

后边加入characterEncoding=utf-8才可以往数据库中存入中文，否则都是乱码

后一个参数autoReconnect=true是意思的：自动重连，MySQL如果长时间不操作就会关闭（默认8小时）

上边提到了hibernateORM元数据配置：

这里继续

我建立了一个实体类:User（get、set方法）

package domain;

public class User {
    private Long u_id;
    private String username;
    private String u_password;
    private String qq;
    private String avatar;
    private Integer article_count;

    private String checkCode;

    public String getCheckCode() {
        return checkCode;
    }

    public void setCheckCode(String checkCode) {
        this.checkCode = checkCode;
    }

    public Long getU_id() {
        return u_id;
    }

    public void setU_id(Long u_id) {
        this.u_id = u_id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getU_password() {
        return u_password;
    }

    public void setU_password(String u_password) {
        this.u_password = u_password;
    }

    public String getQq() {
        return qq;
    }

    public void setQq(String qq) {
        this.qq = qq;
    }

    public String getAvatar() {
        return avatar;
    }

    public void setAvatar(String avatar) {
        this.avatar = avatar;
    }

    public Integer getArticle_count() {
        return article_count;
    }

    public void setArticle_count(Integer article_count) {
        this.article_count = article_count;
    }
}

对应ORM元数据配置：

User.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="domain">
    <class name="User" table="blog_user">
        <id name="u_id">
            <generator class="native"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="u_password" column="u_password"></property>
        <property name="qq" column="qq"></property>
        <property name="avatar" column="avatar"></property>
        <property name="article_count" column="article_count"></property>
    </class>
</hibernate-mapping>

package是包名：在这个包下找到User类，映射

table是新建的表名字，Id是主键生成策略：

具体见我以前文章：http://www.cnblogs.com/xuyiqing/p/8449059.html

实体开发使用native即可

接下来就是配置表的字段名即可

复杂的配置，如：一对多，多对多等（外键）

比如我这里还有一个article文章类：一个用户可以有多个文章，一个分类下也可以有多个文章：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="domain">
    <class name="Article" table="blog_article">
        <id name="article_id">
            <generator class="native"></generator>
        </id>
        <property name="title"></property>
        <property name="summary"></property>
        <property name="read_count"></property>
        <property name="comment_count"></property>
        <property name="up_count"></property>
        <property name="create_time"></property>
        <property name="article_detail"></property>
        <many-to-one name="article_type" column="article_type_id" class="Articletype"></many-to-one>
        <many-to-one name="author" column="article_author_id" class="User"></many-to-one>
    </class>
</hibernate-mapping>

更多的细节见我以前的文章：

http://www.cnblogs.com/xuyiqing/category/1163473.html

接下来是struts2的配置：

<?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <constant name="struts.multipart.maxSize" value="31457280"></constant>
    <constant name="struts.objectFactory" value="spring"></constant>

    <package name="Blog" namespace="/" extends="struts-default">
        <interceptors>
            <interceptor name="privilegeInterceptor" class="web.interceptor.PrivilegeInterceptor"></interceptor>
            <interceptor-stack name="myStack">
                <interceptor-ref name="privilegeInterceptor">
                    <param name="excludeMethods">login,regist,createRandom,execute</param>
                </interceptor-ref>
                <interceptor-ref name="defaultStack"></interceptor-ref>
            </interceptor-stack>
        </interceptors>
        <default-interceptor-ref name="myStack"></default-interceptor-ref>
        <global-results>
            <result name="toHome" type="redirect">/IndexAction_articleTypeList
            </result>
            <result name="toLogin" type="redirect">/login.jsp</result>
        </global-results>

        <!-- 整合:class属性上填写spring中action对象的BeanName 完全由spring管理action生命周期,包括Action的创建 -->
        <action name="UserAction_*" class="userAction" method="{1}">
            <exception-mapping result="loginError"
                exception="java.lang.RuntimeException"></exception-mapping>
            <result name="loginError">/login.jsp</result>
            <result name="regist">/register.jsp</result>
        </action>
        <action name="CheckImgAction" class="web.action.CheckImgAction">
            <result name="success" type="stream">
                <param name="contentType">image/jpeg</param>
                <param name="inputName">inputStream</param>
            </result>
        </action>
        <action name="UploadAction_*" class="uploadAction" method="{1}">
            <result name="success">/index.jsp</result>
               <interceptor-ref name="defaultStack">
                   <param name="fileUpload.allowedExtensions">jepg,jpg,gif,png</param>
               </interceptor-ref>
            <result name="input">/index.jsp</result>
        </action>
    </package>

    <package name="article" extends="json-default">
        <action name="OthersAction_*" class="othersAction" method="{1}">
            <result name="good" type="json"></result>
            <result name="reply" type="json"></result>
            <result name="delete" type="json"></result>
        </action>
    </package>
</struts>
    

开头配置了两个常量：上次文件最大字节、交给Spring管理Action

后边的：

1.这里我设置了一个拦截器：暂且称它为登录状态检验器：如果不登陆，无法访问我的BBS，下边我写出拦截器代码，这里先看配置

要把自定义拦截器放在默认拦截器前面

                    <param name="excludeMethods">login,regist,createRandom,execute</param>

这里的意思是不拦截登录、注册、随机生成验证码方法

2.接下来配置的是全局结果集

3.后边的Action配置就不必详细说了：注意这一句

            <exception-mapping result="loginError"
                exception="java.lang.RuntimeException"></exception-mapping>

这里我为什么要配置一个异常呢？非常有用

用于登录错误回显，Exception里面可以放message，即错误信息，比如用户名不存在等等

如果有异常，这里就返回当前页面，带着错误信息，前端页面用EL或struts2标签显示即可：例如

<s:property value="exception.message" />

4.后边的Action参数配置还可以是一个流对象：用于做验证码图片临时保存

5.后边我留下了一个文件上传Action的配置：

<interceptor-ref name="defaultStack">
<param name="fileUpload.allowedExtensions">jepg,jpg,gif,png</param>
</interceptor-ref>

这里的意思是：我做了一个过滤器，只可以上传图片文件

6.<package name="article" extends="json-default">

这个包的作用很重要：是专门处理AJAX请求的，struts-default无法处理AJAX请求

这里是登录拦截器的代码：

package web.interceptor;

import java.util.Map;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

import domain.User;

//验证登录状态拦截器
@SuppressWarnings("all")
public class PrivilegeInterceptor extends MethodFilterInterceptor {

    @Override
    // 不拦截登陆和注册方法
    protected String doIntercept(ActionInvocation invocation) throws Exception {
        // 1 获得Session
        Map<String, Object> session = ActionContext.getContext().getSession();
        // 2 获得登陆标识
        User user = (User) session.get("user");
        // 3 判断标识是否存在

        if (user != null) {
            // 存在=> 放行
            return invocation.invoke();
        } else {
            // 不存在=> 重定向到登陆页面
            return "toLogin";
        }    

    }

}

写的很详细，不必多说，都能看懂吧

配置文件部分内容就完了，后边陆续更新代码方面的坑和注意事项