gsvince
- 浏览: 54712 次
- 性别:
- 来自: 深圳
-
文章分类
最新评论
-
nevergiveup3：
学习啦！讲的很细。
struts+hibernate+spring (整合使用) -
抛出异常的爱：
请排版....把代码用代码框框起来.
struts+hibernate+spring (整合使用) -
apojava：
我现在正在学习SSH,看了以后收获不小.
谢谢了!
struts+hibernate+spring (整合使用) -
williamy：
刚学java?
struts+hibernate+spring (整合使用)
Spring 和 Struts的整合使用
Spring 和 Struts的整合有3种方式：
1：通过Spring的ActionSupport类
2：通过Spring的DelegatingRequestProcessor类
3：通过Spring的DelegatingActionProxy类
a: 通过Spring的ActionSupport类:(对应工程：SpringStruts)
方法是Action类不再继承Struts的Action而是继承Spring提供的ActionSupport，
然后在Action中获得Spring的ApplicationContext.
缺点是Action和Spring耦合在一起，而且Action不在Spring控制之内。也不能处理多个动作在一个Action中的情况。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
4:创建Action时：
(1) 处，通过从 Spring 的 ActionSupport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action。
(2) 处，使用 getWebApplicationContext() 方法获得一个 ApplicationContext。为了获得业务服务，我使用在
(3) 处 查找一个 Spring bean。
//(1)
public class LoginAction extends ActionSupport {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
//(2)
ApplicationContext ac = this.getWebApplicationContext();//获得ApplicationContext
//(3)
LoginInterface li = (LoginInterface)ac.getBean("loginInterface");//获得Bean
boolean you = li.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
</beans>
b: 通过Spring的DelegatingRequestProcessor类:(对应工程：SpringStruts2)
方法是Spring的DelegatingRequestProcessor代替Struts的RequstProcessor，
把Struts的Action置于Spring的的控制之下
缺点是开发人员可以自己定义RequestProcessor这样就需要手工整合Struts和Spring。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<struts-config>
<form-beans >
<form-bean name="loginForm" type="com.yourcompany.struts.form.LoginForm" />
</form-beans>
<action-mappings >
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
type="com.yourcompany.struts.action.LogAction">
<forward name="show" path="/show.jsp" />
</action>
</action-mappings>
<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"></controller>
<message-resources parameter="com.yourcompany.struts.ApplicationResources" />
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
</struts-config>
4:创建Action时：
public class LogAction extends Action {
private LoginInterface logInterface;
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
boolean you = logInterface.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
public void setLogInterface(LoginInterface logInterface) {
this.logInterface = logInterface;
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
<!--要和Struts的路径对应-->
<bean name="/login" class="com.yourcompany.struts.action.LogAction">
<property name="logInterface">
<ref bean="loginInterface"/>
</property>
</bean>
</beans>
c: 通过Spring的DelegatingActionProxy类:(对应工程：SpringStruts3)
方法是Spring的DelegatingActionProxy代替Struts的Action，
把Struts的Action置于Spring的的控制之下
这种方式最灵活强大。并且它可以利用 Spring AOP 特性的优点。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<struts-config>
<data-sources />
<form-beans >
<form-bean name="loginForm" type="com.yourcompany.struts.form.LoginForm" />
</form-beans>
<action-mappings >
<action
attribute="loginForm"
input="/form/login.jsp"
name="loginForm"
path="/login"
scope="request"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="show" path="/show.jsp" />
</action>
</action-mappings>
<message-resources parameter="com.yourcompany.struts.ApplicationResources" />
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
</struts-config>
4:创建Action时：
public class LogAction extends Action {
private LoginInterface logInterface;
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
boolean you = logInterface.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
public void setLogInterface(LoginInterface logInterface) {
this.logInterface = logInterface;
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
<!--要和Struts的路径对应-->
<bean name="/login" class="com.yourcompany.struts.action.LogAction">
<property name="logInterface">
<ref bean="loginInterface"/>
</property>
</bean>
</beans>
-----------------------------------------------------------------------------------------------
Struts(1.1) + Spring + Hibernate(2.1)的整合使用
开发工具:Eclipse3.1,MyEclipse4.0 ,Tomcat5.0.28,mysql-4.0.18
开发步骤：
1：创建web projectSSHlogin 加入struts1.1
创建loginForm选择DynaValidatorForm，加入password，username，创建jsp文件打上钩，将路径改为/login.jsp，然后下一步，改LoginAction的Input source改为/login.jsp，加入 <forward name="ok" path="ok.jsp" />点击完成
完成后修改struts-config.xml文件加入
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
</plug-in>
拷贝validator-rules.xml和validation.xml到WEB-INF目录中 在validation.xml文件中加入
<form-validation>
<formset>
<form name="loginForm">
<field property="username" depends="required">
<arg0 key="prompt.username" />
</field>
<field property="password" depends="required">
<arg0 key="prompt.password" />
</field>
</form>
</formset>
</form-validation>
validator-rules.xml文件直接考一个就行。
编辑资源文件“ApplicationResources.properties”
增加以下内容
prompt.username=User Name
prompt.password=User Password
errors.required={0} is required.
修改LoginAction.java文件的execute方法，内容如下
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
DynaValidatorForm loginForm = (DynaValidatorForm) form;
String username=loginForm.getString("username");
String password=loginForm.getString("password");
if(username.equals("test")||password.equals("test")){
return mapping.findForward("indexGo");
}else{
return mapping.getInputForward();
}
}
好了，现在可以启动Tomcat进行测试了如果不输入任何数据而直接提交表单的话就可以看到效果了。
好了，如果没有什么问题的话就继续往下看吧，如果有问题的话就得往上看了^_^
2：加入Spring框架
在这里我将Spring所有的包全部加载进去，因为我还不知道具体用到哪些类，全部加进去方便点
单选框选第二个，这样的话所有的类库和标签等都将拷贝到项目中去，这样方便以后的布署
下一步后是创建配置文件，将文件放到“WebRoot/WEB-INF”目录下，文件名称为“applicationContext.xml”
配置struts-config.xml文件，添加（spring）的插件
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
</plug-in>
修改LoginAction配置
原：
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="com.test.struts.action.LoginAction" >
<forward name="ok" path="ok.jsp" />
</action>
</action-mappings>
改为：
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="ok" path="ok.jsp" />
</action>
</action-mappings>
这里将使用spring的代理器来对Action进行控制
当提交到/login.do是将控制权交给了spring，然后由spring来决定是否转回到struts的Action
现在来配置spring
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false"></bean>
</beans>
好了，现在可以启动Tomcat进行测试了如果没有什么问题的话就继续往下看吧，如果有问题的话就得往上看了^_^
3：创建Hibernate框架 hiberante2.1
建立数据库在 这里我使用的是mysql4.1.18
CREATE TABLE `user` (
`ID` int(11) NOT NULL auto_increment,
`USERNAME` varchar(50) NOT NULL default '',
`PASSWORD` varchar(50) NOT NULL default '',
PRIMARY KEY (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
添加记录 insert into user (USERNAME,PASSWORD) values ('test','test')
在配置界面中配置数据库的连接部份，重要的是点击链接将jdbc驱动拷贝到lib目录中
使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件
创建UserDAO.java、UserDAOImp.java
UserDAO.java：
public interface UserDAO {
public abstract boolean isValidUser(String username, String password);
}
UserDAOImp.java：
import java.util.List;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
public class UserDAOImp extends HibernateDaoSupport implements UserDAO {
private static String hql = "from User u where u.username=? and password=?";
public boolean isValidUser(String username, String password) {
String[] userlist=new String[2];
userlist[0]=username;
userlist[1]=password;
List userList = this.getHibernateTemplate().find(hql,userlist);
if (userList.size() > 0) {
return true;
}
return false;
}
}
修改LoginAction.java文件，使用userDao的方法来进行用户验证
package com.test.struts.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.validator.DynaValidatorForm;
import com.test.UserDAO;
public class LoginAction extends Action {
private UserDAO userDAO;
public UserDAO getUserDAO() {
return userDAO;
}
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
DynaValidatorForm loginForm = (DynaValidatorForm) form;
// TODO Auto-generated method stub
String username = (String) loginForm.get("username");
String password = (String) loginForm.get("password");
loginForm.set("password", null);
if (userDAO.isValidUser(username,password)) {
return mapping.findForward("ok");
} else {
return mapping.getInputForward();
}
}
}
现在剩下最后的spring配置了
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/newdb</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value></value>
</property>
</bean>
<!-- 配置sessionFactory, 注意这里引入的包的不同 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>hibernate/po/St.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAO" class="com.test.UserDAOImp">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="target">
<ref local="userDAO" />
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
<property name="userDAO">
<ref bean="userDAOProxy" />
</property>
</bean>
</beans>
!!!
配置sessionFactory也可以写成：
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="configLocation">
<value>hibernate.cfg.xml</value>
</property>
</bean>
现在可以进行测试了！
注意要把spring-hibernate.jar或者把spring.jar加到工程lib里[b][/b]
Spring 和 Struts的整合有3种方式：
1：通过Spring的ActionSupport类
2：通过Spring的DelegatingRequestProcessor类
3：通过Spring的DelegatingActionProxy类
a: 通过Spring的ActionSupport类:(对应工程：SpringStruts)
方法是Action类不再继承Struts的Action而是继承Spring提供的ActionSupport，
然后在Action中获得Spring的ApplicationContext.
缺点是Action和Spring耦合在一起，而且Action不在Spring控制之内。也不能处理多个动作在一个Action中的情况。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
4:创建Action时：
(1) 处，通过从 Spring 的 ActionSupport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action。
(2) 处，使用 getWebApplicationContext() 方法获得一个 ApplicationContext。为了获得业务服务，我使用在
(3) 处 查找一个 Spring bean。
//(1)
public class LoginAction extends ActionSupport {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
//(2)
ApplicationContext ac = this.getWebApplicationContext();//获得ApplicationContext
//(3)
LoginInterface li = (LoginInterface)ac.getBean("loginInterface");//获得Bean
boolean you = li.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
</beans>
b: 通过Spring的DelegatingRequestProcessor类:(对应工程：SpringStruts2)
方法是Spring的DelegatingRequestProcessor代替Struts的RequstProcessor，
把Struts的Action置于Spring的的控制之下
缺点是开发人员可以自己定义RequestProcessor这样就需要手工整合Struts和Spring。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<struts-config>
<form-beans >
<form-bean name="loginForm" type="com.yourcompany.struts.form.LoginForm" />
</form-beans>
<action-mappings >
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
type="com.yourcompany.struts.action.LogAction">
<forward name="show" path="/show.jsp" />
</action>
</action-mappings>
<controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"></controller>
<message-resources parameter="com.yourcompany.struts.ApplicationResources" />
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
</struts-config>
4:创建Action时：
public class LogAction extends Action {
private LoginInterface logInterface;
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
boolean you = logInterface.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
public void setLogInterface(LoginInterface logInterface) {
this.logInterface = logInterface;
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
<!--要和Struts的路径对应-->
<bean name="/login" class="com.yourcompany.struts.action.LogAction">
<property name="logInterface">
<ref bean="loginInterface"/>
</property>
</bean>
</beans>
c: 通过Spring的DelegatingActionProxy类:(对应工程：SpringStruts3)
方法是Spring的DelegatingActionProxy代替Struts的Action，
把Struts的Action置于Spring的的控制之下
这种方式最灵活强大。并且它可以利用 Spring AOP 特性的优点。
步骤：
1：加入spring.
2: 加入struts
3：修改struts配置文件struts-config.xml文件注册ContextLoaderPlugIn插件。
<struts-config>
<data-sources />
<form-beans >
<form-bean name="loginForm" type="com.yourcompany.struts.form.LoginForm" />
</form-beans>
<action-mappings >
<action
attribute="loginForm"
input="/form/login.jsp"
name="loginForm"
path="/login"
scope="request"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="show" path="/show.jsp" />
</action>
</action-mappings>
<message-resources parameter="com.yourcompany.struts.ApplicationResources" />
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
</plug-in>
</struts-config>
4:创建Action时：
public class LogAction extends Action {
private LoginInterface logInterface;
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
LoginForm loginForm = (LoginForm) form;
// TODO Auto-generated method stub
boolean you = logInterface.checkUser(loginForm.getName(),loginForm.getPassword());
if(you){
request.setAttribute("msg","welcome");
return mapping.findForward("show");
}
else{
request.setAttribute("msg","failed");
return mapping.findForward("show");
}
}
public void setLogInterface(LoginInterface logInterface) {
this.logInterface = logInterface;
}
}
applicationContext.xml:
<beans>
<bean id="loginInterface" class="spring.LoginImp"/>
<!--要和Struts的路径对应-->
<bean name="/login" class="com.yourcompany.struts.action.LogAction">
<property name="logInterface">
<ref bean="loginInterface"/>
</property>
</bean>
</beans>
-----------------------------------------------------------------------------------------------
Struts(1.1) + Spring + Hibernate(2.1)的整合使用
开发工具:Eclipse3.1,MyEclipse4.0 ,Tomcat5.0.28,mysql-4.0.18
开发步骤：
1：创建web projectSSHlogin 加入struts1.1
创建loginForm选择DynaValidatorForm，加入password，username，创建jsp文件打上钩，将路径改为/login.jsp，然后下一步，改LoginAction的Input source改为/login.jsp，加入 <forward name="ok" path="ok.jsp" />点击完成
完成后修改struts-config.xml文件加入
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
</plug-in>
拷贝validator-rules.xml和validation.xml到WEB-INF目录中 在validation.xml文件中加入
<form-validation>
<formset>
<form name="loginForm">
<field property="username" depends="required">
<arg0 key="prompt.username" />
</field>
<field property="password" depends="required">
<arg0 key="prompt.password" />
</field>
</form>
</formset>
</form-validation>
validator-rules.xml文件直接考一个就行。
编辑资源文件“ApplicationResources.properties”
增加以下内容
prompt.username=User Name
prompt.password=User Password
errors.required={0} is required.
修改LoginAction.java文件的execute方法，内容如下
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
DynaValidatorForm loginForm = (DynaValidatorForm) form;
String username=loginForm.getString("username");
String password=loginForm.getString("password");
if(username.equals("test")||password.equals("test")){
return mapping.findForward("indexGo");
}else{
return mapping.getInputForward();
}
}
好了，现在可以启动Tomcat进行测试了如果不输入任何数据而直接提交表单的话就可以看到效果了。
好了，如果没有什么问题的话就继续往下看吧，如果有问题的话就得往上看了^_^
2：加入Spring框架
在这里我将Spring所有的包全部加载进去，因为我还不知道具体用到哪些类，全部加进去方便点
单选框选第二个，这样的话所有的类库和标签等都将拷贝到项目中去，这样方便以后的布署
下一步后是创建配置文件，将文件放到“WebRoot/WEB-INF”目录下，文件名称为“applicationContext.xml”
配置struts-config.xml文件，添加（spring）的插件
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
</plug-in>
修改LoginAction配置
原：
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="com.test.struts.action.LoginAction" >
<forward name="ok" path="ok.jsp" />
</action>
</action-mappings>
改为：
<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="org.springframework.web.struts.DelegatingActionProxy">
<forward name="ok" path="ok.jsp" />
</action>
</action-mappings>
这里将使用spring的代理器来对Action进行控制
当提交到/login.do是将控制权交给了spring，然后由spring来决定是否转回到struts的Action
现在来配置spring
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false"></bean>
</beans>
好了，现在可以启动Tomcat进行测试了如果没有什么问题的话就继续往下看吧，如果有问题的话就得往上看了^_^
3：创建Hibernate框架 hiberante2.1
建立数据库在 这里我使用的是mysql4.1.18
CREATE TABLE `user` (
`ID` int(11) NOT NULL auto_increment,
`USERNAME` varchar(50) NOT NULL default '',
`PASSWORD` varchar(50) NOT NULL default '',
PRIMARY KEY (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
添加记录 insert into user (USERNAME,PASSWORD) values ('test','test')
在配置界面中配置数据库的连接部份，重要的是点击链接将jdbc驱动拷贝到lib目录中
使用MyEclipse的数据Database Explorer工具创建User.hmb.xml、AbstractUser.java、User.java映射文件
创建UserDAO.java、UserDAOImp.java
UserDAO.java：
public interface UserDAO {
public abstract boolean isValidUser(String username, String password);
}
UserDAOImp.java：
import java.util.List;
import org.springframework.orm.hibernate.support.HibernateDaoSupport;
public class UserDAOImp extends HibernateDaoSupport implements UserDAO {
private static String hql = "from User u where u.username=? and password=?";
public boolean isValidUser(String username, String password) {
String[] userlist=new String[2];
userlist[0]=username;
userlist[1]=password;
List userList = this.getHibernateTemplate().find(hql,userlist);
if (userList.size() > 0) {
return true;
}
return false;
}
}
修改LoginAction.java文件，使用userDao的方法来进行用户验证
package com.test.struts.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.validator.DynaValidatorForm;
import com.test.UserDAO;
public class LoginAction extends Action {
private UserDAO userDAO;
public UserDAO getUserDAO() {
return userDAO;
}
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
DynaValidatorForm loginForm = (DynaValidatorForm) form;
// TODO Auto-generated method stub
String username = (String) loginForm.get("username");
String password = (String) loginForm.get("password");
loginForm.set("password", null);
if (userDAO.isValidUser(username,password)) {
return mapping.findForward("ok");
} else {
return mapping.getInputForward();
}
}
}
现在剩下最后的spring配置了
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/newdb</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value></value>
</property>
</bean>
<!-- 配置sessionFactory, 注意这里引入的包的不同 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>hibernate/po/St.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAO" class="com.test.UserDAOImp">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>
<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="target">
<ref local="userDAO" />
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
<property name="userDAO">
<ref bean="userDAOProxy" />
</property>
</bean>
</beans>
!!!
配置sessionFactory也可以写成：
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
<property name="configLocation">
<value>hibernate.cfg.xml</value>
</property>
</bean>
现在可以进行测试了！
注意要把spring-hibernate.jar或者把spring.jar加到工程lib里[b][/b]
分享到：
评论
4 楼
nevergiveup3
2008-04-03
学习啦！讲的很细。
3 楼
抛出异常的爱
2008-01-14
请排版....
把代码用代码框框起来.
把代码用代码框框起来.
2 楼
apojava
2008-01-14
我现在正在学习SSH,看了以后收获不小.
谢谢了!
谢谢了!
1 楼
williamy
2007-12-15
刚学java?
发表评论
相关推荐
精通J2EE——Eclipse+Struts+Hibernate+Spring整合应用案例 pdf电子书, 包含所有18个章节的完整版, 美中不足的是扫描质量不是很高,且是第一版的,不是目前最新的第二版! 请看清楚了再下,免得后悔! 共有两个部分-这...
如何整合这4个开源框架进行J2EE开发，如何基于MyEclipseIDE进行开发，J2EE开发的基础和基础环境搭配，Struts、Hibernate、Spring、Eclipse四个框架的使用，如何整合Struts+Hibernate+Spring+Eclipse框架。...
《开发者突击:Java Web主流框架整合开发(J2EE+Struts+Hibernate+Spring)》详细介绍了Java Web软件架构中的各种开发技术。主要内容包括：以MySQL为数据库、Tomcat为Web服务器、Eclipse为开发工具、CVS为版本控制工具...
Struts 2+Hibernate+Spring整合开发技术详解sample.pdf
Struts2+Hibernate+Spring整合开发技术详解19章网上书店完整源码（内附数据库导出文件） 与书上最后一章内容完全对应 可以结合书上教程进行最后一章学习
本光盘是《整合Struts+Hibernate+Spring应用开发详解》一书的配书光盘，书中的代码按章存放， 即第二章所使用的代码放在codes文件夹的02文件夹下，依次类推。 本光盘根目录下有11个文件夹,其内容和含义说明如下： ...
本光盘是《整合Struts+Hibernate+Spring应用开发详解》一书的配书光盘，书中的代码按章存放， 即第二章所使用的代码放在codes文件夹的02文件夹下，依次类推。 本光盘根目录下有11个文件夹,其内容和含义说明如下： ...
【基于Struts+Hibernate+Spring的用户管理系统】是一种常见的企业级Web应用架构，它整合了三个主流的Java技术框架，以构建高效、可维护性高的系统。Struts提供了MVC（Model-View-Controller）设计模式，使得业务逻辑...
开发者突击:Java Web主流框架整合开发(J2EE+Struts+Hibernate+Spring)(第2版)的完整版本，带封面和目录、前言，一共六个压缩文件，这是第6个。
Struts、Hibernate和Spring的整合使用，形成了SSH框架，它提供了强大的功能和灵活性，可以实现复杂的业务逻辑。例如，Spring的AOP可以用于日志记录、权限控制等跨切面需求，进一步提升系统的可维护性和安全性。 7. ...
总的来说，"Struts+Hibernate+Spring整合项目之登录部分"涉及到Java Web开发中的多个核心技术点，包括MVC架构的理解、ORM工具的使用、依赖注入的实践以及安全机制的实施。通过这个项目的实现，开发者可以深入理解...
library_ssh2可能是一个包含系统源代码的压缩文件，"ssh2"可能表示系统使用了Struts2、Spring2和Hibernate2这三个框架的早期版本。这个文件中应包含所有必要的Java源代码、配置文件、Web应用相关的资源（如JSP页面、...
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
Struts2、Hibernate和Spring是Java企业级应用中三大核心框架，它们的整合使用能够构建出高效、可维护性高的Web应用程序。本篇将深入剖析这三者如何协同工作，并提供实际范例应用。 首先，Struts2作为MVC（模型-视图...
Struts、Hibernate和Spring是Java开发中的三大框架，它们各自负责不同的职责，组合起来可以构建出高效、松耦合的企业级应用。SSH整合是指将这三个框架进行集成，以实现MVC（模型-视图-控制器）架构的完整解决方案。 ...
JavaWeb整合开发王者归JSP+Servlet+Struts+Hibernate+Spring共分五部分。这是第三部分。
**Spring整合Struts** Spring整合Struts主要有三种方式： 1. **使用Spring的ActionSupport**：Action类直接继承自Spring的ActionSupport，通过`super.getWebApplicationContext()`获取Spring上下文，然后通过`...
SSH（Struts2+Spring+Hibernate）框架整合是Java Web开发中常见的一种技术栈，能有效地提高开发效率和代码质量。 Struts2作为MVC框架，主要负责处理HTTP请求，控制应用程序的流程，提供视图和控制器的分离。它的...
Java Web整合开发实战--基于Struts 2+Hibernate+Spring.pdf 1章 Web的工作机制 2章 搭建Java Web开发环境 3章 JSP及其相关技术 2篇 表现层框架Struts技术 4章 Struts快速上手 5章 解密Struts之核心文件 6章 ...