springMVC学习(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)
时间： 2024-10-05 14:03:54

springMVC学习(S2SH整合)的相关文章

springmvc学习总结（二） -- maven+springmvc+spring+mybatis+mysql详细搭建整合过程讲解

@[email protected] 写在最前 之前分享过下面这几篇: mybatis学习笔记(五) -- maven+spring+mybatis从零开始搭建整合详细过程(上)(附demo和搭建过程遇到的问题解决方法) mybatis学习笔记(六) -- maven+spring+mybatis从零开始搭建整合详细过程(下) springmvc学习笔记(一) -- 从零搭建,基础入门 这一篇,在这些练习的基础上,将它们整合在一起! 搭建步骤如下 一.新建maven项目,配置环境,测试是否配置成

SpringMVC学习(四)——Spring、MyBatis和SpringMVC的整合

之前我整合了Spring和MyBatis这两个框架,不会的可以看我的文章MyBatis框架的学习(六)——MyBatis整合Spring.本文我再来讲SpringMVC和MyBatis整合开发的方法,这样的话,Spring.MyBatis和SpringMVC三大框架的整合开发我们就学会了.这里我使用的Spring是Spring4.1.3这个版本(SpringMVC自然也是这个版本),MyBatis是MyBatis3.2.7这个版本. 为了更好的学习SpringMVC和MyBatis整合开发的方法

springmvc学习笔记(8)-springmvc整合mybatis之service

springmvc学习笔记(8)-springmvc整合mybatis之service springmvc学习笔记8-springmvc整合mybatis之service 定义service接口 在spring容器配置service 事务控制 本文记录如何整合service,包括定义spring接口,在spring容器配置service以及事务控制.让spring管理service接口. 定义service接口 public interface ItemsService { //商品查询列表 L

springmvc学习笔记(9)-springmvc整合mybatis之controller

springmvc学习笔记(9)-springmvc整合mybatis之controller springmvc学习笔记9-springmvc整合mybatis之controller springmvcxml 配置webxml 编写Controller就是Handler 编写jsp 本文介绍如何配置springmvc配置文件和web.xml,以及如何编写controller,jsp springmvc.xml 在resources/spring文件下下创建springmvc.xml文件,配置处理

史上最全的SpringMVC学习笔记

SpringMVC学习笔记---- 一.SpringMVC基础入门,创建一个HelloWorld程序 1.首先,导入SpringMVC需要的jar包. 2.添加Web.xml配置文件中关于SpringMVC的配置 <!--configure the setting of springmvcDispatcherServlet and configure the mapping--> <servlet> <servlet-name>springmvc</servlet

springMVC+Hibernate3+spring3整合实例,附带基本权限功能及CURD例子

实例说明: 1.本实例的架子是在2012年为了真实项目的开发搭建的,目前已经在此架子上做了几个中小项目.分为两个不同的版本,一个是Hibernate版本,一个是ibatis版本. 2.本实例是一个SSH的完整的架子,包括了基本的权限管理及CURD的例子.权限管理包括用户管理,菜单管理,角色管理,权限分配等.CURD的例子包括了基本的CURD以及分页功能,可以做为代码复制的例子,只专为新手学习编写的. 3..在本实例的架子上已经开发了几个中小项目,系统技术架构为springMVC+Hibernat

SSM(springmvc+spring+mybatis)整合过程

问题?SSM(springmvc+spring+mybatis)整合过程 一.SSM框架比较S2SH框架的优缺点比较 站在个人使用这两个框架的观点儿上来说的话,我觉得这个不能定死的说,常用的S2SH,SpringMVC等,还可以考虑jFinal. 首先说S2SH,这个是用的比较多的,特别是在中小型项目中,针对大型项目就不行了,是Struts和hibernate过于庞大,过于重量级,项目大了之后配置文件多的也是麻烦事,配置文件多了之后一方面不好操作,另外比较蛋疼的是没法断点调试,特别是对底层数据库

SpringMVC学习(五)——SpringMVC的参数绑定

SpringMVC中的参数绑定还是蛮重要的,所以单独开一篇文章来讲解.本文所有案例代码的编写均建立在前文SpringMVC学习(四)——Spring.MyBatis和SpringMVC的整合的案例基础之上,因此希望读者能仔细阅读这篇文章. 默认支持的数据类型 现在有这样一个需求:打开商品编辑页面,展示商品信息.这是我对这个需求的分析:编辑商品信息,需要根据商品id查询商品信息,然后展示到页面.我这里假设请求的url为/itemEdit.action,由于我想要根据商品id查询商品信息,所以需要传

springmvc+spring+mybatis整合项目

开发环境: System:Windows server 2003 WebBrowser:IE6+.Firefox3+ JavaEE Server:tomcat5. IDE:eclipse.MyEclipse 6.5 Database:MySQL 开发依赖库: JavaEE5.Spring 3.0.5.Mybatis 3.0.2.myBatis-spring-1.0.0-rc2 参考百度文库:http://wenku.baidu.com/view/34559702a6c30c2259019e4e.