Structs+Spring+Hibernate,这是很经典的一个搭配,它的开发流程也比较程式化,下面以用户注册为例。
    注册页面代码:

<%@page contentType="text/html;charset=GBK"%>

<html> 

<head><title>Spring、Struts和Hibernate整合之用户注册</title></head> 

<body>${msg}

    <form name="user" action="/myHibernate/regedit.do" method="post"> 

        用户名 <input type="text" name="username" value="${user.username}"/><br> 

密  码 <input type="password" name="password" value="${user.password}"/><br>

        <input type="submit" name="method" value="提交"/> 

    </form> 

</body> 

</html>

实体Bean类:

package com.myHibernate.bean;

public class User1 {

//    定义id

    private String id = null;

    //定义用户名

    private String username = null;

    //定义密码

    private String password = null;

    //设定id

    public void setId(String id) {

        this.id = id;

    }

    //获取id

    public String getId() {

        return this.id;

    }

    //设定用户名

    public void setUsername (String username) {

        this.username = username;

    }

    //获取用户名

    public String getUsername () {

        return this.username;

    }

    //设定密码

    public void setPassword (String password) {

        this.password = password;

    }

    //获取密码

    public String getPassword () {

        return this.password;

    }

}

对应的映射文件User.hbm.xml:

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.myHibernate.bean">

  <class name="User" table="user">

  <!--定义id-->   

  <id name="id" column="id">

            <generator class="native"/>

        </id>

      <!--定义用户名-->

      <property name="username"/>

      <!--定义密码-->   

      <property name="password"/>

  </class>

</hibernate-mapping>

用户DAO接口:

package com.myHibernate.dao;

import com.myHibernate.bean.User;

public interface UserDAO {

    //查询用户

    public abstract User queryUser(String name);

    //新增用户

    public abstract void insertUser(User user);

    //修改用户

    public abstract void updateUser(User user);

    //删除用户

    public abstract void deleteUser(User user);

}

用户DAO接口实现类:

package com.myHibernate.dao.impl;

import org.hibernate.SessionFactory;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.myHibernate.bean.User;

import com.myHibernate.dao.UserDAO;

public class UserDAOImpl extends HibernateDaoSupport implements UserDAO{

    private SessionFactory sessionFactory;

    private String hql = "from User u where u.username = ?";

    //查询用户

    public User queryUser(String name) {

        User user = null;

        //如果查询结果为空

        if (this.getHibernateTemplate().find(hql, name) == null ) {

            user = null;

        } else {

            //不为空时,取第一笔

            user = (User)this.getHibernateTemplate().find(hql, name).get(0);

        }

        return user;

    }

    //新增用户

    public void insertUser(User user) {

        this.getHibernateTemplate().save(user);

    }

    //修改用户

    public void updateUser(User user) {

        this.getHibernateTemplate().update(user);

    }

    //删除用户

    public void deleteUser(User user) {

        this.getHibernateTemplate().delete(user);

    }

}

注册的业务逻辑接口:


package com.myHibernate.domain;

import com.myHibernate.bean.User;

public interface Regedit {

    //保存用户

    public abstract void saveUser(User user);

    //修改用户

    public abstract void updateUser(User user);

    //删除用户

    public abstract void deleteUser(User user);

    //获取是否保存成功的消息

    public abstract String getMsg();

}

注册的业务逻辑实现:

package com.myHibernate.domain.impl;

import com.myHibernate.bean.User;

import com.myHibernate.dao.UserDAO;

import com.myHibernate.domain.Regedit;

public class RegeditImpl implements Regedit{

    private String msg;

    private UserDAO userDao;

    //保存用户

    public void saveUser(User user) {

        userDao.insertUser(user);

        msg = "保存成功";

    }

    //修改用户

    public void updateUser(User user) {

        userDao.updateUser(user);

    }

    //删除用户

    public void deleteUser(User user) {

        userDao.deleteUser(user);

    }

    //获取是否保存成功的消息

    public String getMsg() {

        return msg;

    }

    /**

     * @返回userDao

     */

    public UserDAO getUserDao() {

        return userDao;

    }

    /**

     * @注入userDao

     */

    public void setUserDao(UserDAO userDao) {

        this.userDao = userDao;

    }

}

用户注册控制器类:

package com.myHibernate.action;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

//导入struts包

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 com.myHibernate.bean.User;

import com.myHibernate.domain.Regedit;

//继承action    

public class RegeditAction extends Action {

    //定义接口Regedit

    private Regedit regedit;

    //获取值

      public Regedit getRegedit () {

            return regedit;

      }

      //依赖注入值

     public void setRegedit (Regedit regedit) { 

            this.regedit = regedit;

      }

    public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest  request, HttpServletResponse response)  throws Exception {   

        //获取用户提交的信息

        User user = (User)form;

        //保存用户提交的信息    

        getRegedit().saveUser(user);

        //将用户提交的信息和是否保存成功的信息存放在request中

        request.setAttribute("user", user);

        request.setAttribute("msg", regedit.getMsg());

        //返回页面

        return mapping.findForward("regedit");

    }

}

下面是配置文件方面,首先是Hibernate的配置文件hibernate.cfg.xml,定义了访问数据库所需要的一些值:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="hibernate.connection.url">jdbc:mysql://localhost/myHibernate</property>

        <property name="hibernate.connection.username">root</property>

        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <property name="show_sql">true</property>

        <mapping resource="com/myHibernate/bean/User.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

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

<?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>

       <!--设定url-->

       <property name="url">

           <value>jdbc:mysql://localhost/myHibernate</value>

       </property>

       <!--设定用户名-->

       <property name="username">

           <value>root</value>

       </property>

    </bean>

    <!--通过org.springframework.orm.hibernate3.LocalSessionFactoryBean建立联系-->

  <bean id="sessionFactory"

      class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

       <property name="dataSource">

           <ref local="dataSource" />

       </property>

       <!--定义要使用的映射文件-->

       <property name="mappingResources">

           <list>

              <value>com/myHibernate/bean/User.hbm.xml</value>

           </list>

       </property>

       <!--定义要使用的方言和是否显示sql-->

       <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.hibernate3.HibernateTransactionManager">

       <property name="sessionFactory">

           <ref local="sessionFactory" />

       </property>

    </bean>

    <!--表示要将下面定义的userDao置于事务处理之下-->

  <bean id="userDaoProxy"

      class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

     <property name="transactionManager">

         <ref bean="transactionManager" />

     </property>

     <!--要代理userDao-->

     <property name="target">

         <ref local="userDao" />

     </property>

    <!--定义不同情况下,事务处理的方式-->

     <property name="transactionAttributes">

         <props>

            <prop key="create*">PROPAGATION_REQUIRED</prop>

            <prop key="update*">PROPAGATION_REQUIRED</prop>

            <prop key="delete*">PROPAGATION_REQUIRED</prop>

            <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>

         </props>

     </property>

   </bean>

   <!--定义userDao-->

  <bean id="userDao" class="com.myHibernate.dao.impl.UserDAOImpl">

       <property name="sessionFactory">

           <ref local="sessionFactory" />

       </property>

  </bean>

    <!--定义regedit,将UserDAO进行注入-->

    <bean id="regedit" class="com.myHibernate.domain.impl.RegeditImpl">

        <property name="userDao">

           <ref local="userDao" />

       </property>

    </bean>

    <!--定义login,将UserDAO进行注入-->

    <bean id="login" class="com.myHibernate.domain.impl.LoginImpl">

        <property name="userDao">

           <ref local="userDao" />

       </property>

    </bean>

    <!--定义和Struts相应的映射,将regedit进行注入-->

    <bean name="/regedit" class="com.myHibernate.action.RegeditAction">

     <property name="regedit">

        <ref bean="regedit"/>

     </property>

    </bean>

    <!--定义和Struts相应的映射,将login进行注入-->

    <bean name="/login" class="com.myHibernate.action.LoginAction">

     <property name="login">

        <ref bean="login"/>

     </property>

    </bean>

</beans>

然后是Struts的配置文件struts-config.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd">

<struts-config><!--定义formbean--><form-beans><form-bean name="user" type="com.myHibernate.bean.User"/></form-beans>

    <action-mappings>

    <!--定义和SPring配置文件相同的路径-->

        <action path="/regedit" type="org.springframework.web.struts.DelegatingActionProxy" name="user">

            <forward name="regedit" path="/jsp/regedit.jsp"/>

        </action>

        <!--定义初次访问时的路径-->

        <action path="/input"

            type="org.apache.struts.actions.ForwardAction"

            parameter="/jsp/regedit.jsp"/>

        <!--定义和SPring配置文件相同的路径-->

        <action path="/login"

            type="org.springframework.web.struts.DelegatingActionProxy" name="user">

             <forward name="login" path="/jsp/login.jsp"/>

        </action>

        <!--定义初次访问时的路径-->

        <action path="/loginTemp"

            type="org.apache.struts.actions.ForwardAction"

            parameter="/jsp/login.jsp"/>

    </action-mappings>

    <!--注册ContextLoaderPlugIn插件-->

    <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

          <set-property property="contextConfigLocation" value="/WEB-INF/spring-config.xml" />

    </plug-in>

</struts-config>

最后是Web应用程序配置文件web.xml:

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="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。

Structs+Spring+Hibernate快速入门的更多相关文章

  1. spring boot入门教程——Spring Boot快速入门指南

    Spring Boot已成为当今最流行的微服务开发框架,本文是如何使用Spring Boot快速开始Web微服务开发的指南,我们将使创建一个可运行的包含内嵌Web容器(默认使用的是Tomcat)的可运 ...

  2. Spring Boot 快速入门

    Spring Boot 快速入门 http://blog.csdn.net/xiaoyu411502/article/details/47864969 今天给大家介绍一下Spring Boot MVC ...

  3. structs spring hibernate 三者之间有什么关系?

    现在开发流行MVC模式,structs在C(控制器)中使用:hibernate在M(模型)中被使用:至于 spring ,最大的作用在于,structs.hibernate的对象,由于在各个层之间相互 ...

  4. Spring Boot快速入门(二):http请求

    原文地址:https://lierabbit.cn/articles/4 一.准备 postman:一个接口测试工具 创建一个新工程 选择web 不会的请看Spring Boot快速入门(一):Hel ...

  5. Spring Cloud 快速入门

     Spring Cloud快速入门 代码地址: https://gitee.com/gloryxu/spring-cloud-test EureKa:服务注册中心 添加依赖 <dependenc ...

  6. (转)Hibernate快速入门

    http://blog.csdn.net/yerenyuan_pku/article/details/64209343 Hibernate框架介绍 什么是Hibernate 我们可以从度娘上摘抄这样有 ...

  7. Spring Boot 快速入门 史上最简单

    1.Spring Boot 概述 Spring Boot 是所有基于 Spring 开发的项目的起点.Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的 ...

  8. Struts+Spring+Hibernate整合入门详解

    Java 5.0 Struts 2.0.9 Spring 2.0.6 Hibernate 3.2.4 作者:  Liu Liu 转载请注明出处 基本概念和典型实用例子. 一.基本概念       St ...

  9. Spring Boot 快速入门(IDEA)

    从字面理解,Boot是引导的意思,因此SpringBoot帮助开发者快速搭建Spring框架:SpringBoot帮助开发者快速启动一个Web容器:SpringBoot继承了原有Spring框架的优秀 ...

随机推荐

  1. dbus 消息和消息总线实例讲解-一

    应用程序A和消息总线连接,这个连接获取了一个众所周知的公共名(记作连接A).应用程序A中有对象A1提供了接口I1,接口I1有方法M1. 应用程序B和消息总线连接,要求调用连接A上对象A1的接口I1的方 ...

  2. BZOJ1015或洛谷1197 [JSOI2008]星球大战

    BZOJ原题链接 洛谷原题链接 发现正着想毫无思路,所以我们可以考虑倒着思考,把摧毁变成建造. 这样很容易想到用并查集来维护连通块,问题也变的很简单了. 建原图,先遍历一遍所有边,若某条边的两端点未被 ...

  3. ps高级磨皮的7个步骤

    1.打开图片 2. 进入通道看红绿蓝哪个通道痘比较明显拖拽复制拷贝哪个通道! 3.选中拷贝的通道--执行滤镜--其他--高反差保留 4.在执行图像--计算(混合模式强光)--计算三次 5.选alpha ...

  4. 查看windows上次开机时间

    首先在电脑上找的[计算机]图标,点击鼠标右键弹出下拉菜单,在下拉菜单里找到[管理]选项 点击下拉菜单里的[管理]选项,弹出计算机管理界面,在左侧菜单栏里的系统工具里可以看到[事件查看器]菜单 点击[时 ...

  5. sock5协议转换http协议工具polipo使用笔记(Centos7)

    一.安装 Shadowsocks使用socks5协议,而终端很多工具目前只支持http和https等协议,所以我们为终端设置Shadowsocks的思路就是将socks5协议转换成http协议,然后为 ...

  6. python抢火车票 短信通知

    # -*- coding: utf-8 -*- from splinter.browser import Browser from time import sleep import traceback ...

  7. Noxim配置运行

    Noxim - the NoC Simulator that is implemented by SystemC 第一步: C++ compiler installation 第二步: YAML in ...

  8. MFC源码解读(一)最原始一个MFC程序,手写不用向导

    从这一篇开始,详细记录一下MFC的源码解读 四个文件,分别为: stdafx.h,stdafx.cpp,hello.h,hello.cpp 代码如下: //stdafx.h #include < ...

  9. elasticsearch之hello(spring data整合)

    1.书写pom.xml文件 <dependencies> <dependency> <groupId>org.springframework.data</gr ...

  10. 向jsp中引入公共文件

    前沿,在网页开发中,总会存在某几个.js或者某几个.css是所有.jsp文件的公用文件,为了方便引用 我们把这些在公共的.js及.css文件放到一个.jsp文件中,只需要将这个引入所有公共.js及.c ...