Structs+Spring+Hibernate快速入门

最新推荐文章于 2018-12-05 12:19:14 发布
最新推荐文章于 2018-12-05 12:19:14 发布
阅读量196 收藏
点赞数
文章标签： java 测试 web.xml
本文介绍了一个使用Structs+Spring+Hibernate的经典组合进行用户注册功能开发的实例，详细展示了从注册页面到业务逻辑的具体实现过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Structs+Spring+Hibernate，这是很经典的一个搭配，它的开发流程也比较程式化，下面以用户注册为例。
注册页面代码：
<%@pagecontentType="text/html;charset=GBK"%>
<html>
<head><title>Spring、Struts和Hibernate整合之用户注册</title></head>
<body>${msg}
<formname="user"action="/myHibernate/regedit.do"method="post">
用户名<inputtype="text"name="username"value="${user.username}"/><br>
密码<inputtype="password"name="password"value="${user.password}"/><br>
<inputtype="submit"name="method"value="提交"/>
</form>
</body>
</html>

实体Bean类：

packagecom.myHibernate.bean;
publicclassUser1{
//定义id
privateStringid=null;
//定义用户名
privateStringusername=null;
//定义密码
privateStringpassword=null;
//设定id
publicvoidsetId(Stringid){
this.id=id;
}
//获取id
publicStringgetId(){
returnthis.id;
}
//设定用户名
publicvoidsetUsername(Stringusername){
this.username=username;
}
//获取用户名
publicStringgetUsername(){
returnthis.username;
}
//设定密码
publicvoidsetPassword(Stringpassword){
this.password=password;
}
//获取密码
publicStringgetPassword(){
returnthis.password;
}

}
对应的映射文件User.hbm.xml:
<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mappingPUBLIC
"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mappingpackage="com.myHibernate.bean">
<classname="User"table="user">
<!--定义id-->
<idname="id"column="id">
<generatorclass="native"/>
</id>
<!--定义用户名-->
<propertyname="username"/>
<!--定义密码-->
<propertyname="password"/>
</class>
</hibernate-mapping>
用户DAO接口：

packagecom.myHibernate.dao;
importcom.myHibernate.bean.User;
publicinterfaceUserDAO{
//查询用户
publicabstractUserqueryUser(Stringname);
//新增用户
publicabstractvoidinsertUser(Useruser);
//修改用户
publicabstractvoidupdateUser(Useruser);
//删除用户
publicabstractvoiddeleteUser(Useruser);
}
用户DAO接口实现类：
packagecom.myHibernate.dao.impl;
importorg.hibernate.SessionFactory;
importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;

importcom.myHibernate.bean.User;
importcom.myHibernate.dao.UserDAO;
publicclassUserDAOImplextendsHibernateDaoSupportimplementsUserDAO{
privateSessionFactorysessionFactory;
privateStringhql="fromUseruwhereu.username=?";
//查询用户
publicUserqueryUser(Stringname){
Useruser=null;
//如果查询结果为空
if(this.getHibernateTemplate().find(hql,name)==null){
user=null;
}else{
//不为空时，取第一笔
user=(User)this.getHibernateTemplate().find(hql,name).get(0);
}
returnuser;
}
//新增用户
publicvoidinsertUser(Useruser){
this.getHibernateTemplate().save(user);
}
//修改用户
publicvoidupdateUser(Useruser){
this.getHibernateTemplate().update(user);
}
//删除用户
publicvoiddeleteUser(Useruser){
this.getHibernateTemplate().delete(user);
}
}

注册的业务逻辑接口：


packagecom.myHibernate.domain;
importcom.myHibernate.bean.User;
publicinterfaceRegedit{
//保存用户
publicabstractvoidsaveUser(Useruser);
//修改用户
publicabstractvoidupdateUser(Useruser);
//删除用户
publicabstractvoiddeleteUser(Useruser);
//获取是否保存成功的消息
publicabstractStringgetMsg();
}
注册的业务逻辑实现：

packagecom.myHibernate.domain.impl;

importcom.myHibernate.bean.User;
importcom.myHibernate.dao.UserDAO;
importcom.myHibernate.domain.Regedit;

publicclassRegeditImplimplementsRegedit{
privateStringmsg;
privateUserDAOuserDao;
//保存用户
publicvoidsaveUser(Useruser){
userDao.insertUser(user);
msg="保存成功";
}
//修改用户
publicvoidupdateUser(Useruser){
userDao.updateUser(user);
}
//删除用户
publicvoiddeleteUser(Useruser){
userDao.deleteUser(user);
}
//获取是否保存成功的消息
publicStringgetMsg(){
returnmsg;
}
/***//**
*@返回userDao
*/
publicUserDAOgetUserDao(){
returnuserDao;
}
/***//**
*@注入userDao
*/
publicvoidsetUserDao(UserDAOuserDao){
this.userDao=userDao;
}
}
用户注册控制器类：
packagecom.myHibernate.action;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
//导入struts包
importorg.apache.struts.action.Action;
importorg.apache.struts.action.ActionForm;
importorg.apache.struts.action.ActionForward;
importorg.apache.struts.action.ActionMapping;

importcom.myHibernate.bean.User;
importcom.myHibernate.domain.Regedit;
//继承action
publicclassRegeditActionextendsAction{
//定义接口Regedit
privateRegeditregedit;
//获取值
publicRegeditgetRegedit(){
returnregedit;
}
//依赖注入值
publicvoidsetRegedit(Regeditregedit){
this.regedit=regedit;
}
publicActionForwardexecute(ActionMappingmapping,ActionFormform,HttpServletRequestrequest,HttpServletResponseresponse)throwsException{
//获取用户提交的信息
Useruser=(User)form;
//保存用户提交的信息
getRegedit().saveUser(user);
//将用户提交的信息和是否保存成功的信息存放在request中
request.setAttribute("user",user);
request.setAttribute("msg",regedit.getMsg());
//返回页面
returnmapping.findForward("regedit");
}
}
下面是配置文件方面，首先是Hibernate的配置文件hibernate.cfg.xml，定义了访问数据库所需要的一些值：

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEhibernate-configurationPUBLIC
"-//Hibernate/HibernateConfigurationDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<propertyname="hibernate.connection.url">jdbc:mysql://localhost/myHibernate</property>
<propertyname="hibernate.connection.username">root</property>
<propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<propertyname="show_sql">true</property>
<mappingresource="com/myHibernate/bean/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>

然后是Spring的配置文件spring-config.xml：

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEbeansPUBLIC"-//SPRING//DTDBEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!--定义数据源-->
<beanid="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<!--设定驱动-->
<propertyname="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<!--设定url-->
<propertyname="url">
<value>jdbc:mysql://localhost/myHibernate</value>
</property>
<!--设定用户名-->
<propertyname="username">
<value>root</value>
</property>
</bean>
<!--通过org.springframework.orm.hibernate3.LocalSessionFactoryBean建立联系-->
<beanid="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<propertyname="dataSource">
<reflocal="dataSource"/>
</property>
<!--定义要使用的映射文件-->
<propertyname="mappingResources">
<list>
<value>com/myHibernate/bean/User.hbm.xml</value>
</list>
</property>
<!--定义要使用的方言和是否显示sql-->
<propertyname="hibernateProperties">
<props>
<propkey="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<propkey="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<!--这里添加对事务处理的支持，当然也可以不用-->
<beanid="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<propertyname="sessionFactory">
<reflocal="sessionFactory"/>
</property>
</bean>
<!--表示要将下面定义的userDao置于事务处理之下-->
<beanid="userDaoProxy"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<propertyname="transactionManager">
<refbean="transactionManager"/>
</property>
<!--要代理userDao-->
<propertyname="target">
<reflocal="userDao"/>
</property>
<!--定义不同情况下，事务处理的方式-->
<propertyname="transactionAttributes">
<props>
<propkey="create*">PROPAGATION_REQUIRED</prop>
<propkey="update*">PROPAGATION_REQUIRED</prop>
<propkey="delete*">PROPAGATION_REQUIRED</prop>
<propkey="query*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<!--定义userDao-->
<beanid="userDao"class="com.myHibernate.dao.impl.UserDAOImpl">
<propertyname="sessionFactory">
<reflocal="sessionFactory"/>
</property>
</bean>
<!--定义regedit，将UserDAO进行注入-->
<beanid="regedit"class="com.myHibernate.domain.impl.RegeditImpl">
<propertyname="userDao">
<reflocal="userDao"/>
</property>
</bean>
<!--定义login，将UserDAO进行注入-->
<beanid="login"class="com.myHibernate.domain.impl.LoginImpl">
<propertyname="userDao">
<reflocal="userDao"/>
</property>
</bean>
<!--定义和Struts相应的映射，将regedit进行注入-->
<beanname="/regedit"class="com.myHibernate.action.RegeditAction">
<propertyname="regedit">
<refbean="regedit"/>
</property>
</bean>
<!--定义和Struts相应的映射，将login进行注入-->
<beanname="/login"class="com.myHibernate.action.LoginAction">
<propertyname="login">
<refbean="login"/>
</property>
</bean>
</beans>
然后是Struts的配置文件struts-config.xml:

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEstruts-configPUBLIC"-//ApacheSoftwareFoundation//DTDStrutsConfiguration1.2//EN""http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd">
<struts-config><!--定义formbean--><form-beans><form-beanname="user"type="com.myHibernate.bean.User"/></form-beans>
<action-mappings>
<!--定义和SPring配置文件相同的路径-->
<actionpath="/regedit"type="org.springframework.web.struts.DelegatingActionProxy"name="user">
<forwardname="regedit"path="/jsp/regedit.jsp"/>
</action>
<!--定义初次访问时的路径-->
<actionpath="/input"
type="org.apache.struts.actions.ForwardAction"
parameter="/jsp/regedit.jsp"/>
<!--定义和SPring配置文件相同的路径-->
<actionpath="/login"
type="org.springframework.web.struts.DelegatingActionProxy"name="user">
<forwardname="login"path="/jsp/login.jsp"/>
</action>
<!--定义初次访问时的路径-->
<actionpath="/loginTemp"
type="org.apache.struts.actions.ForwardAction"
parameter="/jsp/login.jsp"/>
</action-mappings>
<!--注册ContextLoaderPlugIn插件-->
<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn">
<set-propertyproperty="contextConfigLocation"value="/WEB-INF/spring-config.xml"/>
</plug-in>
</struts-config>
最后是Web应用程序配置文件web.xml:
<?xmlversion="1.0"encoding="UTF-8"?>
<web-appversion="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>actionServlet</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<!--初始参数-->
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!--处理所有后缀为do的请求-->
<servlet-mapping>
<servlet-name>actionServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
可以看到，MVC的三层架构思路很清晰，但缺点也很明显，配置文件太过于冗杂，CRUD代码随处冗余，不够简约，下一篇文章中我们将见识到一个解决这个问题的优秀框架—SpringSide。



iteye_5736
关注
structs+hibernate
05-29
structs+hibernate实例2
Struts快速入门（五完）
冰云BLOG
05-13 1939
用FormTag初始化ActionForm对象       本节早前提到，HTML表单中动作URL被映射到一个配置，并轮流被映射到一个配置。FormTag中由action属性制定的URL被FormTag转换为一个在部署描述符中确定的路径结构URL。对于扩充的映射，这意味着资源扩展和指定的一样。因此，一个表单URL中 editCustomerProfile?customerType=prefer
Struts快速入门（二）
冰云BLOG
05-13 1877
Struts MVC 语义 我们从关键的Struts抽象概念开始，这是它MVC架构的核心。Struts使用Service to Worker模式实现了MVC模式。[Core] 控制器对象控制器被ActionServlet类所实现。它提供一个中心位置来处理全部的终端请求。这就为处理视图和导航管理的控制层提供了更为清晰的划分，把模型访问和操作留给专门的请求处理器。全部提交的请求被映
Struts+Spring+Hibernate整合入门详解
doliu6的专栏
08-06 6114
Java 5.0 Struts 2.0.9Spring 2.0.6Hibernate 3.2.4                                              作者：  Liu Liu 转载请注明出处基本概念和典型实用例子。一、基本概念       Str
Struts快速入门
白菜大爷的专栏
03-21 571
Struts快速入门     一、Struts快速入门案例 为什么要学习Struts呢？因为Web层jsp页面调用servlet过于繁琐，Apache组织开发了一套针对web层简化操作的框架，可以简化Web层的操作。 首先，我们了解了为什么要学习Struts后，我们先来用上Struts框架实现用户注册页面。 1、编写一个注册页面 2、把表单的注册请求交给struts处理 3、导入str
SSH框架组合实例：Structs2 + Spring + Hibernate入门
在MyEclipse中直接导入这样的项目，能够快速看到一个整合了Structs2、Spring和Hibernate的Web应用是如何配置和组织代码的。开发者可以通过这个例子来学习如何配置这些框架，如何编写Model、DAO、Service层的代码，...
MyEclipse 6 Java开发入门教程：Structs2+Spring2+Hibernate3
"MyEclipse 6 Java 开发中文教程，由刘长炯著，主要针对初学者，讲解了如何使用 MyEclipse 6 进行 Java 开发，并结合开源框架 Struts2、Spring2 和 Hibernate3 进行实践。教程包含从安装配置开发环境到实际应用的...
SSH整合 Struts2.1+Spring4.1+Hibernate4.1
09-15
这个“SSH整合 Struts2.1+Spring4.1+Hibernate4.1”是一个预配置的框架模板，适用于快速开发J2EE项目，特别是对于那些需要管理业务逻辑和持久层操作的复杂应用。 Struts2是MVC（模型-视图-控制器）架构的扩展，提供...
SPring+structs2+hibernate框架搭建
09-05
本文将详细介绍如何使用MyEclipse工具逐步搭建SSH（Spring+Struts2+Hibernate）框架环境，适用于初学者快速入门并掌握SSH框架的基本操作流程。通过本教程的学习，读者能够独立完成SSH框架的搭建，并对框架的基本原理...
spring+structs+Hibernate
09-23
使用ssh做的登陆Demo，简单明了的说明了spring structs Hibernate三者到底是怎么结合使用的。
SSH（struts+spring+hibernate）
10-27
SSH（Struts Spring Hibernate）Java三大框架的整合。
Struts快速入门教程
wxt1013的专栏
01-21 1002
规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国 规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国 规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国 规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国规格尴尴尬尬规格尴尴尬尬国国国规格尴尴尬尬国国国
一、Struts2快速入门
mChenys的博客
12-05 466
概述 Struts2是一个基于MVC设计模式的Web层框架,是Struts1的下一代产品,在 struts1和WebWork的技术基础上进行了合并的全新的Struts 2框架。 其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。 Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以...
struts2教程--快速入门
好好学java
04-18 1558
Struts2框架介绍 1、三大框架 ： 是企业主流 JavaEE 开发的一套架构 Struts2 + Spring + Hibernate 2、 什么是框架？为什么要学框架 ？ 框架 是 实现部分功能的代码 （半成品），使用框架简化企业级软件开发 学习框架 ，清楚的知道框架能做什么？ 还有哪些工作需要自己编码实现 ？ 3、 什么是Struts2 ？
SSH---Structs初级篇1
DavidWu88的专栏
11-16 508
一，structs简介 struts是一个web层框架，规范了MVC的开发方法，基于MVC的一个web框架。structs1.3的好处：1，程序更加规范化。2，开发效率提高。3，可读性提高。4，可维护性提升（规范统一开发流程，开发人员技能可复用）。缺点：1，表单比较鸡肋。2，action是单态。 二，structs原理 以用户登陆验证来讲解原理。 1，用户通过浏览器访
struts 快速入门教程地址
xfdxcy的专栏
06-30 463
   韩顺平 http://edu.51cto.com/lesson/id-6145.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值