码迷,mamicode.com
首页 > 编程语言 > 详细

springMVC学习(S2SH整合)

时间:2015-05-03 09:22:28      阅读:300      评论:0      收藏:0      [点我收藏+]

标签:springmvc   hibernate   structs2   s2sh   

前面几篇博客学习了spring中IOC,和springAOP以及spring通过jdbc操作数据库的方法。我们的目标是学习springMVC,那么在正式学习springMVC之前呢,我还是想到先写一篇文章来讲解S2SH整合吧,这样大家简单了解了structs2,对于后面学习springMVC也是有很大好处的。
我们先来整合spring和hibernate吧,我这里新建一个web工程叫做ssh。

第一步

将spring和hibernate需要的jar文件添加到WEB-INFO下的lib目录中。需要的jar文件如下:
hibernate3.jar
hibernate-jpa-2.0-api-1.0.0.Final.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
spring.jar
commons-logging.jar
log4j-1.2.15.jar
mysql-connector-java-3.0.10-stable-bin.jar
commons-dbcp.jar
commons-pool.jar

第二步

创建实体类和映射对象,这里我依然通过一个user实体来操作,因此我需要新建一个Userinfo实体类,如下:
    package com.test.entity;

import java.io.Serializable;

public class Userinfo implements Serializable {
    private int uid;
    private String uname;
    private String upass;

    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public String getUpass() {
        return upass;
    }
    public void setUpass(String upass) {
        this.upass = upass;
    }
}
这里,由于UserInfo实体类,以后会在网络上传输,所以需要实现Serializable接口。然后需要创建对应的实体类映射,我们需要在实体类同样的包下,新建一个Userinfo.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.test.entity.Userinfo" table="userinfo">
        <id name="uid" column="uid">
            <generator class="native"></generator>
        </id>
        <property name="uname"></property>
        <property name="upass"></property>
    </class>
</hibernate-mapping>  
这里class标签中的name的值就是需要映射的实体类的全类名,table的值就是数据库中该实体类对应的表的名称,有一个id,标签,就是该userinfo表所对应的主键,这里我们逐渐的生成测试采用"native",该中方式可以根据不同的底层数据库采用不同的主键生成方式,说明一下genernator的属性吧。
在hibernate中genernator的属性一共有七种,我们来看几个常用的:
1.identity用于mysql数据库的递增,注意需要在mysql中建表的时候将对应的字段设置为auto_increment
2.sequence用于orecale数据库
3.native  跨数据库时候使用,屏蔽了底层的方言
4.assigned 用户自定义id
5.foreign 用于外键关联时候使用
6.increment 用于为long,short,int类型生成唯一的表示,在高并发下不能使用
<property name="uname"></property>
<property name="upass"></property>
表示实体类对应到表中的字段,name表示实体类中的属性,如果我们不为该property标签指定column=""属性,那么对应的userinfo表中的字段名称和类中的属性名是相同的,如果指定了column="",比如<property name="uname" column="t_uname"></property> 此时userinfo表中uname属性对应的字段名称就叫做"t_uname"

第三步

编写dao以及实现类,用来操作数据库的(dao需要集成HibernateDaoSupport),首先编写一个UserinfoDao的接口:
    package com.test.dao;

import java.util.List;

import com.test.entity.Userinfo;

public interface UserinfoDao {
    public int addUserinfo(Userinfo user);
    public int updateUserinfo(Userinfo user);
    public int deleteUserinfo(int uid);
    public List<Userinfo> getAll();
    public Userinfo getUserinfoById(int uid);
}
可以看到,在该接口中定义了"增删改查"四个方法,然后编写UserinfoDao的实现类,UserinfoDaoImpl.java
    package com.test.dao.impl;

import java.util.List;

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

import com.test.dao.UserinfoDao;
import com.test.entity.Userinfo;

public class UserinfoDaoImpl extends HibernateDaoSupport implements UserinfoDao {

    public int addUserinfo(Userinfo user) {
        int count=0;
        try {
            this.getHibernateTemplate().save(user);
            count=1;
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return count;
    }

    public int deleteUserinfo(int uid) {
        int count=0;
        Userinfo user = getUserinfoById(uid);
        try {
            this.getHibernateTemplate().delete(user);
            count=1;
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return count;
    }

    public List<Userinfo> getAll() {
        return this.getHibernateTemplate().find("from Userinfo");
    }

    public Userinfo getUserinfoById(int uid) {
        return (Userinfo)this.getHibernateTemplate().get(Userinfo.class, uid);
    }

    public int updateUserinfo(Userinfo user) {
        int count=0;
        try {
            this.getHibernateTemplate().update(user);
            count=1;
        } catch (DataAccessException e) {
            e.printStackTrace();
        }
        return count;
    }
}
我们可以看到通过this.getHibernateTemplate();就可以得到HibernateTemplate 对象,然后通过该对象操作数据库是很方便的,HibernateTemplate 为我们提供的方法,我们只需要将对应的实体类,或该实体类的id传进去就可以操作数据库了,大大的提高了开发效率。
下面我写一个UserinfoBiz接口,并且让UserinfoBizImpl实现该接口同时在UserinfoBizImpl中声明一个UserInfoDao的属性,并且设置set方法,这样做是为了后边将UserInfoDao通过IOC注入给UserinfoBizImpl。
package com.test.biz;

import java.util.List;
import com.test.entity.Userinfo;

public interface UserinfoBiz {
    public int addUserinfo(Userinfo user);
    public int updateUserinfo(Userinfo user);
    public int deleteUserinfo(int uid);
    public List<Userinfo> getAll();
    public Userinfo getUserinfoById(int uid);
}
package com.test.biz.impl;

import java.util.List;

import com.test.biz.UserinfoBiz;
import com.test.dao.UserinfoDao;
import com.test.entity.Userinfo;

public class UserinfoBizImpl implements UserinfoBiz {
    private UserinfoDao userDao;

    public void setUserDao(UserinfoDao userDao) {
        this.userDao = userDao;
    }

    public int addUserinfo(Userinfo user) {
        return userDao.addUserinfo(user);
    }

    public int deleteUserinfo(int uid) {
        return userDao.deleteUserinfo(uid);
    }

    public List<Userinfo> getAll() {
        return userDao.getAll();
    }

    public Userinfo getUserinfoById(int uid) {
        return userDao.getUserinfoById(uid);
    }

    public int updateUserinfo(Userinfo user) {
        return userDao.updateUserinfo(user);
    }
}

第四步

创建spring容器,配置数据源和sessionFactory,在src下新建spring的配置文件applicationContext.xml配置数据源。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
            <!-- 驱动名称 -->
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <!-- url -->
            <property name="url" value="jdbc:mysql://localhost:3306/mydb?useUnicode=true&amp;characterEncoding=UTF-8"></property>
            <!-- 用户名 -->
            <property name="username" value="root"></property>
            <!-- 密码 -->
            <property name="password" value="root"></property>
        </bean>
</beans>
接下来配置sessionFactory,并将datasource注入:
    <!-- 配置sessionFactory,注入dataSource -->
        <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
            <!-- 注入dataSource -->
            <property name="dataSource" ref="dataSource"></property>
            <!-- 引入映射文件的位置 -->
            <property name="mappingResources">
                <list>
                    <value>com/test/entity/Userinfo.hbm.xml</value>
                </list>
            </property>
            <property name="hibernateProperties">
                <props>
                    <prop key="hibernate.show_sql">true</prop>
                    <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                </props>
            </property>
        </bean>
在org.springframework.orm.hibernate3.LocalSessionFactoryBean中有一个dataSource属性,<property name="dataSource" ref="dataSource"></property>就是将上面配置的dataSource注入给该属性。
<property name="mappingResources">
    <list>
        <value>com/test/entity/Userinfo.hbm.xml</value>
    </list>
</property>
mappResources,就是映射所有的实体类到数据库中的,注意这里是一个list,由于我们现在只有一个UserInfo,所以只写了这么一个,这里value的值,是实体类对应的映射文件的路径。
<property name="hibernateProperties">
    <props>
        <prop key="hibernate.show_sql">true</prop>
        <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
    </props>
</property>
hibernateProperties配置的是数据库的方言,即hibernate.dialect的值。这里是mysql的方言。hibernate.show_sql的值是true表示在程序运行期间是否打印sql语句,在开发调试期间最好打开,这样便于观察生成的sql语句是否正常。
 接下来需要配置Dao,并将sessionFactory注入:
<!-- 配置Dao,并注入sessionFactory -->
<bean id="userDao" class="com.test.dao.impl.UserinfoDaoImpl">
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>
这里整个过程和spring的IOC配置是一样的,其实这里就是spring的ioc配置,最后需要配置Biz,并将Dao注入。
<!-- 配置Biz,并注入Dao -->
<bean id="userBiz" class="com.test.biz.impl.UserinfoBizImpl">
    <property name="userDao" ref="userDao"></property>
</bean>
这里,因为我在UserinfoBizImpl类中声明了userDao属性,并且为该属性设置了set方法,可以通过spring来为其赋值,这里我是通过ref引用上一步定义的userDao,可以发现我们整个过程都是一步一步通过IOC赋值的:
dataSource-->sessionFactory-->Dao-->Biz
此时,万事俱备,只欠东风,新建一个dataSource中配置的数据库mydb,然后新建一个userinfo表,该表有三个字段uid,uname,upass,注意建表的时候字段类型需要和实体类中对应哦。创建好了表以后,就可以编写测试类来测试我们的spring和hbiernate整合是否成功。
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserinfoBiz userBiz = (UserinfoBiz)ac.getBean("userBiz");
        Userinfo user = new Userinfo();
        user.setUname("bb");
        user.setUpass("123");
        userBiz.addUserinfo(user);
        List<Userinfo> list = userBiz.getAll();
        for (Userinfo userinfo : list) {
            System.out.println(userinfo.getUid()+"\t"+userinfo.getUname()+"\t"+userinfo.getUpass());
        }
这里,我首先插入一条记录到userinfo表中,然后调用getAll()查询所有数据,打印如下:
Hibernate: insert into userinfo (uname, upass) values (?, ?)
Hibernate: select userinfo0_.uid as uid0_, userinfo0_.uname as uname0_, userinfo0_.upass as     upass0_ from userinfo userinfo0_
1   bb  123
可以看到,这时查询所用的sql语句也一并给我们打印出来了,此时spring和hibernate整合就成功了,可是有时候在对数据库进行增删改查的时候,难免会需要使用事物,接下来我们就来配置hibernate事物。
<!-- 配置声明式事务 -->
<!-- 配置事务管理器,注入sessionFactory -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"></property>
</bean>     
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="*" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <!-- 定义切入点 -->
        <aop:pointcut expression="execution(* com.test.biz.*.*(..))" id="bizMethods"/>
        <!-- 将事务通知和切入点告知给通知者 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="bizMethods"/>
    </aop:config>
配置hibernate事物主要有一下几步:
1.配置事务管理器,注入sessionFactory
2.配置事务通知
3.定义切入点,将事务通知和切入点告知给通知者
在配置事物通知的时候,我将以add,update,delete开头的方法是必须开启事物的,另外一个"*"表示如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行,propagation有一下一些值:
REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启
SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行
MANDATORY: 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常
REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起
NOT_SUPPORTED: 总是非事务地执行,并挂起任何存在的事务
NEVER: 总是非事务地执行,如果存在一个活动事务,则抛出异常
NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按                  TransactionDefinition.PROPAGATION_REQUIRED 属性执行

<aop:pointcut expression="execution(* com.test.biz.*.*(..))" id="bizMethods"/>
这里我们的切入点是com.test.biz包下的所有方法,在说一遍吧:
第一个"*"表示方法的返回值类型
第二个"*"表示类名
第三个"*"表示方法名
第四个".."表示方法中存在0个或者多个参数。
记住,添加aop所需要的jar:aspectjrt.jar,aspectjweaver.jar
此时hibernate的事物就配置好了,此时当我运行add,update,delete方法时都会开启事物,如果操作失败,事物将会回滚。接下来就是将struts2整合进来拉。
同样将strust2整合进来,

第一步 ##

首先需要添加struts2的jar文件:
commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar
commons-lang3-3.1.jar
commons-logging-1.1.1.jar
freemarker-2.3.19.jar
javassist-3.11.0.GA.jar
ognl-3.0.5.jar
sqljdbc.jar
struts2-core-2.3.4.1.jar
struts2-dojo-plugin-2.3.4.1.jar
xwork-core-2.3.4.1.jar
同时需要添加struts2和spring整合的jar:struts2-spring-plugin-2.3.4.1.jar,有一些jar在spring和hibernate整合的时候已经添加过了,这里就不需要重复添加了,否则可能引起jar包冲突。

第二步

在web.xml中配置struts2的核心过滤器和ContextLoaderListener
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- 加载spring的配置文件 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 指定spring配置文件的位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:applicationContext.xml</param-value>
    </context-param>
    <!-- OSIVFilter:解决hibernate懒加载问题 -->
    <filter>
        <filter-name>osivFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>osivFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- struts2核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

第三步 ##

编写UserInfoAction,我们在编写action的时候,为该UserInfoAction声明一个UserInfoBiz属性,并且设置set方法,这样做是为了后边通过springIOC将UserInfoBiz注入给UserInfoAction,完美的实现了三层架构,注意:UserInfoAction必须继承自ActionSupport,如果我们需要用到HttpServletRequest,那么UserInfoAction需要声明一个HttpServletRequest request;属性,并且实现ServletRequestAware接口,实现了ServletRequestAware接口之后,需要重写一下方法:
public void setServletRequest(HttpServletRequest arg0) {
    request=arg0;
}
这里是将arg0赋值给我们自己的属性。
package com.test.action;

import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.interceptor.ServletRequestAware;
import com.opensymphony.xwork2.ActionSupport;
import com.test.biz.UserinfoBiz;
import com.test.entity.Userinfo;

public class UserinfoAction extends ActionSupport implements ServletRequestAware{
    private UserinfoBiz userBiz;
    private HttpServletRequest request;
    private Userinfo user;

    public Userinfo getUser() {
        return user;
    }

    public void setUser(Userinfo user) {
        this.user = user;
    }

    public void setUserBiz(UserinfoBiz userBiz) {
        this.userBiz = userBiz;
    }

    public String getAll() throws Exception {
        List<Userinfo> list = userBiz.getAll();
        request.setAttribute("list", list);
        return "list";
    }

    public String doRegister() throws Exception {
        int result = userBiz.addUserinfo(user);
        if(result>0){
            return this.SUCCESS;
        }
        return this.ERROR;
    }

    public String doDelete() throws Exception {
        int result = userBiz.deleteUserinfo(user.getUid());
        if(result>0){
            return this.SUCCESS;
        }
        return this.ERROR;
    }

    public String doDetail() throws Exception {
        Userinfo userinfo = userBiz.getUserinfoById(user.getUid());
        request.setAttribute("userinfo", userinfo);
        return "detail";
    }
    public String doUpdate() throws Exception {
        int result = userBiz.updateUserinfo(user);
        if(result>0){
            return this.SUCCESS;
        }
        return this.ERROR;
    }   
    public void setServletRequest(HttpServletRequest arg0) {
        request=arg0;
    }
}
这里我们每个方法都返回的是一个string类型的数据,这是因为structs2会根据该返回值来跳转到对应的界面。如果需要将数据传递到jsp页面来显示的话,可以使用request.setAttribute("list", list);这样的形式来传递。其他的没什么可说的了。

第四步

在spring的配置文件中配置action并设置biz
<!-- 配置Action,并注入Biz -->
<bean id="userAction" class="com.test.action.UserinfoAction">
    <property name="userBiz" ref="userBiz"></property>
</bean>
这里我们是将structs2的action交给spring来管理。

第五步

配置structs2的配置文件structs.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="sshDemo" extends="struts-default">
        <!-- class="伪类(spring配置文件中action的id)" -->
        <action name="user-*" class="userAction" method="{1}">
            <result name="list">/list.jsp</result>
            <result name="success" type="redirectAction">user-getAll</result>
            <result name="error">/error.jsp</result>
            <result name="detail">/detail.jsp</result>
        </action>
    </package>
</struts>   
这里"package"标签的名称可以随便起,但是必须继承自"struts-default",action标签中的class是spring中配置的id,因为我们完全将action交给spring来处理了,我可看到我在这里利用"*"通配符和method="{1}"来匹配,什么意思呢?举个栗子,比如我传入的是"http://localhost:8080/xiangmuming/user-add.action",此时将会执行UserinfoAction.java类中的add方法,如果该方法返回"list"这个字符串,那么此时系统将会跳转到根目录下的"list.jsp"页面。
下面是时候编写我们的页面了。在web.xml中配置我的项目的默认主页面是index.jsp,如下:
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
我在index.jsp中创建一个连接,通过该连接可以查询所有的数据:
<a href="user-getAll.action">用户列表</a>
可以看到,"用户列表"会执行到UserInfoAction.java中的getAll方法,通过返回值和structs.xml分析,此方法会跳转到list.jsp,下面是list.jsp的代码:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags"  prefix="s"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <body>
     <table width="70%" align="center" border="1">
        <tr>
            <td>编号</td><td>用户名</td><td>密码</td><td>操作</td>
        </tr>
        <s:if test="#request.list.size==0">
        <tr>
            <td colspan="4">暂无用户信息!</td>
        </tr>
        </s:if>
        <s:else>
            <s:iterator value="#request.list" var="user">
              <tr>
                <td><s:property value="#user.uid"/> </td>
                <td><s:property value="#user.uname"/></td>
                <td><s:property value="#user.upass"/></td>
                <td>
                <a href="user-doDelete.action?user.uid=<s:property value="#user.uid"/>">删除 </a>
                <a href="user-doDetail.action?user.uid=<s:property value="#user.uid"/>">修改</a></td>
               </tr>
            </s:iterator>
        </s:else>
     </table>
  </body>
</html>
在list.jsp中使用了structs2的标签,因此需要导入struct2的标签"<%@ taglib uri="/struts-tags"  prefix="s"%>"
在structs2标签中有<s:if>和<s:else>以及<s:iterator>等标签。
<s:if test="#request.list.size==0">
    <tr>
        <td colspan="4">暂无用户信息!</td>
    </tr>
 </s:if>
 上面的if表示如果request中存在list的长度==0的情况,如果request中的list是有数据的:
 <s:else>
        <s:iterator value="#request.list" var="user">
          <tr>
            <td><s:property value="#user.uid"/> </td>
            <td><s:property value="#user.uname"/></td>
            <td><s:property value="#user.upass"/></td>
            <td>
            <a href="user-doDelete.action?user.uid=<s:property value="#user.uid"/>">删除 </a>
            <a href="user-doDetail.action?user.uid=<s:property value="#user.uid"/>">修改</a></td>
           </tr>
        </s:iterator>
    </s:else>
通过<s:iterator>标签来遍历list集合,这里和forech循环比较相似。user.uid,user.uname,user.upass是UserInfo中的属性。可以看到当我点击删除的时候,会跳转到UserInfoAction中的doDelete方法,删除的连接是跳转到doDetail方法。
运行截图:
![list列表](http://img.blog.csdn.net/20150502231957649)

[**源码下载**](http://download.csdn.net/detail/mockingbirds/8655299)

springMVC学习(S2SH整合)

标签:springmvc   hibernate   structs2   s2sh   

原文地址:http://blog.csdn.net/mockingbirds/article/details/45444793

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!