SSH框架学习

1.SSH框架的认知

        在做相关的java的网页的开发制作时，良好的层次分解是十分有比要的，所以我们在云涌第三方的框架之下来简化还有名了我们相关的网站的开发。
        SSH框架实则为Struct + spring + hibernate 的三个组成的，其中struct，专注与前台的相关的请求的所对应的ActionForm还有其相关跳转的Action来处理得到相关的JSP页面，从而来更新或是条状到相关用户的请求的服务页面，或是信息页面。而Hibernate的作用是体现在数据的持久化的层次中，我们对于页面，通过其特定的方式来对相关程序的数据惊醒I/O的持久化操作。在其次是相关spring的应用，是对与中间层次的相关的控制，处理相关业务的数据的依赖注入问题，还有就是融合其他的联大框架来实现相关程序的层次化的结构。

 

2.struct框架的使用

1.  在web.xml中进行配置，相关配置如下：
   1. <filter>  
   2.         <filter-name>SSH</filter-name>  
   3.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
   4.     </filter>  
   5.   
   6.     <filter-mapping>  
   7.         <filter-name>SSH</filter-name>  
   8.         <url-pattern>/*</url-pattern>  
   9.     </filter-mapping> 
2. Struct.xml的相关配置如下
   1. <?xml version="1.0" encoding="UTF-8" ?>  
   2. <!DOCTYPE struts PUBLIC  
   3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
   4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
   5.   
   6. <struts>  
   7.   
   8.     <include file="struts-default.xml" />  
   9.     <package name="ynwi" extends="struts-default">  
   10.         <action name="register" class="com.ynwi.ssh.action.RegisterAction">  
   11.             <result name="input">/Register.jsp</result>  
   12.             <result name="success">/Success.jsp</result>  
   13.             <result name="error">/Fail.jsp</result>  
   14.         </action>  
   15.     </package>  
   16.   
   17. </struts>
3. 其上两处的配置的做用时。当在browser中发出相关的请求时候，Struct会把相关的请求转到Struct的特定的filter中去，然后把数据映射到在struct.xml中所示的ActionForm中去，然后在更具配置吧，数据还有其他的相关的参数转交给相关的Action来做业务的处理，软后在更具结果进行跳转的。所以我们在Struct.xml中的相关的配置，实际上就是相关的请求所对应要使用到的ActionForm还有就是Action和相关跳转页面的配置。
4. 程序的书写代码如下：
   1. package com.ynwi.ssh.beans;  
   2.   
   3. public class UserForm {  
   4.   
   5.     private String username;  
   6.     private String password;  
   7.     private int gender;  
   8.   
   9.     public String getUsername() {  
   10.         return username;  
   11.     }  
   12.   
   13.     public void setUsername(String username) {  
   14.         this.username = username;  
   15.     }  
   16.   
   17.     public String getPassword() {  
   18.         return password;  
   19.     }  
   20.   
   21.     public void setPassword(String password) {  
   22.         this.password = password;  
   23.     }  
   24.   
   25.     public int getGender() {  
   26.         return gender;  
   27.     }  
   28.   
   29.     public void setGender(int gender) {  
   30.         this.gender = gender;  
   31.     }  
   32.   
   33. }  //相关的ActionForm类的书写范例。
5. 处理业务的书写如下：
   1. package com.ynwi.ssh.action;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;  
   4. import com.ynwi.ssh.beans.UserForm;  
   5. import com.ynwi.ssh.service.UserManager;  
   6. import com.ynwi.ssh.serviceImpl.UserManagerImpl;  
   7.   
   8. public class RegisterAction extends ActionSupport {  
   9.   
   10.     private static final long serialVersionUID = 1L;  
   11.   
   12.     private UserForm user;  
   13.   
   14.     private UserManager userManager;  
   15.   
   16.     public UserForm getUser() {  
   17.         return user;  
   18.     }  
   19.   
   20.     public void setUser(UserForm user) {  
   21.         this.user = user;  
   22.     }  
   23.   
   24.     public UserManager getUserManager() {  
   25.         return userManager;  
   26.     }  
   27.   
   28.     public void setUserManager(UserManager userManager) {  
   29.         this.userManager = userManager;  
   30.     }  
   31.   
   32.     public String execute() {  
   33.         try {  
   34.             this.setUserManager(new UserManagerImpl());  
   35.             userManager.regUser(user);  
   36.             return SUCCESS;  
   37.   
   38.         } catch (Exception e) {  
   39.             e.printStackTrace();  
   40.             return ERROR;  
   41.         }  
   42.     }  
   43.   
   44. }  //相关的Action的书写范例。
6. 以上便是struct的书写的范例。Struct的其原理可查询struct的官网站，或者是相关的文档。

3.Hibernate的使用

1. hibernate的相关的配置如下：
   1. <?xml version='1.0' encoding='utf-8'?>  
   2. <!DOCTYPE hibernate-configuration PUBLIC  
   3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
   4. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
   5.   
   6. <hibernate-configuration>  
   7.   <session-factory>  
   8.     <!-- Database connection settings -->  
   9.     <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  
   10.     <property name="connection.url">jdbc:mysql://localhost:3306/project</property>  
   11.     <property name="connection.username">root</property>  
   12.     <property name="connection.password">root</property>  
   13.   
   14.     <!-- JDBC connection pool (use the built-in) -->  
   15.     <!-- <property name="connection.pool_size">1</property> -->  
   16.   
   17.     <!-- SQL dialect -->  
   18.     <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
   19.   
   20.     <!-- Enable Hibernate's automatic session context management -->  
   21.     <!-- <property name="current_session_context_class">thread</property> -->  
   22.   
   23.     <!-- Disable the second-level cache  -->  
   24.     <!-- <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property> -->  
   25.   
   26.     <!-- Echo all executed SQL to stdout -->  
   27.     <property name="show_sql">true</property>  
   28.   
   29.     <!-- Drop and re-create the database schema on startup -->  
   30.     <!-- <property name="hbm2ddl.auto">update</property> -->  
   31.     <mapping resource="com/ynwi/ssh/beans/User.hbm.xml"/>  
   32.   </session-factory>  
   33. </hibernate-configuration>  
   34. //hibernate-configuration的相关的配置实际上就是配置县官的Hibernate的相关数据库ide链接用户名还有密码。同时还有一些相关的设置的问题。还有就是Mapping的配置（对象性的数据到关系型数据映射，例子见2）
2. mapping的配置：
   1. <?xml version="1.0" encoding='UTF-8'?>  
   2. <!DOCTYPE hibernate-mapping PUBLIC  
   3.                             "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
   4.                             "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  
   5.   
   6. <hibernate-mapping package="com.ynwi.ssh.beans">  
   7.     <class name="User" table="user">  
   8.         <id name="userId" column="userId">  
   9.             <generator class="native"></generator>  
   10.         </id>  
   11.         <property name="username" column="userName" type="java.lang.String"  
   12.             not-null="true" length="16"></property>  
   13.         <property name="password" column="password" type="java.lang.String"  
   14.             not-null="true" length="16" />  
   15.         <property name="gender" column="gender" type="java.lang.Integer" length="1" />  
   16.     </class>  
   17. </hibernate-mapping>
   18. //其中ID是变种对应的主键，而其他的为元素的应用。
   19. // 代码<generator class="native"></generator>说明将根据本地数据库的设置来创建userId，如MySQL中将表user的userId设置为自动增长，则在保存记录是，userId将自动增长。对于需要在程序中指定主键的值，则将generator的class属性设置为assigned。
3. 相关的代码书写如下：
   1. package com.ynwi.ssh.dao;  
   2.   
   3. import org.hibernate.HibernateException;  
   4. import org.hibernate.Session;  
   5.   
   6. public interface BaseDao {  
   7.   
   8.     public void saveObject(Object obj) throws HibernateException;  
   9.   
   10.     public Session getSession();  
   11.   
   12.     public void setSession(Session session);  
   13. }  
   14. //数据持久化曾的相关的接口。

 

1. package com.ynwi.ssh.daoImpl;  
2.   
3. import org.hibernate.HibernateException;  
4. import org.hibernate.Session;  
5.   
6. import com.ynwi.ssh.dao.BaseDao;  
7.   
8. public class UserDao implements BaseDao {  
9.   
10.     private Session session;  
11.   
12.     @Override  
13.     public Session getSession() {  
14.         return session;  
15.     }  
16.   
17.     @Override  
18.     public void setSession(Session session) {  
19.         this.session = session;  
20.     }  
21.   
22.     @Override  
23.     public void saveObject(Object obj) throws HibernateException {  
24.         session.save(obj);  
25.     }  
26.   
27. }  
28. //数据持久层的相关的实现。

 

 

1. package com.ynwi.ssh.daoImpl;  
2.   
3. import org.hibernate.HibernateException;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.hibernate.cfg.Configuration;  
7. import org.hibernate.service.ServiceRegistry;  
8. import org.hibernate.service.ServiceRegistryBuilder;  
9.   
10. public class HibernateSessionFactory {  
11.   
12.     private static final String CFG_FILE_LOCATION = "/Hibernate.cfg.xml";  
13.   
14.     private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();  
15.   
16.     private static final Configuration cfg = new Configuration()  
17.             .configure(CFG_FILE_LOCATION);  
18.   
19.     private static ServiceRegistryBuilder builder = new ServiceRegistryBuilder()  
20.             .applySettings(cfg.getProperties());  
21.   
22.     private static ServiceRegistry registry;  
23.   
24.     private static SessionFactory sessionFactory;  
25.   
26.     public static Session currentSession() throws HibernateException {  
27.         Session session = threadLocal.get();  
28.   
29.         if (session == null || session.isOpen() == false) {  
30.   
31.             if (sessionFactory == null) {  
32.                 try {  
33.                     registry = builder.buildServiceRegistry();  
34.                     sessionFactory = cfg.buildSessionFactory(registry);  
35.                 } catch (Exception e) {  
36.                     e.printStackTrace();  
37.                 }  
38.             }  
39.   
40.             session = sessionFactory.openSession();  
41.             threadLocal.set(session);  
42.   
43.         }  
44.   
45.         return session;  
46.     }  
47.   
48.     public static void closeSession() throws HibernateException {  
49.         Session session = threadLocal.get();  
50.         threadLocal.set(null);  
51.         if (session != null) {  
52.             session.close();  
53.         }  
54.     }  
55.   
56. }  
57. // 工厂类SessionFactory的内容。（这是使用Hibernate4时候的SessionFactory，Hibernate3时候sessionFactory的创建估计会不一样，请自行查阅。）

 

1. package com.ynwi.ssh.serviceImpl;  
2.   
3. import org.hibernate.HibernateException;  
4. import org.hibernate.Session;  
5. import org.hibernate.Transaction;  
6.   
7. import com.ynwi.ssh.beans.User;  
8. import com.ynwi.ssh.dao.BaseDao;  
9. import com.ynwi.ssh.daoImpl.HibernateSessionFactory;  
10. import com.ynwi.ssh.daoImpl.UserDao;  
11. import com.ynwi.ssh.forms.UserForm;  
12. import com.ynwi.ssh.service.UserManager;  
13.   
14. public class UserManagerImpl implements UserManager {  
15.   
16.     private BaseDao dao;  
17.   
18.     private Session session;  
19.   
20.     public UserManagerImpl() {  
21.         dao = new UserDao();  
22.     }  
23.   
24.     @Override  
25.     public void regUser(UserForm userForm) throws HibernateException {  
26.         session = HibernateSessionFactory.currentSession();  
27.         dao.setSession(session);  
28.         // 获取事务  
29.         Transaction ts = session.beginTransaction();  
30.         // 构造User对象  
31.         User user = new User();  
32.         user.setUsername(userForm.getUsername());  
33.         user.setPassword(userForm.getPassword());  
34.         user.setGender(userForm.getGender());  
35.         // 保存User对象  
36.         dao.saveObject(user);  
37.         // 提交事务  
38.         ts.commit();  
39.         // 关闭Session  
40.         HibernateSessionFactory.closeSession();  
41.     }  
42.   
43. }  
44. //相关的业务逻辑。

  4.Hibernate的总结：

       Hibernate实际上是在configuration方法的读取之下，得到相关的变量然后在通过此变量得到相关的sessionfactory类，通过SessionFactory类来读到会话类（Session）然后Session中的系列方法类进行数据库中的对应增，删，改，查的操作。当然session还可以开启事物的相关的操作。

 

4.Spring整合：

1. ApplicationContext.xml相关配置：
   1. <?xml version="1.0" encoding="UTF-8"?>  
   2. <beans xmlns="http://www.springframework.org/schema/beans"  
   3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
   4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
   5.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
   6.   
   7.     <!-- 定义数据源的信息 -->  
   8.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
   9.         destroy-method="close">  
   10.         <property name="driverClass">  
   11.             <value>com.mysql.jdbc.Driver</value>  
   12.         </property>  
   13.         <property name="jdbcUrl">  
   14.             <value>jdbc:mysql://localhost/project</value>  
   15.         </property>  
   16.         <property name="user">  
   17.             <value>root</value>  
   18.         </property>  
   19.         <property name="password">  
   20.             <value>root</value>  
   21.         </property>  
   22.         <property name="maxPoolSize">  
   23.             <value>80</value>  
   24.         </property>  
   25.         <property name="minPoolSize">  
   26.             <value>1</value>  
   27.         </property>  
   28.         <property name="initialPoolSize">  
   29.             <value>1</value>  
   30.         </property>  
   31.         <property name="maxIdleTime">  
   32.             <value>20</value>  
   33.         </property>  
   34.     </bean>  
   35.   
   36.     <!--定义Hibernate的SessionFactory -->  
   37.     <!-- SessionFactory使用的数据源为上面的数据源 -->  
   38.     <!-- 指定了Hibernate的映射文件和配置信息 -->  
   39.     <bean id="sessionFactory"  
   40.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
   41.         <property name="dataSource">  
   42.             <ref local="dataSource" />  
   43.         </property>  
   44.         <property name="mappingResources">  
   45.             <list>  
   46.                 <value>com/ynwi/ssh/beans/User.hbm.xml</value>  
   47.             </list>  
   48.         </property>  
   49.         <property name="hibernateProperties">  
   50.             <props>  
   51.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
   52.                 <prop key="show_sql">true</prop>  
   53.                 <prop key="hibernate.jdbc.batch_size">20</prop>  
   54.             </props>  
   55.         </property>  
   56.     </bean>  
   57.   
   58.     <bean id="transactionManager"  
   59.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
   60.         <property name="sessionFactory" ref="sessionFactory" />  
   61.     </bean>  
   62.   
   63.     <bean id="baseDao" class="com.ynwi.ssh.daoImpl.UserDao">  
   64.         <property name="sessionFactory">  
   65.             <ref bean="sessionFactory" />  
   66.         </property>  
   67.     </bean>  
   68.   
   69.     <!--用户注册业务逻辑类 -->  
   70.     <bean id="userManager" class="com.ynwi.ssh.serviceImpl.UserManagerImpl">  
   71.         <property name="dao">  
   72.             <ref bean="baseDao" />  
   73.         </property>  
   74.     </bean>  
   75.   
   76.     <!-- 用户注册的Action -->  
   77.     <bean id="regAction" class="com.ynwi.ssh.action.RegisterAction">  
   78.         <property name="userManager">  
   79.             <ref bean="userManager" />  
   80.         </property>  
   81.     </bean>  
   82.   
   83.     <!-- more bean definitions go here -->  
   84.   
   85. </beans>  
   86. //对于用户中的业务逻辑还有持久化操作的逻辑的相关类，我们放到spring的相关的容器中进行统一的管理。
2. 以上相关的修改结果如下（相对于之前的类来说）：BaseDao.java

    

   [java] view plaincopyprint?

   1. package com.ynwi.ssh.dao;  
   2.   
   3. import org.hibernate.HibernateException;  
   4.   
   5. public interface BaseDao {  
   6.   
   7.     public void saveObject(Object obj) throws HibernateException;  
   8.   
   9. }  
   UserDao.java

    

    

   [java] view plaincopyprint?

   1. package com.ynwi.ssh.daoImpl;  
   2.   
   3. import org.hibernate.HibernateException;  
   4. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
   5.   
   6. import com.ynwi.ssh.dao.BaseDao;  
   7.   
   8. public class UserDao extends HibernateDaoSupport implements BaseDao {  
   9.   
   10.     @Override  
   11.     public void saveObject(Object obj) throws HibernateException {  
   12.         getHibernateTemplate().save(obj);  
   13.     }  
   14.   
   15. }  

    //getHibernateTemplate（）：HibernateTemplate 提供非常多的常用方法来完成基本的操作，比如通常的增加、删除、修改、查询等操作，Spring 2.0更增加对命名SQL查询的支持，也增加对分页的支持。大部分情况下，使用Hibernate的常规用法，就可完成大多数DAO对象的CRUD操作。 下面是HibernateTemplate的常用方法简介： 

   q void delete(Object entity)：删除指定持久化实例 
   q deleteAll(Collection entities)：删除集合内全部持久化类实例 
   q find(String queryString)：根据HQL查询字符串来返回实例集合 
   q findByNamedQuery(String queryName)：根据命名查询返回实例集合 
   q get(Class entityClass, Serializable id)：根据主键加载特定持久化类的实例 
   q save(Object entity)：保存新的实例 
   q saveOrUpdate(Object entity)：根据实例状态，选择保存或者更新 
   q update(Object entity)：更新实例的状态，要求entity是持久状态 
   q setMaxResults(int maxResults)：设置分页的大小·····························································································································································在dao层用到getSession()方法来操作数据库记录，但是他还有个方法getHibernateTemplate()，这两个方法究竟有什么区别呢？

   1.使用getSession()方法你只要继承 sessionFactory，而使用getHibernateTemplate()方法必须继承HibernateDaoSupport当然包括 sessionFactory，这点区别都不是特别重要的，下面这些区别就很重要了

   2.getSession()方法是没有经过spring包装 的，spring会把最原始的session给你，在使用完之后必须自己调用相应的close方法，而且也不会对声明式事务进行相应的管理，一旦没有及时 关闭连接，就会导致数据库连接池的连接数溢出，getHibernateTemplate()方法是经过spring封装的，例如添加相应的声明式事务管 理，由spring管理相应的连接。

   在实际的使用过程中发现的确getHibernateTemplate()比getSession()方法要好很多，但是有些方法在getHibernateTemplate()并没有提供，这时我们用HibernateCallback 回调的方法管理数据库.

   例如如下代码：

   /**
        * 使用 hql 语句进行操作
        * @param hql HSQL 查询语句（使用回调函数访问外部变量，必须是final的）
        * @param offset 开始取数据的下标
       * @param length 读取数据记录数
       * @return List 结果集
   */
   public List getListForPage ( final String hql , final int offset , final int length ) {

                 List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {
                               public Object doInHibernate ( Session session ) throws HibernateException, SQLException {
                                               Query query = session.createQuery ( hql ) ;
                                               query.setFirstResult ( offset ) ;
                                               query.setMaxResults ( length ) ;
                                               List list = query.list ( ) ;
                                               return list ;
                              }
                  }) ;
                  return list ;
   }

   • 修改后的业务逻辑实现类UserManagerImpl的内容。

    

   [java] view plaincopyprint?

   1. package com.ynwi.ssh.serviceImpl;  
   2.   
   3. import org.hibernate.HibernateException;  
   4. import org.springframework.beans.BeanUtils;  
   5.   
   6. import com.ynwi.ssh.beans.User;  
   7. import com.ynwi.ssh.dao.BaseDao;  
   8. import com.ynwi.ssh.forms.UserForm;  
   9. import com.ynwi.ssh.service.UserManager;  
   10.   
   11. public class UserManagerImpl implements UserManager {  
   12.   
   13.     private BaseDao dao;  
   14.   
   15.     public void setDao(BaseDao dao) {  
   16.         this.dao = dao;  
   17.     }  
   18.   
   19.     @Override  
   20.     public void regUser(UserForm userForm) throws HibernateException {  
   21.         User user = new User();  
   22.         BeanUtils.copyProperties(userForm, user);  
   23.         dao.saveObject(user);  
   24.     }  
   25.   
   26. }  

    

   • 修改后的用户注册Action类RegisterAction的内容。

    

   [java] view plaincopyprint?

   1. package com.ynwi.ssh.action;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;  
   4. import com.ynwi.ssh.forms.UserForm;  
   5. import com.ynwi.ssh.service.UserManager;  
   6.   
   7. public class RegisterAction extends ActionSupport {  
   8.   
   9.     private static final long serialVersionUID = 1L;  
   10.   
   11.     private UserForm user;  
   12.   
   13.     private UserManager userManager;  
   14.   
   15.     public UserForm getUser() {  
   16.         return user;  
   17.     }  
   18.   
   19.     public void setUser(UserForm user) {  
   20.         this.user = user;  
   21.     }  
   22.   
   23.     public void setUserManager(UserManager userManager) {  
   24.         this.userManager = userManager;  
   25.     }  
   26.   
   27.     public String execute() {  
   28.         try {  
   29.             userManager.regUser(user);  
   30.             return SUCCESS;  
   31.   
   32.         } catch (Exception e) {  
   33.             e.printStackTrace();  
   34.             return ERROR;  
   35.         }  
   36.     }  
   37.   
   38. }  

    

   • 修改后的web.xml的内容。

    

   [html] view plaincopyprint?

   1. <?xml version="1.0" encoding="UTF-8"?>  
   2. <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
   3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
   4.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
   5.   
   6.     <display-name>SSH Project</display-name>  
   7.   
   8.     <filter>  
   9.         <filter-name>SSH</filter-name>  
   10.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
   11.     </filter>  
   12.   
   13.     <filter-mapping>  
   14.         <filter-name>SSH</filter-name>  
   15.         <url-pattern>/*</url-pattern>  
   16.     </filter-mapping>  
   17.   
   18.     <listener>  
   19.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
   20.     </listener>  
   21.   
   22.     <welcome-file-list>  
   23.         <welcome-file>index.html</welcome-file>  
   24.     </welcome-file-list>  
   25.   
   26. </web-app>  

    

   • 修改后的Struts配置文件struts.xml的内容。

    

   [html] view plaincopyprint?

   1. <?xml version="1.0" encoding="UTF-8" ?>  
   2. <!DOCTYPE struts PUBLIC  
   3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
   4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
   5.   
   6. <struts>  
   7.   
   8.     <include file="struts-default.xml" />  
   9.     <package name="ynwi" extends="struts-default">  
   10.         <action name="register" class="regAction">  
   11.             <result name="input">/Register.jsp</result>  
   12.             <result name="success">/Success.jsp</result>  
   13.             <result name="error">/Fail.jsp</result>  
   14.         </action>  
   15.     </package>  
   16.   
   17. </struts>  

5.总结

       有待改善。