Java框架----SSH整合回顾

1，新建工程，类型为Web Project，设置默认编码为UTF-8，并创建如下文件夹
    1，Source Folder
        1，src        项目源码
        2，config    配置文件
        3，test        单元测试
    2，普通文件夹
        1，WebRoot/style        css与图片等文件
        2，WebRoot/script        js脚本文件
        3，WebRoot/WEB-INF/jsp    jsp页面文件
    3，包结构
        1，实体
            cn.itcast.oa.domain
        2，Dao
            cn.itcast.oa.dao            Dao接口
            cn.itcast.oa.dao.impl        Dao实现类
        3，Service
            cn.itcast.oa.service        Service接口
            cn.itcast.oa.service.impl    Service实现类
        4，View(Struts2)
            cn.itcast.oa.strtus2.action
        5，其他
            cn.itcast.oa.cfg            配置
            cn.itcast.oa.util            工具类
            ...

2，新建数据库，指定编码为UTF-8。

3，添加jar包（放在 WebRoot/WEB-INF/lib/ 下）
    1，环境为：JDK_1.6、JavaEE_5.0
    2，Junit-4.4：
        junit4.4.jar
    3，Struts-2.1.8.1：
        1，添加 ${Struts2_Home}/apps/struts2-blank-2.1.8.1.war/WEB-INF/lib/*.jar
        2，添加struts2-spring整合插件的jar：${Struts2_Home}/lib/struts2-spring-plugin-2.1.8.1.jar
    4，Hibernate-3.6：
        1，添加 ${HIBERNATE_HOME}/hibernate3.jar
        2，添加 ${HIBERNATE_HOME}/lib/required/*.jar
                ${HIBERNATE_HOME}/lib/jpa/hibernate-jpa-2.0-api-1.0.0.Final.jar
        3，添加 JDBC 驱动包，mysql-connector-java-5.1.5-bin.jar
        4，添加 slf4j-log4j12-1.5.8.jar、log4j-1.2.15.jar，
        5，添加 c3p0-0.9.1.2.jar
    5，Spring 2.5.6
        1，添加 ${SPRING_HOME}/dist/spring.jar
        2，添加 ${SPRING_HOME}/lib/aspectj/*.jar（共2个）
        3，添加 ${SPRING_HOME}/lib/cglib/cglib-nodep-2.1_3.jar
        5，添加 ${SPRING_HOME}/lib/jakarta-commons/commons-logging.jar（1.1.1版）
        6，添加工具jar包：commons-codec.jar，commons-lang.jar
    6，Jbpm 4.4（带了Hibernate 3.3.1的jar包与MySQL的JDBC驱动包，所以要把重复的包删除）
        1，添加 ${JBPM_HOME}/jpbm.jar
        2，添加 ${JBPM_HOME}/lib/*.jar，除了junit.jar、servlet-api.jar、cglib.jar
        3，注意：不要添加 cglib.jar，因为Spring中有更高版本的 cglib-nodep-2.1_3.jar
        4, 问题 启动Tomcat后，访问JSP时（使用的是MyEclipse自带的Tomcat，是6.0的版本），报错：
            Caused by: java.lang.LinkageError: loader constraints violated when linking javax/el/ExpressionFactory class
                at org.apache.jsp.WEB_002dINF.jsp.UserAction.loginUI_jsp._jspInit(loginUI_jsp.java:39)
                at org.apache.jasper.runtime.HttpJspBase.init(HttpJspBase.java:52)
                at org.apache.jasper.servlet.JspServletWrapper.getServlet(JspServletWrapper.java:159)
                at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:329)
                at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:320)
                at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:266)
                ... 40 more
                或
java.lang.LinkageError: loader constraint violation: when resolving interface method "javax.servlet.jsp.JspApplicationContext.getExpressionFactory()Ljavax/el/ExpressionFactory;" the class loader (instance of org/apache/jasper/servlet/JasperLoader) of the current class, org/apache/jsp/index_jsp, and the class loader (instance of org/apache/catalina/loader/StandardClassLoader) for resolved class, javax/servlet/jsp/JspApplicationContext, have different Class objects for the type javax/el/ExpressionFactory used in the signature
    org.apache.jsp.index_jsp._jspInit(index_jsp.java:23)
    org.apache.jasper.runtime.HttpJspBase.init(HttpJspBase.java:52)
    org.apache.jasper.servlet.JspServletWrapper.getServlet(JspServletWrapper.java:159)
    org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:329)
    org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:320)
    org.apache.jasper.servlet.JspServlet.service(JspServlet.java:266)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:803)
    org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.doFilter(StrutsPrepareAndExecuteFilter.java:88)

        说明：原因是Jbpm的juel.jar, juel-engine.jar, juel-impl.jar包和Tomcat6.0中的el-api.jar包冲突了。
        有三个解决办法：
        1，方法一：换成tomcat5.5，就没有问题了。
        2，方法二：在MyEclipse的Preferences -> MyEclipse -> Application Servers -> Tomcat -> .. -> Paths 中配置 Append to classpath，选中 juel.jar, juel-engine.jar, juel-impl.jar 这三个jar包就可以了。
        3，方法三：将 juel.jar, juel-engine.jar, juel-impl.jar 这三个包复制到tomcat6下 lib/ 中，并删除原来的el-api.jar，
        切记还要把工程中 WEB-INF\lib 下的 juel.jar, juel-engine.jar, juel-impl.jar 删除，不然还是要冲突。

    8，其他的jar包（在Spring中有）
        commons-codec.jar    含有MD5的工具类
        commons-lang.jar    java.lang包中有关类的工具类

    提示：注意不要发生jar包冲突的问题。

4，配置文件（除web.xml外，都放在源码文件夹 conf/ 下）
    1，Log4j的配置文件：
        log4j.properties
    2，Strtus2的配置文件：
        1，MessageResources.properties
        2，在 web.xml 中配置Struts2的Filter：
            <!-- Struts2的配置 -->
            <filter>
                <filter-name>struts2</filter-name>
                <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
            </filter>
            <filter-mapping>
                <filter-name>struts2</filter-name>
                <url-pattern>/*</url-pattern>
            </filter-mapping>
        3，配置struts.xml（在default.properties找常量的配置）
            <?xml version="1.0" encoding="UTF-8" ?>
            <!DOCTYPE struts PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
                "http://struts.apache.org/dtds/struts-2.1.7.dtd">
            <struts>
                <!-- 设置开发模式 -->
                <constant name="struts.devMode" value="true" />
                <!-- 把action扩展名配置为action -->
                <constant name="struts.action.extension" value="action" />
                <!-- 指定主题使用simple（默认值为xhtml） -->
                <constant name="struts.ui.theme" value="simple" />
                <!-- 定义全局的国际化资源文件 -->
                <constant name="struts.custom.i18n.resources" value="MessageResources"></constant>

                <!-- 可以把相关的action都放在一个package中，以便于管理，形成模块 -->
                <package name="default" extends="struts-default">

                </package>
            </struts>
    3，Hibernate的配置文件：hibernate.cfg.xml
        1，对于MySQL数据库，（JBPM4要求）方言要配置为：org.hibernate.dialect.MySQL5InnoDBDialect
        2，配置如下：
            <!-- 方言 -->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
            <!-- 其他配置 -->
            <property name="show_sql">true</property>
            <property name="hbm2ddl.auto">update</property>
        3，说明：在这里不配置数据库连接信息，是在后面Spring中整合Hibernate时配置的（配置c3p0数据库连接池）。
    4，Spring的配置文件：applicationContext.xml
        1，声明如下：
            <?xml version="1.0" encoding="UTF-8"?>
            <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
                xmlns:tx="http://www.springframework.org/schema/tx"
                xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
        2，配置bean的自动扫描与装配
            <!-- 配置bean的自动扫描与装配 -->
            <context:component-scan base-package="cn.itcast.oa"></context:component-scan>
    5，Jbpm的配置文件：jbpm.cfg.xml

一些问题说明：
    如果使用JavaEE1.4，则可能会出现以下错误：
    1，Caused by: javax.xml.parsers.FactoryConfigurationError: Provider org.apache.xerces.jaxp.DocumentBuilderFactoryImpl not found
    2，Caused by: java.lang.NoClassDefFoundError: org/jboss/mx/util/PropertyAccess
    解决办法：使用JavaEE_5.0就可以了。
    3，${SPRING_HOME}/lib/j2eecommon-annotations.jar（如果是JDK6.0则不需要）

Struts2的dtd文件的位置：
{Struts2_Home}\src\core\src\main\resources

1，设计 BaseDao 与 BaseDaoImpl
    1，设计接口 BaseDao
        1，每个实体都应有一个对应的Dao接口，封装了对这个实体的数据库操作。例
            实体            Dao接口                实现类
            ========================================================
            User            --> UserDao            --> UserDaoImpl
            Role            --> RoleDao            --> RoleDaoImpl
            Department        --> DepartmentDao    --> DepartmentDaoImpl
            Article            --> ArticleDao        --> ArticleDaoImpl
            ...
        2，在每个Dao接口中都应有一个基本的增删改查的方法，
            但每个Dao接口中都写一遍就是重复的代码，可以把这些方法抽取到一个父接口中，定义为：
            public interface BaseDao<T> {
                save(entity : T) : void
                delete(id : Serializable) : void
                update(entity : T) :void
                getById(id : Serializable) : T
                getByIds(ids : Serializable[]) : List<T>
                findAll() : List<T>
            }
        3，说明：
            1，使用泛型的技术，可以在使用时更方便，如：User user = userDao.getById(1L); // 不需要强制转型
            2，getById(id : Long) 与 getByIds(ids : Long[]) 不要合并为一个有可变参数的方法，
                因为那个用起来就不方便了，比如要经常使用的根据一个id获取一个对象时就很不方便：
                List<User> list = userDao.getByIds(1L); User user = list.size() > 0 ? list.get(0) : null。
            3，以后再有Dao接口就可以继承这个 BaseDao，以拥有基本的增删改查方法，如：
                UserDao extends BaseDao<User>
                RoleDao extends BaseDao<Role>
    2，设计实现类 BaseDaoImpl
        1，每个Dao的接口还要有相应的实现类才可以，在每个DaoImpl中都要实现Dao接口中定义的所有方法，
            当然也包括公共的增删改查方法（BaseDao中定义的6个基本方法）。
        2，每个DaoImpl中都实现一遍公共方法显示是重复的，所以也可以抽取出来为一个父类BaseDaoImpl，
            在BaseDaoImpl中实现了BaseDao接口的所有方法，我们的DaoImpl只需要继承他就可以不用重复的写公共方法的实现了。
            声明如下：
                public class BaseDaoImpl<T> implements BaseDao<T> {
                    @Resource private SessionFactory sessionFactory; // 让Spring注入sessionFactory
                    private Class<T> clazz; // 要想办法得到T的Class

                    public void save(T entity) { }
                    public void delete(Long id) { }
                    public void update(T entity) { }
                    public T getById(Long id) { }
                    public List<T> getByIds(Long[] ids) { }
                    public List<T> findAll() { }
                }
            在实现方法时，获取Session的代码为：sessionFactory.getCurrentSession()
        3，在获取clazz时有两种方法
            1，方法一：
                1，把clazz声明成protected修饰符的，这样子类中就可以访问了，
                2，在每个子类的构造方法中传递这个属性的值，如：
                    public RoleDaoImpl() { clazz = Role.class; }
                    public UserDaoImpl() { clazz = User.class; }
            2，方法二：使用反射的方式：
                1，在BaseDaoImpl的默认构造方法中写如下代码就可以了：
                    ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
                    clazz = (Class) pt.getActualTypeArguments()[0];
                2，说明：BaseDaoImpl不能直接使用，只能使用他的子类，否则这段代码就无效了。

2，页面中的JS表单验证（使用jQuery.validate）
    1，基本用法
        1，导入JS文件
            <script type="text/javascript" src="lib/jquery.js"></script>
            <script type="text/javascript" src="lib/jquery.metadata.js"></script>
            <script type="text/javascript" src="jquery.validate.js"></script>
        2，指定哪个表单要在提交前要先进行验证
            $(function(){
                $("form").validate();
            })
        3，指定表单中字段的验证规则
            <input type="text" name="name" class="required" />
    2，指定验证规则的方式
        1，多个class之间使用空格隔开，如 class="required email"
        2，使用json方式，如 class="{required: true, minlength: 2}"
        3，混合方式一与方式二，如 class="required {minlength: 2}"
    3，内置的验证规则
        有很多，见文档
    4，修改提示消息
        1，默认提示
        2，针对某个表单的个性化提示
    5，修改提示消息的样式
        <style type="text/css">
            label.error{
                margin-left: 10px;
                color: red;
            }
        </style>

一，集成 Spring 与 Hibernate
为什么要整合？
    1.管理SessionFactory实例（只需要一个）
    2.声明式的事务处理

    1，配置SessionFactory
        1，配置
            ---------------------- applicationContext.xml ------------------------
            <!-- 配置SessionFactory（整合Hibernate） -->
            <context:property-placeholder location="classpath:jdbc.properties" />
            <bean id="sessionFactory"
                class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
                <property name="dataSource">
                    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource">
                        <!-- 数据库连接信息 -->
                        <property name="jdbcUrl" value="${jdbcUrl}"></property>
                        <property name="driverClass" value="${driverClass}"></property>
                        <property name="user" value="${username}"></property>
                        <property name="password" value="${password}"></property>
                        <!-- 其他配置 -->
                        <property name="initialPoolSize" value="3"></property>
                        <property name="maxPoolSize" value="5"></property>
                        <property name="minPoolSize" value="3"></property>
                        <property name="acquireIncrement" value="2"></property>
                        <property name="maxStatements" value="8"></property>
                        <property name="maxStatementsPerConnection" value="5"></property>
                        <property name="maxIdleTime" value="20"></property>
                    </bean>
                </property>
                <!-- 指定hibernate的配置文件的位置 -->
                <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
            </bean>
            ---------------------- jdbc.properties配置文件的内容 ------------------------
            jdbcUrl = jdbc:mysql:///itcastoa
            driverClass = com.mysql.jdbc.Driver
            username = root
            password = 1234
        2，测试代码
            @Test// 测试 SessionFactory 的配置
            public void testSessionFactory(){
                SessionFactory sessionFactory = (SessionFactory) ac.getBean("sessionFactory");
                Assert.assertNotNull(sessionFactory.openSession());
            }
    2，配置声明式事务（使用基于注解的方式）
        1，配置
            <!-- 配置事务管理器 -->
            <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
                <property name="sessionFactory" ref="sessionFactory"></property>
            </bean>
            <!-- 配置基于注解的事务支持-->
            <tx:annotation-driven transaction-manager="transactionManager"/>
        2，测试代码
            1，Service类
                @Service
                public class InsertUserService {
                    @Resource
                    private SessionFactory sessionFactory;
                    @Transactional
                    public void addUsers() {
                        sessionFactory.getCurrentSession().save(new User());
                        // int a = 1 / 0; // 这行会抛异常
                        sessionFactory.getCurrentSession().save(new User());
                    }
                }
            2，单元测试
                @Test // 测试声明式事务
                public void testTransaction() {
                    InsertUserService service = (InsertUserService) ac.getBean("insertUserService");
                    service.addUsers();
                }
    3，在web.xml中配置 spring 的 OpenSessionInView 过滤器（解决抛LazyInitializationException的问题）
        1，配置
            <!-- 配置 spring 的 OpenSessionInView 过滤器 -->
            <filter>
                <filter-name>OpenSessionInView</filter-name>
                <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
            </filter>
            <filter-mapping>
                <filter-name>OpenSessionInView</filter-name>
                <url-pattern>*.action</url-pattern>
            </filter-mapping>
        2，LazyInitializationException异常说明
            1，对于集合属性，默认是lazy="true"的，在第一次使用时才加载。
            2，但在加载时，如果Session已经关掉了就会抛LazyInitializationException异常

二，集成 Spring 与 Struts2.1.8.1

    为什么要与Spring整合？为了使用Spring容器管理Action
    spring 的特性：IOC可以管理bean对象，以及对象与对象之间的关系。AoP声明式的事务管理

    1，在web.xml配置监听器（Spring Reference 15.2 Common configuration）
        <!-- 集成Spring -->
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/classes/applicationContext*.xml</param-value>
        </context-param>
    2，拷贝一个用于整合的jar包（与Spring整合用的一个插件）
        struts-2.1.8.1/lib/struts2-spring-plugin-2.1.8.1.jar
    3，测试
        1，写Action类与Service类
            @Controller("testAction")
            @Scope("prototype")
            public class TestAction extends ActionSupport {
                @Resource
                private TestService testService;
                @Override
                public String execute(){
                    testService.saveTwoUser();
                    return SUCCESS;
                }
            }
            @Service
            public class TestService {
                @Resource
                private SessionFactory sessionFactory;
                @Transactional
                public void saveTwoUser() {
                    sessionFactory.getCurrentSession().save(new User());
                    // int a = 1 / 0; // 这行会抛异常
                    sessionFactory.getCurrentSession().save(new User());
                }
            }
        2，在struts.xml中配置Action
            <!-- 测试 -->
            <action name="test" class="testAction">
                <result>/test.jsp</result>
            </action>
        3，部署到Tomcat中并访问测试。

    4，说明：
        1，在写Action时要指定 @Controller 与 @Scope("prototype")
        2，在struts.xml中配置action时，在class属性中写bean的名称

log4j学习：需要下载slf4j：日志工具简介加入log4j: jar包：1.slf4j-api-1.6.1    2.slf4j-log4j12-1.6.1  3.log4j-1.2.15（Spring里面）

        配置信息：debug 调试信息 info一般信息 warn警告 error错误 fatal 严重的错误

三，整合Spring与Jbpm4（jBPM4.4 Developers Guide, Chapter 17. Spring Integration）
    1，在jbpm.cfg.xml中
        1，删除配置：
            <import resource="jbpm.tx.hibernate.cfg.xml" />
        2，增加配置：
            <!-- 整合Spring -->
            <import resource="jbpm.tx.spring.cfg.xml" />
    2，在applicationContext.xml中配置
        <!-- 配置ProcessEngine（整合jBPM4） -->
        <bean id="springHelper" class="org.jbpm.pvm.internal.processengine.SpringHelper">
            <!-- jbpmCfg是相对于classpath的相对路径，默认值为jbpm.cfg.xml -->
            <property name="jbpmCfg" value="jbpm.cfg.xml"></property>
        </bean>
        <bean id="processEngine" factory-bean="springHelper" factory-method="createProcessEngine" />
    3，测试
        @Test // 测试ProcessEngine
        public void testProcessEngine() {
            ProcessEngine processEngine = (ProcessEngine) ac.getBean("processEngine");
            Assert.assertNotNull(processEngine);
        }

struts2  原理图：

aaarticlea/png;base64,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" alt="" width="829" height="611" />

Dao层设计

aaarticlea/png;base64,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" alt="" />

1，新建工程，类型为Web Project，设置默认编码为UTF-8，并创建如下文件夹
    1，Source Folder
        1，src        项目源码
        2，config    配置文件
        3，test        单元测试
    2，普通文件夹
        1，WebRoot/style        css与图片等文件
        2，WebRoot/script        js脚本文件
        3，WebRoot/WEB-INF/jsp    jsp页面文件
    3，包结构
        1，实体
            cn.itcast.oa.domain
        2，Dao
            cn.itcast.oa.dao            Dao接口
            cn.itcast.oa.dao.impl        Dao实现类
        3，Service
            cn.itcast.oa.service        Service接口
            cn.itcast.oa.service.impl    Service实现类
        4，View(Struts2)
            cn.itcast.oa.strtus2.action    
        5，其他
            cn.itcast.oa.cfg            配置
            cn.itcast.oa.util            工具类
            ...

2，新建数据库，指定编码为UTF-8。
        
3，添加jar包（放在 WebRoot/WEB-INF/lib/ 下）
    1，环境为：JDK_1.6、JavaEE_5.0
    2，Junit-4.4：
        junit4.4.jar
    3，Struts-2.1.8.1：
        1，添加 ${Struts2_Home}/apps/struts2-blank-2.1.8.1.war/WEB-INF/lib/*.jar
        2，添加struts2-spring整合插件的jar：${Struts2_Home}/lib/struts2-spring-plugin-2.1.8.1.jar
    4，Hibernate-3.6：
        1，添加 ${HIBERNATE_HOME}/hibernate3.jar
        2，添加 ${HIBERNATE_HOME}/lib/required/*.jar
                ${HIBERNATE_HOME}/lib/jpa/hibernate-jpa-2.0-api-1.0.0.Final.jar
        3，添加 JDBC 驱动包，mysql-connector-java-5.1.5-bin.jar
        4，添加 slf4j-log4j12-1.5.8.jar、log4j-1.2.15.jar，
        5，添加 c3p0-0.9.1.2.jar
    5，Spring 2.5.6
        1，添加 ${SPRING_HOME}/dist/spring.jar
        2，添加 ${SPRING_HOME}/lib/aspectj/*.jar（共2个）
        3，添加 ${SPRING_HOME}/lib/cglib/cglib-nodep-2.1_3.jar
        5，添加 ${SPRING_HOME}/lib/jakarta-commons/commons-logging.jar（1.1.1版）
        6，添加工具jar包：commons-codec.jar，commons-lang.jar
    6，Jbpm 4.4（带了Hibernate 3.3.1的jar包与MySQL的JDBC驱动包，所以要把重复的包删除）
        1，添加 ${JBPM_HOME}/jpbm.jar
        2，添加 ${JBPM_HOME}/lib/*.jar，除了junit.jar、servlet-api.jar、cglib.jar
        3，注意：不要添加 cglib.jar，因为Spring中有更高版本的 cglib-nodep-2.1_3.jar
        4, 问题 启动Tomcat后，访问JSP时（使用的是MyEclipse自带的Tomcat，是6.0的版本），报错：
            Caused by: java.lang.LinkageError: loader constraints violated when linking javax/el/ExpressionFactory class
                at org.apache.jsp.WEB_002dINF.jsp.UserAction.loginUI_jsp._jspInit(loginUI_jsp.java:39)
                at org.apache.jasper.runtime.HttpJspBase.init(HttpJspBase.java:52)
                at org.apache.jasper.servlet.JspServletWrapper.getServlet(JspServletWrapper.java:159)
                at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:329)
                at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:320)
                at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:266)
                ... 40 more
                或
java.lang.LinkageError: loader constraint violation: when resolving interface method "javax.servlet.jsp.JspApplicationContext.getExpressionFactory()Ljavax/el/ExpressionFactory;" the class loader (instance of org/apache/jasper/servlet/JasperLoader) of the current class, org/apache/jsp/index_jsp, and the class loader (instance of org/apache/catalina/loader/StandardClassLoader) for resolved class, javax/servlet/jsp/JspApplicationContext, have different Class objects for the type javax/el/ExpressionFactory used in the signature
    org.apache.jsp.index_jsp._jspInit(index_jsp.java:23)
    org.apache.jasper.runtime.HttpJspBase.init(HttpJspBase.java:52)
    org.apache.jasper.servlet.JspServletWrapper.getServlet(JspServletWrapper.java:159)
    org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:329)
    org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:320)
    org.apache.jasper.servlet.JspServlet.service(JspServlet.java:266)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:803)
    org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.doFilter(StrutsPrepareAndExecuteFilter.java:88)

说明：原因是Jbpm的juel.jar, juel-engine.jar, juel-impl.jar包和Tomcat6.0中的el-api.jar包冲突了。
        有三个解决办法：
        1，方法一：换成tomcat5.5，就没有问题了。
        2，方法二：在MyEclipse的Preferences -> MyEclipse -> Application Servers -> Tomcat -> .. -> Paths 中配置 Append to classpath，选中 juel.jar, juel-engine.jar, juel-impl.jar 这三个jar包就可以了。
        3，方法三：将 juel.jar, juel-engine.jar, juel-impl.jar 这三个包复制到tomcat6下 lib/ 中，并删除原来的el-api.jar，
        切记还要把工程中 WEB-INF\lib 下的 juel.jar, juel-engine.jar, juel-impl.jar 删除，不然还是要冲突。

8，其他的jar包（在Spring中有）
        commons-codec.jar    含有MD5的工具类
        commons-lang.jar    java.lang包中有关类的工具类

提示：注意不要发生jar包冲突的问题。
    
4，配置文件（除web.xml外，都放在源码文件夹 conf/ 下）
    1，Log4j的配置文件：
        log4j.properties
    2，Strtus2的配置文件：
        1，MessageResources.properties
        2，在 web.xml 中配置Struts2的Filter：
            <!-- Struts2的配置 -->
            <filter>
                <filter-name>struts2</filter-name>
                <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
            </filter>
            <filter-mapping>
                <filter-name>struts2</filter-name>
                <url-pattern>/*</url-pattern>
            </filter-mapping>
        3，配置struts.xml（在default.properties找常量的配置）
            <?xml version="1.0" encoding="UTF-8" ?>
            <!DOCTYPE struts PUBLIC
                "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
                "http://struts.apache.org/dtds/struts-2.1.7.dtd">
            <struts>
                <!-- 设置开发模式 -->
                <constant name="struts.devMode" value="true" />
                <!-- 把action扩展名配置为action -->
                <constant name="struts.action.extension" value="action" />
                <!-- 指定主题使用simple（默认值为xhtml） -->
                <constant name="struts.ui.theme" value="simple" />
                <!-- 定义全局的国际化资源文件 -->
                <constant name="struts.custom.i18n.resources" value="MessageResources"></constant>

<!-- 可以把相关的action都放在一个package中，以便于管理，形成模块 -->
                <package name="default" extends="struts-default">

</package>
            </struts>
    3，Hibernate的配置文件：hibernate.cfg.xml
        1，对于MySQL数据库，（JBPM4要求）方言要配置为：org.hibernate.dialect.MySQL5InnoDBDialect
        2，配置如下：
            <!-- 方言 -->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
            <!-- 其他配置 -->
            <property name="show_sql">true</property>
            <property name="hbm2ddl.auto">update</property>
        3，说明：在这里不配置数据库连接信息，是在后面Spring中整合Hibernate时配置的（配置c3p0数据库连接池）。
    4，Spring的配置文件：applicationContext.xml
        1，声明如下：
            <?xml version="1.0" encoding="UTF-8"?>
            <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
                xmlns:tx="http://www.springframework.org/schema/tx"
                xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
        2，配置bean的自动扫描与装配
            <!-- 配置bean的自动扫描与装配 -->
            <context:component-scan base-package="cn.itcast.oa"></context:component-scan>
    5，Jbpm的配置文件：jbpm.cfg.xml

一些问题说明：
    如果使用JavaEE1.4，则可能会出现以下错误：
    1，Caused by: javax.xml.parsers.FactoryConfigurationError: Provider org.apache.xerces.jaxp.DocumentBuilderFactoryImpl not found
    2，Caused by: java.lang.NoClassDefFoundError: org/jboss/mx/util/PropertyAccess
    解决办法：使用JavaEE_5.0就可以了。
    3，${SPRING_HOME}/lib/j2eecommon-annotations.jar（如果是JDK6.0则不需要）

Struts2的dtd文件的位置：
{Struts2_Home}\src\core\src\main\resources