springmvc+spring+mybatis 整合

1、以前ssm不会，所以花了一段时间，学习了mybatis spring又进行了整合，后来又学习springmvc算是都看了看，今天就把整个搭建好的框架整理一下，和大家分享，如果错误希望指正……

 

2、整个项目的目录结构：

3、有了整体结构之后我们一步一步整合来实现，整合步骤：

（1）、配置前端控制器,web.xml配置

（2）、创建处理映射器  springmvc-server.xml 配置

（3）、创建控制层

（4）、业务逻辑层

（5）、dao层

（6）、sqlmapper 映射文件 

（7）、spring+mybatis 整合配置文件即spring.xml 配置文件

 

4、具体实现

（1）、web.xml配置文件

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xmlns="http://java.sun.com/xml/ns/javaee"  
4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
5.     id="WebApp_ID" version="3.0">  
6.     <display-name>website2</display-name>  
7.     <!-- 加载spring容器配置 -->  
8.     <listener>  
9.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
10.     </listener>  
11.     <!-- 设置Spring容器加载配置文件路径 -->  
12.     <context-param>  
13.         <param-name>contextConfigLocation</param-name>  
14.         <param-value>    
15.          classpath:config/springmvc-servlet.xml,    
16.          classpath:config/ApplicationContext.xml    
17.        </param-value>  
18.     </context-param>  
19.     <!-- 字符编码过滤器 -->  
20.     <filter>  
21.         <filter-name>encodingFilter</filter-name>  
22.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
23.         <init-param>  
24.             <param-name>encoding</param-name>  
25.             <param-value>utf-8</param-value>  
26.         </init-param>  
27.         <init-param>  
28.             <param-name>forceEncoding</param-name>  
29.             <param-value>true</param-value>  
30.         </init-param>  
31.     </filter>  
32.     <filter-mapping>  
33.         <filter-name>encodingFilter</filter-name>  
34.         <url-pattern>*.do</url-pattern>  
35.     </filter-mapping>  
36.     <!-- 前端控制器 -->  
37.     <servlet>  
38.         <servlet-name>springmvc</servlet-name>  
39.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
40.         <init-param>  
41.             <param-name>contextConfigLocation</param-name>  
42.             <param-value>classpath:config/springmvc-servlet.xml</param-value>  
43.         </init-param>  
44.         <!-- 这个配置文件在容器启动的时候 就加载 -->  
45.         <load-on-startup>1</load-on-startup>  
46.     </servlet>  
47.     <servlet-mapping>  
48.         <servlet-name>springmvc</servlet-name>  
49.         <!-- 拦截请求 -->  
50.         <url-pattern>*.do</url-pattern>  
51.     </servlet-mapping>  
52.     <welcome-file-list>  
53.         <welcome-file>index.html</welcome-file>  
54.         <welcome-file>index.htm</welcome-file>  
55.         <welcome-file>index.jsp</welcome-file>  
56.         <welcome-file>default.html</welcome-file>  
57.         <welcome-file>default.htm</welcome-file>  
58.         <welcome-file>default.jsp</welcome-file>  
59.     </welcome-file-list>  
60. </web-app>  

（2）、创建映射处理器：springmvc-server.xml 配置

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans   
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
5.     xmlns:aop="http://www.springframework.org/schema/aop"  
6.     xmlns:context="http://www.springframework.org/schema/context"  
7.     xmlns:mvc="http://www.springframework.org/schema/mvc"   
8.     xmlns:util="http://www.springframework.org/schema/util"  
9.     xmlns:tx="http://www.springframework.org/schema/tx"  
10.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
11.     xmlns:cache="http://www.springframework.org/schema/cache"  
12.     xsi:schemaLocation="  
13.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
14.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  
15.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd  
16.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd  
17.         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd  
18.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
19.         http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd  
20.         http://www.springframework.org/schema/cache  http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">  
21.       
22.     <!-- 注解驱动 -->  
23.     <mvc:annotation-driven/>   
24. <!--     <context:annotation-config />  -->   
25. <!-- context:component-scan 具有annotation-config 的功能 -->  
26.     <!-- 扫描 -->  
27.     <context:component-scan  base-package="com.inspur.action"></context:component-scan>  
28.       
29.     <!--  视图解析器 -->  
30.     <bean id="viewResolver"  class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
31.     <property  name="prefix" value="/WEB-INF/view/"> </property>  
32.     <property name="suffix"  value=".jsp"></property>  
33.     </bean>  
34.   
35. </beans>   

[html]  view plain  copy

 print ?

1. <context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan base-package="xxx.xxx.xxx"/> 后，就可以将 <context:annotation-config/> 移除了。  

（3）、控制层，也就是映射处理器将请求映射到控制层的某个具体的方法上。

[java]  view plain  copy

 print ?

1. packagecom.inspur.action;  
2. importjava.util.ArrayList;  
3. importjava.util.HashMap;  
4. importjava.util.List;  
5. importjava.util.Map;  
6. importorg.springframework.beans.factory.annotation.Autowired;  
7. importorg.springframework.stereotype.Controller;  
8. importorg.springframework.web.bind.annotation.RequestMapping;  
9. importcom.inspur.po.User;  
10. importcom.inspur.service.UserService;  
11. /** 
12.  *@author WHD 
13.  *2015-3-18 
14.  */  
15. /* 
16.  * 这里实现控制层的方式有多种，一般有extends abstractController 以及implements  Controller这个接口 
17.  * 但是在平时的项目中使用的都是这个注解方式实现， 
18.  *所以这里也就使用了注解的方式,使用Controller 就说明这就是控制器 
19.  */  
20. @Controller  
21. /** 
22.  * 这里的RequestMapping 可以在类上也可以不再类上，如果在类上则完整的请求路劲就是类+方法 
23.  */  
24. @RequestMapping(value="/user")  
25. public classUserController {  
26. /** 
27.  * 自动注入业务逻辑层，注入方式使用了注解自动注入 
28.  */  
29.    
30. @Autowired  
31. private UserService userService;  
32.    
33. /** 
34.  * 添加用户信息 
35.  */  
36. /*  增加 */  
37. @RequestMapping(value="/save.do")  
38. public String insert(Integer id ,String name,String sex,User user){  
39. Map<String,Object>map= new HashMap<String,Object>();  
40. map.put("id",user.getId());  
41. map.put("name",user.getName());  
42. map.put("sex",user.getSex());  
43.    
44. userService.saveUser(map);  
45. System.out.println("ok");  
46. return"index";  
47. }  
48.    
49. /**删除 
50.  * 
51.  */  
52. @RequestMapping(value="/delete.do")  
53. public String  delete(Integer id){  
54. userService.delUser(id);  
55. return"index";  
56. }  
57.    
58. /** 
59.  * 修改用户信息 
60.  */  
61. @RequestMapping(value="/update.do")  
62. public String update(User user){  
63. Map<String,Object>map= new HashMap<String,Object>();  
64. map.put("id",user.getId());  
65. map.put("name",user.getName());  
66. map.put("sex",user.getSex());  
67. userService.updateUser(map);  
68. return"index";  
69. }  
70.    
71. /** 
72.  * 查询用户信息 
73.  */  
74. @RequestMapping(value="/select.do")  
75. public String select(Integer id,Map<String,Object> map){  
76. List<Map<String,Object>>list= new ArrayList<Map<String,Object>>();  
77. list=userService.selectUser(id);  
78. map.put("mylist",list);  
79. return"list";  
80. }  
81. }  

（4）、业务逻辑层

[java]  view plain  copy

 print ?

1. packagecom.inspur.service;  
2. importjava.util.List;  
3. importjava.util.Map;  
4. importorg.springframework.beans.factory.annotation.Autowired;  
5. importorg.springframework.stereotype.Service;  
6. importorg.springframework.transaction.annotation.Transactional;  
7. importcom.inspur.dao.UserDao;  
8. /** 
9.  *@author WHD 
10.  *2015-3-18 
11.  */  
12. /** 
13.  * 这个service注解说明就是一个业务逻辑层，里面的值可有可无 
14.  */  
15. @Service("userService")  
16. /** 
17.  * transactional 这个注解就是使用注解的方式实现事务 
18.  */  
19. @Transactional  
20. public classUserService {  
21. /** 
22.  *自动注入dao层 
23.  */  
24. @Autowired  
25. private UserDao  userDao;  
26.    
27. /**保存用户信息 
28.  * @param map 
29.  */  
30. public void saveUser(Map<String, Object> map) {  
31. //TODO Auto-generated method stub  
32. userDao.saveUser(map);  
33. }  
34.    
35. /** 
36.  *删除user 
37.  * @param id 
38.  */  
39. public void delUser(Integer id) {  
40. userDao.delUser(id);  
41. }  
42.    
43. /** 
44.  * 编辑用户信息 
45.  * @param map 
46.  */  
47. public void updateUser(Map<String, Object> map) {  
48.  userDao.updateUser(map);  
49. }  
50.    
51. /** 
52.  * 查询信息 
53.  * @param id 
54.  */  
55. public List<Map<String,Object>> selectUser(Integer id) {  
56.        return userDao.selectUser(id);                  
57. }  
58. }  

(5)、dao层

[java]  view plain  copy

 print ?

1. packagecom.inspur.dao;  
2. importjava.util.List;  
3. importjava.util.Map;  
4. importorg.mybatis.spring.SqlSessionTemplate;  
5. importorg.springframework.beans.factory.annotation.Autowired;  
6. importorg.springframework.stereotype.Repository;  
7. /** 
8.  *@author WHD 
9.  *2015-3-18 
10.  */  
11. /** 
12.  * repository 说明就是一个dao层的注解 
13.  */  
14. @Repository("userDao")  
15. public class UserDao{  
16. /** 
17.  *自动注入这里spring管理了mybatis的sqlsessionfactory 
18.  */  
19. @Autowired  
20. private SqlSessionTemplate sqlSession;  
21.    
22. /** 
23.  * 保存用户信息 
24.  * @param map 
25.  */  
26. publicvoid saveUser(Map<String, Object> map) {  
27. sqlSession.insert("com.inspur.userMapper.insertUserMap",map);  
28. }  
29.    
30. /** 
31.  * 删除用户 
32.  * @param id 
33.  */  
34. public void delUser(Integer id) {  
35. sqlSession.delete("com.inspur.userMapper.delUser",id);  
36. }  
37. /** 
38.  * 修改用户信息 
39.  * @param map 
40.  */  
41. public void updateUser(Map<String, Object> map) {  
42. sqlSession.update("com.inspur.userMapper.updateUser",map);  
43. }  
44. /** 
45.  * 查询用户信息 
46.  * @param id 
47.  * @return 
48.  */  
49. public List<Map<String, Object>> selectUser(Integer id) {  
50. return sqlSession.selectList("com.inspur.userMapper.selectUser", id) ;  
51. }  
52. }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>  

（6）、mybatis sqlmapper 映射文件

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
4.         <!--这个namespace + 下面的id 就是一个完整的路径，在dao层我们写了完整的路径之后mybatis就是映射这个文件中的相关sql语句 -->  
5. <mapper namespace="com.inspur.userMapper">  
6. <!-- parameterType就是你接受的参数的类型，  -->  
7. <!-- 添加用户信息 -->  
8. <insert id="insertUserMap"  parameterType="java.util.Map">  
9.  insert  into  mytest(id,name,sex)  values(#{id},#{name},#{sex})  
10. </insert>  
11.   
12. <delete id="delUser" parameterType="int">  
13.  delete  from  mytest where id=#{id}  
14. </delete>  
15.   
16. <update id="updateUser" parameterType="java.util.Map">  
17. update mytest set name=#{name},sex=#{sex} where id=#{id}  
18. </update>  
19.   
20. <!--  查询返回的是 list<map> -->  
21. <!-- resultType 就是返回查询结果的类型，而如果是resultMap=则返回的就是你定义的javabean  -->  
22. <select  id="selectUser"  parameterType="int" resultType="java.util.Map">  
23.   select  id ,name,sex from mytest where id=#{id}  
24. </select>  
25.   
26. </mapper>  

（7）、ApplicationContext 配置文件

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.     xmlns:tx="http://www.springframework.org/schema/tx"  
5.     xmlns:context="http://www.springframework.org/schema/context"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
7.                 http://www.springframework.org/schema/context  
8.                  http://www.springframework.org/schema/context/spring-context-3.2.xsd  
9.                 http://www.springframework.org/schema/tx   
10.                 http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
11.       
12.     <!-- 加载配置JDBC文件 -->  
13.     <context:property-placeholder location="classpath:datasource.properties" />  
14.     <!-- 数据源 -->  
15.     <bean id="dataSource"  class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
16.     <property name="driverClassName">  
17.     <value>${jdbc.driverClassName}</value>  
18.      </property>  
19.     <property name="url">  
20.     <value>${jdbc.url}</value>  
21.     </property>  
22.     <property name="username">  
23.     <value>${jdbc.username}</value>  
24.     </property>  
25.     <property name="password">  
26.     <value>${jdbc.password}</value>  
27.     </property>  
28.     </bean>  
29.       
30.      <!-- 下面这两个开启了自动扫描功能 -->  
31.       <!-- 开启注解配置 即Autowried -->    
32.   <!--   <context:annotation-config/>   -->  
33.     <!--    使用自动注入的时候要  添加他来扫描bean之后才能在使用的时候   -->  
34.        <!--其实component-scan 就有了annotation-config的功能即把需要的类注册到了spring容器中-->  
35.     <context:component-scan base-package="com.inspur.service ,com.inspur.dao"/>    
36.     <!-- 在使用mybatis时 spring使用sqlsessionFactoryBean 来管理mybatis的sqlsessionFactory-->  
37.     <!-- 而像这种使用接口实现的方式 是使用sqlsessionTemplate来进行操作的，他提供了一些方法 -->  
38.     <bean id="sqlSessionFactory"  class="org.mybatis.spring.SqlSessionFactoryBean">  
39.     <property name="dataSource" ref="dataSource"/>  
40.     <!-- mybatis配置文件路径-->  
41.     <property name="configLocation"  value=""/>     
42.     <!-- 实体类映射文件路径-->  
43.      <property name="mapperLocations" value="classpath:mybatis/UserMapper.xml"/>   
44.     </bean>  
45.     <!-- 配置sqlsession 产生这个实例就是通过 sqlsessionTemplate来实现的 -->      
46.     <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">  
47.     <constructor-arg index="0">  
48.     <ref  bean="sqlSessionFactory"/>  
49.     </constructor-arg>  
50.     </bean>  
51.     <!-- 事务 需要三件事才可以  一具体的事务实现着  二事务管理器  三  aop 事务控制  不起作用-->  
52.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">      
53.         <property name="dataSource" ref="dataSource" />      
54.     </bean>  
55.    <!-- 使用全注释事务 -->  
56.     <tx:annotation-driven transaction-manager="transactionManager" />  
57. </beans>  

多个映射文件使用*来替代

[html]  view plain  copy

 print ?

1. <bean id="sqlSessionFactory"  class="org.mybatis.spring.SqlSessionFactoryBean">    
2.    <property name="dataSource" ref="dataSource"/>    
3.    <!-- mybatis配置文件路径-->    
4.    <property name="configLocation"  value=""/>       
5.    <!-- 实体类映射文件路径,如果映射文件比较多的话可以这样写(*)来替代-->    
6.     <property name="mapperLocations" value="classpath:mybatis/*.xml"/>     
7.    </bean>    

Ok  到这里主要的配置文件以及 代码都有了，如果还有什么不清楚的可以下载演示源码看看，如有错误请 指正谢谢！

演示源码下载：http://download.csdn.net/detail/qh_java/8524235

5、annotation-config,annotation-driven,compont-scan 的区别

（1）、<context:annotation-config/> 
隐式地向Spring容器中注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 及 RequiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor
对这个结果类做个解释： 
1、如果你想使用@Autowired注解，那么就必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。
2、如果想使用@ Resource 、@ PostConstruct、@ PreDestroy等注解就必须声明CommonAnnotationBeanPostProcessor。
3、如果想使用@PersistenceContext注解，就必须声明PersistenceAnnotationBeanPostProcessor的Bean。 
4、如果想使用 @Required的注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean。

4个类的传统注入方式：

[java]  view plain  copy

 print ?

1. <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>   
2. <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>   
3. <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>   
4. <bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor"/>   

一般来说，这些注解我们还是比较常用，尤其是Antowired的注解，在自动注入的时候更是经常使用，所以如果总是需要按照传统的方式一条一条配置显得有些繁琐和没有必要，于是spring给我们提供 <context:annotation-config>  的简化配置方式，自动帮你完成声明。

（2）、<context:component-scan/>
<context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan base-package="xxx.xxx.xxx"/> 后，就可以将<context:annotation-config/> 移除了。

（3）、<mvc:annotation-driven/>

相当于注册了DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter两个bean，配置一些messageconverter。即解决了@Controller注解的使用前提配置。

这也是spring3.0中新增加的。