`

ssh整合

阅读更多

最近看看SSH,从网上看到这篇文章,转过来收藏:

摘自 :  http://blog.csdn.net/czg18596/archive/2007/07/10/1684487.aspx

Struts+Spring+Hibernate练习(完整)
工具:
    Eclipse3.1、MyEclipse4.03、Tomcat5.5.9、Properties Editor插件、MySql4.1.13
 
新建工程:名称为 login
 
创建Struts框架
 
创建 index.jsp,增加一链接指向 login.jsp
 
按下Ctrl + N,创建 login.jsp、LoginAction,使用MyEclipse的向导就可以了,记得选对正确的版本
 
在ActionForm配置页中选择类型为动态Form,并继承于DynaValidatorForm,新增两个属性:username、password,在创建jsp文件打上钩,将路径改为/login.jsp,然后下一步,改LoginAction的Input source改为/login.jsp,点击完成
 
按下Ctrl + N 创建一个forwards,记得选对正确的版本
name 输入 indexGo
路径选择 /index.jsp
 
配置validator
先添加Struts插件,使用向导
Plugin class : org.apache.struts.validator.ValidatorPlugIn
Property : pathnames
Value : /WEB-INF/validator-rules.xml,/WEB-INF/validation.xml
这里需要两个xml文件
现在创建“validation.xml” 文件
 
在这里说明一点,我使用MyEclipse创建的Struts框架中缺少了validator-rules.xml文件,需要动拷贝到WEB-INF目录中
此文件可以到http://struts.apache.org/下载
 
文件内容如下:

xml 代码
  1. <form-validation>  
  2.  <formset>  
  3.   <form name="loginForm">  
  4.    <field property="username" depends="required">  
  5.     <arg0 key="prompt.username" />  
  6.    field>  
  7.    <field property="password" depends="required">  
  8.     <arg0 key="prompt.password" />  
  9.    field>  
  10.   form>  
  11.  formset>  
  12. form-validation>  

 
编辑资源文件“ApplicationResources.properties”
增加以下内容
 
prompt.username=User Name
prompt.password=User Password
errors.required={0} is required.
 
再创建中文件资源文件“ApplicationResources_zh_CN.properties”
增加以下内容
prompt.username=用户名称
prompt.password=登录密码
errors.required={0} 必需填写!
 
修改struts-config.xml文件
在以下位置增加绿色字体部份

xml 代码
  1. <action-mappings >  
  2.     <action  
  3.       attribute="loginForm"  
  4.       input="/login.jsp"  
  5.       name="loginForm"  
  6.       path="/login"  
  7.       scope="request"  
  8.       validate="true"  
  9.       type="com.test.struts.action.LoginAction" />  
  10.   action-mappings>  


 
这里说明提交的数据必需经过验证,而验证则是通过validator框架进行的。
 
修改LoginAction.java文件的execute方法,内容如下

java 代码
  1. public ActionForward execute(   
  2.   ActionMapping mapping,   
  3.   ActionForm form,   
  4.   HttpServletRequest request,   
  5.   HttpServletResponse response) {   
  6.   DynaValidatorForm loginForm = (DynaValidatorForm) form;   
  7.   String username=loginForm.getString("username");   
  8.   String password=loginForm.getString("password");   
  9.   if(username.equals("test")||password.equals("test")){   
  10.    return mapping.findForward("indexGo");   
  11.   }else{   
  12.    return mapping.getInputForward();   
  13.   }   
  14.  }  


 
现在再修改一下login.jsp
增加以下绿色字体部份
<!---->
 
其中charset=UTF-8 是使用UTF-8的字符编码,这也是为了支持国际化而使用的。
 
好了,现在可以启动Tomcat进行测试了
http://localhost/login/ 这里说明一下,我的Tomcat已经装端口号改为80了,所以就不必使用http://localhost:8080/login/这样的方法了。
 
如果不输入任何数据而直接提交表单的话就可以看到效果了。
 
好了,如果没有什么问题的话就继续往下看吧,如果有问题的话就得往上看了^_^
 
现在创建Spring框架了,在这里我将Spring所有的包全部加载进去,因为我还不知道具体用到哪些类,全部加进去方便点
 
单选框选第二个,这样的话所有的类库和标签等都将拷贝到项目中去,这样方便以后的布署
下一步后是创建配置文件,将文件放到“WebRoot/WEB-INF”目录下,文件名称为“applicationContext.xml”
 
 
配置struts-config.xml文件,添加(spring)的插件
 

xml 代码
  1.   
  2. <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">  
  3.     <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />  
  4.   plug-in>  
  5.    


 
修改LoginAction配置
 
原:

xml 代码
  1. <action  
  2.       attribute="loginForm"  
  3.       input="/login.jsp"  
  4.       name="loginForm"  
  5.       path="/login"  
  6.       scope="request"  
  7.       validate="true"  
  8.       type="com.test.struts.action.LoginAction" />  
  9.     
  10.   action-mappings>  


 
改为:

xml 代码
  1. <action  
  2.       attribute="loginForm"  
  3.       input="/login.jsp"  
  4.       name="loginForm"  
  5.       path="/login"  
  6.       scope="request"  
  7.       validate="true"  
  8.       type="org.springframework.web.struts.DelegatingActionProxy" />  
  9.   action-mappings>  


 
 
绿色字体部份为修改内容
这里将使用spring的代理器来对Action进行控制
 
当提交到/login.do是将控制权交给了spring,然后由spring来决定是否转回到struts的Action
 
现在来配置spring
 
<!---->
<!---->

xml 代码
  1. <!---->xml version="1.0" encoding="UTF-8"?>  
  2. <!---->>  
  3.     
  4. <beans>  
  5.  <bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">bean>  
  6. beans>  


 
<beans></beans>
 <bean class="com.test.struts.action.LoginAction" name="/login" singleton="false"></bean>

 
绿色字体是关于转交控制权的配置内容
 
属性singleton="false",指明了Action 的实例获取方式为每次重新创建。解决了Struts中令人诟病的线程安全问题(Struts中,由一个Action实例处理所有的请求,这就导致了类公用资源在并发请求中的线程同步问题。)(摘自spring开发指南)
 
这时如果你要进行测试也是可以的,不过为了省点时间就不进行测试了。
 
建立数据库在 这里我使用的是mysql4.1.13
 

sql 代码
  1. CREATE TABLE `user` (   
  2.   `ID` int(11) NOT NULL auto_increment,   
  3.   `USERNAME` varchar(50) NOT NULL default '',   
  4.   `PASSWORDvarchar(50) NOT NULL default '',   
  5.   PRIMARY KEY  (`ID`)   
  6. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;    

 
添加记录 insert into user (USERNAME,PASSWORD) values ('test','test')
 
创建Hibernate框架
在配置界面中配置数据库的连接部份,重要的是点击链接将jdbc拷贝到lib目录中
使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件
创建完成后可以将自动生成的hibernate.cfg.xml删除
 
创建UserDAO.java、UserDAOImp.java
UserDAO.java

java 代码
  1. public interface UserDAO {   
  2.    public abstract boolean isValidUser(String username, String password);   
  3. }   
  4.     
  5. UserDAOImp.java   
  6. import java.util.List;   
  7. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
  8. import com.test.Hibernate.SessionFactory;   
  9. public class UserDAOImp extends HibernateDaoSupport implements UserDAO {   
  10.     private SessionFactory sessionFactory;   
  11.     private static String hql = "from User u where u.username=? ";   
  12.     public boolean isValidUser(String username, String password) {   
  13.        List userList = this.getHibernateTemplate().find(hql, username);   
  14.        if (userList.size() > 0) {   
  15.            return true;   
  16.        }   
  17.        return false;   
  18.     }   
  19. }   
  20.     
  21. 修改LoginAction.java文件,使用userDao的方法来进行用户验证   
  22. package com.test.struts.action;   
  23.     
  24. import javax.servlet.http.HttpServletRequest;   
  25. import javax.servlet.http.HttpServletResponse;   
  26.     
  27. import org.apache.struts.action.Action;   
  28. import org.apache.struts.action.ActionForm;   
  29. import org.apache.struts.action.ActionForward;   
  30. import org.apache.struts.action.ActionMapping;   
  31. import org.apache.struts.validator.DynaValidatorForm;   
  32.     
  33. import com.test.UserDAO;   
  34.   
  35. public class LoginAction extends Action {   
  36.   
  37.  private UserDAO userDAO;   
  38.     
  39.  public UserDAO getUserDAO() {   
  40.   return userDAO;   
  41.  }   
  42.     
  43.  public void setUserDAO(UserDAO userDAO) {   
  44.   this.userDAO = userDAO;   
  45.  }   
  46.     
  47.  public ActionForward execute(ActionMapping mapping, ActionForm form,   
  48.    HttpServletRequest request, HttpServletResponse response) {   
  49.   DynaValidatorForm loginForm = (DynaValidatorForm) form;   
  50.   // TODO Auto-generated method stub   
  51.   String username = (String) loginForm.get("username");   
  52.   String password = (String) loginForm.get("password");   
  53.   loginForm.set("password"null);   
  54.   if (userDAO.isValidUser(username,password)) {   
  55.    return mapping.findForward("indexGo");   
  56.   } else {   
  57.    return mapping.getInputForward();   
  58.   }   
  59.  }   
  60. }   
  61.   

绿色字体为修改部份
 
现在剩下最后的spring配置了

xml 代码
  1. <!---->xml version="1.0" encoding="UTF-8"?>  
  2. <!---->>  
  3.     
  4. <beans>  
  5.  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  6.   <property name="driverClassName">  
  7.    <value>com.mysql.jdbc.Drivervalue>  
  8.   property>  
  9.   <property name="url">  
  10.    <value>jdbc:mysql://localhost/testvalue>  
  11.   property>  
  12.   <property name="username">  
  13.    <value>rootvalue>  
  14.   property>  
  15.   <property name="password">  
  16.    <value>rootvalue>  
  17.   property>  
  18.  bean>  
  19.     
  20.  <!---->  
  21.  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  22.   <property name="dataSource">  
  23.    <ref local="dataSource" />  
  24.   property>  
  25.   <property name="mappingResources">  
  26.    <list>  
  27.     <value>com/test/Hibernate/User.hbm.xmlvalue>  
  28.    list>  
  29.   property>  
  30.   <property name="hibernateProperties">  
  31.    <props>  
  32.     <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>  
  33.     <prop key="hibernate.show_sql">trueprop>  
  34.    props>  
  35.   property>  
  36.  bean>  
  37.     
  38.  <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  39.   <property name="sessionFactory">  
  40.    <ref local="sessionFactory" />  
  41.   property>  
  42.  bean>  
  43.     
  44.  <bean id="userDAO" class="com.test.UserDAOImp">  
  45.   <property name="sessionFactory">  
  46.    <ref local="sessionFactory" />  
  47.   property>  
  48.  bean>  
  49.     
  50.  <bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
  51.   <property name="transactionManager">  
  52.    <ref bean="transactionManager" />  
  53.   property>  
  54.   <property name="target">  
  55.    <ref local="userDAO" />  
  56.   property>  
  57.   <property name="transactionAttributes">  
  58.    <props>  
  59.     <prop key="insert*">PROPAGATION_REQUIREDprop>  
  60.     <prop key="get*">PROPAGATION_REQUIRED,readOnlyprop>  
  61.     <prop key="is*">PROPAGATION_REQUIRED,readOnlyprop>  
  62.    props>  
  63.   property>  
  64.  bean>  
  65.     
  66.  <bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">  
  67.   <property name="userDAO">  
  68.    <ref bean="userDAOProxy" />  
  69.   property>  
  70.  bean>  
  71. beans>  

 
现在可以进行测试了!
 
在编写代码有配置内容时一定要注意 hibernate 和 hibernate3 ,这两个包的名字就只差一个字,千万不要有错,否则找错误可是很难的。
2、
环境:Windows2003&jdk1.5.05&Eclipse3.1+MyEclipse4.03
 
做一登录练习。

现已经完成了login的struts部份,实现了动态ActionForm和动态validator验证,详细全部文件内容如下:


struts-config.xml

xml 代码
  1. <!---->xml version="1.0" encoding="UTF-8"?>  
  2. <!---->>    
  3.   
  4.  <struts-config>  
  5.   <data-sources />  
  6.   <form-beans >  
  7.     <form-bean name="loginForm" type="org.apache.struts.validator.DynaValidatorForm">  
  8.       <form-property name="password" type="java.lang.String" />  
  9.       <form-property name="username" type="java.lang.String" />  
  10.     form-bean>    
  11.   
  12.    form-beans>    
  13.   
  14.   <global-exceptions />  
  15.   <global-forwards >  
  16.     <forward name="indexGo" path="/index.jsp" />    
  17.  global-forwards>    
  18.   
  19.   <action-mappings >  
  20.     <action  
  21.       attribute="loginForm"  
  22.       input="/login.jsp"  
  23.       name="loginForm"  
  24.       path="/login"  
  25.       scope="request"  
  26.       validate="true"  
  27.       type="com.test.struts.action.LoginAction" />    
  28.  action-mappings>    
  29.   
  30.   <message-resources parameter="com.test.struts.ApplicationResources" />  
  31.   <plug-in className="org.apache.struts.validator.ValidatorPlugIn">  
  32.     <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />  
  33.   plug-in>  
  34. struts-config>    
  35.   

login.jsp

xml 代码
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"%>  
  2. <%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%>    
  3. <%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%>  
  4.     
  5. <html>    
  6.  <head>  
  7.   <title>JSP for loginForm formtitle>  
  8.  head>  
  9.  <body>  
  10.   <html:form action="/login">  
  11.    username : <html:text property="username"/><html:errors property="username"/><br/>  
  12.    password : <html:password property="password"/><html:errors property="password"/><br/>  
  13.    <html:submit/><html:cancel/>  
  14.   html:form>  
  15.  body>  
  16. html>   

 

java 代码

index.jsp

xml 代码
  1. <html>  
  2.   <head>  
  3.     <title>My JSP 'index.jsp' starting page</title>  
  4.   </head>  
  5.      
  6.   <body>  
  7.  <a href="login.jsp">Login</a>  
  8.   </body>  
  9. </html>   


LoginAction.java

java 代码
  1. //Created by MyEclipse Struts   
  2. // XSL source (default): platform:/plugin/com.genuitec.eclipse.cross.easystruts.eclipse_4.0.1/xslt/JavaClass.xsl    
  3.   
  4. package com.test.struts.action;    
  5.   
  6. import javax.servlet.http.HttpServletRequest;   
  7. import javax.servlet.http.HttpServletResponse;    
  8.   
  9. import&n
分享到:
评论

相关推荐

    ssh整合ssh整合ssh整合

    SSH整合主要指的是在软件开发中,Spring Security、Hibernate和Struts三个开源框架的集成应用。SSH框架整合可以构建高效、灵活且安全的企业级Web应用程序。下面将分别介绍SSH中的每一个框架及其整合的关键点。 1. ...

    SSH整合Jar包

    SSH整合在JavaWeb开发中是一项重要的技术组合,它包含了三个主要的开源框架:Spring、Struts和Hibernate。这些框架分别负责应用的业务逻辑管理、视图层控制和数据持久化。接下来,我们将深入探讨SSH整合的关键知识点...

    SSH整合jar包

    SSH整合jar包是一个集合了所有在Java开发中用于Spring、Struts和Hibernate(SSH)集成应用所需的库文件的压缩包。SSH是Java企业级开发中非常流行的一种框架组合,它能够帮助开发者快速构建高效、可维护的企业级Web...

    ssh整合jar包

    SSH整合是Java Web开发中的一种常见模式,它结合了Struts2、Spring和Hibernate三个开源框架,以实现高效、灵活的MVC(Model-View-Controller)架构。在这个"ssh整合jar包"中,包含了这三个框架的核心库和其他必要的...

    ssh整合所需要的jar包

    SSH整合,全称为Struts2、Spring和Hibernate的整合,是Java Web开发中常见的技术栈。这三种框架分别负责表现层、业务层和持久层的管理,通过合理的整合,可以构建出高效、灵活且易于维护的Web应用。下面将详细介绍...

    ssh整合所需所有架包

    SSH整合是Java开发中一种常见的框架集成方式,它结合了Struts2、Spring和Hibernate三个开源框架,以实现高效、灵活的企业级应用开发。这里提到的"ssh整合所需所有架包"是一个包含这三个框架相应版本的集合,确保它们...

    SSH整合增删改查全部

    SSH整合是Java Web开发中常见的一个技术组合,指的是Spring、Struts和Hibernate三个开源框架的集成。Spring提供了依赖注入和面向切面编程的能力,Struts则处理MVC(Model-View-Controller)架构中的控制器部分,而...

    SSH整合经典实例

    SSH整合经典实例主要涉及到的是Java开发中的三大框架:Spring、Struts和Hibernate的集成应用,这些框架在J2EE体系中被广泛使用,为开发者提供了高效、便捷的开发环境。SSH整合是Java企业级开发中一种常见的解决方案...

    SSH整合 银行管理系统

    SSH整合在IT行业中通常指的是Struts、Hibernate和Spring三大框架的集成应用,它们是Java Web开发中的重要组件,尤其在企业级应用系统中广泛应用。银行管理系统是一个典型的业务复杂、安全性要求高的应用场景,SSH...

    SSH整合的jar包.zip

    SSH整合是指Spring、Struts和Hibernate这三大开源框架的集成应用。这三种框架分别负责不同的职责:Spring作为应用的管理核心,提供依赖注入(DI)和面向切面编程(AOP);Struts则主要处理MVC(模型-视图-控制器)...

    SSH整合的一个案例

    SSH整合在IT行业中通常指的是Spring、Struts和Hibernate这三个开源框架的集成应用。Spring作为核心容器,负责管理对象(依赖注入DI)和事务处理;Struts则是MVC(Model-View-Controller)设计模式的实现,处理用户...

    SSH整合例子(SSH例子)

    SSH整合是Java开发中一种常见的框架组合,包括Spring、Struts和Hibernate三个核心组件。Spring提供了依赖注入(DI)和面向切面编程(AOP),Struts负责MVC模式的实现,而Hibernate则是用于对象关系映射(ORM)。在这...

    SSH整合小案例,实用性比较强

    SSH整合是软件开发中一种常见的技术实践,主要指的是Spring、Struts和Hibernate这三大开源框架的集成应用。这个小案例提供了SSH整合的具体实现,对于项目研发具有很高的实用价值。下面我们将详细探讨SSH整合的关键...

    ssh整合所需jar包

    SSH整合是指将Struts、Spring和Hibernate这三个Java开源框架结合在一起,用于构建高效、可维护的企业级Web应用程序。Struts提供了MVC(Model-View-Controller)架构,Spring强化了依赖注入和事务管理,而Hibernate则...

    SSH整合小项目

    SSH整合是Java Web开发中的一种常见技术栈,主要包括Spring、Struts和Hibernate这三个框架的集成。这个名为"SSH整合小项目"的资源提供了一个实践示例,帮助开发者理解和掌握这三大框架协同工作的机制。 首先,...

    SSH整合实例源码

    SSH整合是Java Web开发中的一个常见实践,它指的是Struts 2、Hibernate和Spring这三大框架的集成。这个"SSH整合实例源码"提供了一种实际应用这些框架的方法,帮助开发者理解如何在项目中有效地结合它们。以下是关于...

    ssh整合 jar包

    SSH整合是指在Java Web开发中,将Spring、Struts2和Hibernate这三大开源框架进行集成,以实现高效、灵活和可扩展的业务应用。这些框架分别负责不同的职责:Spring作为核心容器,管理对象的依赖注入;Struts2是MVC...

Global site tag (gtag.js) - Google Analytics