Spring3.2.4 和 MyBatis 整合笔记

 涉及内容：

1. Spring 和 MyBatis 的整合
2. Annotation的事务管理
3. 响应流程
   

需要的lib文件：

spring 版本：spring-framework-3.1.0.RELEASE

MyBatis 版本: mybatis-3.0.6

注意：请用这以上或是更高的版本，否则会出奇怪的错误哦~

源代码：

         1.     新建Oracle数据表

[sql] view plain copy

1. CREATE TABLE MYUSER    
2. (    
3.     id       VARCHAR2(10) PRIMARY KEY,    
4.     pwd      VARCHAR2(10) NOT NULL,    
5.     NAME     VARCHAR2(15) NOT NULL,    
6.     birthday VARCHAR2(8) NOT NULL,    
7.     salary   NUMBER(10,2)    
8. );  

         2.     在com.entity包下新建UserEntity.class

[java] view plain copy

1. package com.entity;  
2.   
3. import java.io.Serializable;  
4.   
5. public class UserEntity implements Serializable{  
6.     private static final long serialVersionUID = -458045724375300041L;  
7.       
8.     private String userID;  
9.     private String userPWD;  
10.     private String userName;  
11.     private String userBirthday;  
12.     private String userSalary;  
13.       
14.       
15.     public String getUserID() {  
16.         return userID;  
17.     }  
18.     public void setUserID(String userID) {  
19.         this.userID = userID;  
20.     }  
21.     public String getUserPWD() {  
22.         return userPWD;  
23.     }  
24.     public void setUserPWD(String userPWD) {  
25.         this.userPWD = userPWD;  
26.     }  
27.     public String getUserName() {  
28.         return userName;  
29.     }  
30.     public void setUserName(String userName) {  
31.         this.userName = userName;  
32.     }  
33.     public String getUserBirthday() {  
34.         return userBirthday;  
35.     }  
36.     public void setUserBirthday(String userBirthday) {  
37.         this.userBirthday = userBirthday;  
38.     }  
39.     public String getUserSalary() {  
40.         return userSalary;  
41.     }  
42.     public void setUserSalary(String userSalary) {  
43.         this.userSalary = userSalary;  
44.     }  
45. }  

         3.     在com.dao包下新建IUserDao.java 的Interface

[java] view plain copy

1. package com.dao;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.stereotype.Repository;  
6. import org.springframework.transaction.annotation.Transactional;  
7.   
8. import com.entity.UserEntity;  
9.   
10. public interface IUserDao{  
11.     //这里的函数名，参数与UserMapper.xml中的id相对应。  
12.     public UserEntity getUser(String userID);  
13.     public List<UserEntity> getAllUser();  
14.     public int insertUser(UserEntity user);  
15.     public int updateUser(UserEntity user);  
16.     public int deleteUser(String userID);  
17. }  

         4.     在com.service包下新建UserService.class

[java] view plain copy

1. package com.service;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.stereotype.Repository;  
6. import org.springframework.transaction.annotation.Transactional;  
7.   
8. import com.dao.IUserDao;  
9. import com.entity.UserEntity;  
10.   
11. //表明该文件需要事务  
12. @Transactional  
13. //表明该文件是一个Service  
14. @Service   
15. public class UserService{  
16.   
17.     // 这个属性由Spring帮我们注入。也就是说我们无需写IUserDao userDao = new IUserDao();,Spring会帮我们new一个的  
18.     // MyBatis帮我们管理xml与类的映射及Dao，所以我们直接用@Autowired进行注入就可以了  
19.     @Autowired  
20.     private IUserDao userDao;  
21.       
22.     public IUserDao getUserDao() {  
23.         return userDao;  
24.     }  
25.       
26.     public void setUserDao(IUserDao userDao) {  
27.         this.userDao = userDao;  
28.     }  
29.   
30.     public UserEntity getUser(String userID) {  
31.         return userDao.getUser(userID);  
32.     }  
33.   
34.     public List<UserEntity> getAllUser() {  
35.         return userDao.getAllUser();  
36.     }  
37.   
38.     //表明该方法需要事务  
39.     @Transactional  
40.     public int insertUser(UserEntity user) {  
41.           
42. //      以下为验证事务而添加的  
43. //      UserEntity user1 = new UserEntity();  
44. //      user1.setUserID("10");  
45. //      user1.setUserPWD("1");  
46. //      user1.setUserName("asd");  
47. //      user1.setUserBirthday("20120228");  
48. //      user1.setUserSalary("15000.26");  
49. //      userDao.insertUser(user1);  
50.           
51.         return userDao.insertUser(user);  
52.     }  
53.   
54.     @Transactional  
55.     public int updateUser(UserEntity user) {  
56.         // TODO Auto-generated method stub  
57.         return 0;  
58.     }  
59.   
60.     @Transactional  
61.     public int deleteUser(String userID) {  
62.         // TODO Auto-generated method stub  
63.         return 0;  
64.     }  
65. }  

         5.     在src下新建spring-configuration.xml

[javascript] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <beans xmlns="http://www./schema/beans"  
3.     xmlns:xsi="http://www./2001/XMLSchema-instance" xmlns:aop="http://www./schema/aop"  
4.     xmlns:tx="http://www./schema/tx"  
5.     xmlns:context="http://www./schema/context"   
6.     xsi:schemaLocation="  
7.          http://www./schema/context   
8.          http://www./schema/context/spring-context-3.0.xsd    
9.      http://www./schema/beans   
10.      http://www./schema/beans/spring-beans-3.0.xsd  
11.      http://www./schema/tx   
12.      http://www./schema/tx/spring-tx-3.0.xsd  
13.      http://www./schema/aop   
14.      http://www./schema/aop/spring-aop-3.0.xsd">  
15.   
16.     <!-- 使用apache的DBCP连接池  -->  
17.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  
18.         destroy-method="close">  
19.         <!-- Connection Info -->  
20.         <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />  
21.         <property name="url" value="jdbc:oracle:thin:@192.168.80.128:1521:ocp" />  
22.         <property name="username" value="shenyang" />  
23.         <property name="password" value="shenyang" />  
24.   
25.         <!-- Connection Pooling DBCP -->  
26.         <property name="initialSize" value="5" />  
27.         <property name="maxActive" value="100" />  
28.         <property name="maxIdle" value="30" />  
29.         <property name="maxWait" value="1000" />  
30.         <property name="poolPreparedStatements" value="true" />  
31.         <property name="defaultAutoCommit" value="false" />  
32.     </bean>  
33.   
34.     <!-- 这里的dataSource要与sqlSessionFactory的dataSource一致，否则事务无效 -->  
35.     <bean id="transactionManager"  
36.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
37.         <property name="dataSource" ref="dataSource" />  
38.     </bean>  
39.   
40.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
41.         <property name="dataSource" ref="dataSource" />  
42.         <property name="configLocation" value="classpath:mybatis-configuration.xml"></property>  
43.     </bean>  
44.   
45.     <!-- 注意！这里不要偷懒！。要把userMapper赋给别的.class文件里的一个属性后再使用，否则事务无效。  
46.     也就是说当直接创建userMapper的一个class，然后使用IUserDao.insertUser方法的话也可以实现，但是事务将无效。 -->  
47.     <!-- 这里的mapperInterface需要接口类型 -->  
48.     <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">  
49.         <property name="mapperInterface" value="com.dao.IUserDao" />  
50.         <property name="sqlSessionFactory" ref="sqlSessionFactory" />  
51.     </bean>  
52.       
53.     <!-- 扫描包 -->  
54.     <context:component-scan base-package="com.service" />   
55.   
56.     <!-- 使用注解方式的事务 -->  
57.     <tx:annotation-driven transaction-manager="transactionManager" />  
58.   
59. </beans>  

         6.     在src下新建mybatis-configuration.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN"  
3. "http:///dtd/mybatis-3-config.dtd">  
4. <configuration>  
5.     <!-- 配置mybatis的缓存，延迟加载等等一系列属性 -->  
6.     <settings>  
7.         <!-- 全局映射器启用缓存 -->  
8.         <setting name="cacheEnabled" value="true" />  
9.         <!-- 查询时，关闭关联对象即时加载以提高性能 -->  
10.         <setting name="lazyLoadingEnabled" value="true" />  
11.         <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->  
12.         <setting name="aggressiveLazyLoading" value="false" />  
13.         <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->  
14.         <setting name="multipleResultSetsEnabled" value="true" />  
15.         <!-- 允许使用列标签代替列名 -->  
16.         <setting name="useColumnLabel" value="true" />  
17.         <!-- 允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->  
18.         <!-- <setting name="useGeneratedKeys" value="true" /> -->  
19.         <!-- 给予被嵌套的resultMap以字段-属性的映射支持 -->  
20.         <setting name="autoMappingBehavior" value="FULL" />  
21.         <!-- 对于批量更新操作缓存SQL以提高性能 -->  
22.         <setting name="defaultExecutorType" value="BATCH" />  
23.         <!-- 数据库超过25000秒仍未响应则超时 -->  
24.         <setting name="defaultStatementTimeout" value="25000" />  
25.     </settings>  
26.     <!-- 全局别名设置，在映射文件中只需写别名，而不必写出整个类路径 -->  
27.     <!-- <typeAliases>  
28.         <typeAlias alias="TestBean"  
29.             type="com.wotao.taotao.persist.test.dataobject.TestBean" />  
30.     </typeAliases> -->  
31.     <!-- 非注解的sql映射文件配置，如果使用mybatis注解，该mapper无需配置，但是如果mybatis注解中包含@resultMap注解，则mapper必须配置，给resultMap注解使用 -->  
32.     <mappers>  
33.         <mapper resource="com/mybatis/mapper/UserMapper.xml" />  
34.     </mappers>  
35. </configuration>  

         7.     在com.mybatis.mapper包下新建UserMapper.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN"  
3. "http:///dtd/mybatis-3-mapper.dtd">  
4. <!-- 这里的namespace名字必须为执行该sql的dao地址  -->  
5. <mapper namespace="com.dao.IUserDao">  
6.       
7.     <resultMap type="com.entity.UserEntity" id="userResultMap">    
8.         <id property="userID" column="id"/>    
9.         <result property="userPWD" column="pwd"/>    
10.         <result property="userName" column="name"/>    
11.         <result property="userBirthday" column="birthday"/>  
12.         <result property="userSalary" column="salary"/>  
13.     </resultMap>  
14.        
15.     <select id="getUser" parameterType="String" resultType="com.entity.UserEntity" resultMap="userResultMap">    
16.         <![CDATA[  
17.             SELECT * FROM MYUSER 
18.             WHERE ID =  #{userID} 
19.         ]]>     
20.     </select>  
21.       
22.     <insert id="insertUser" parameterType="com.entity.UserEntity">  
23.             INSERT INTO MYUSER(ID,PWD,NAME,BIRTHDAY,SALARY)  
24.              VALUES(  
25.                 #{userID},  
26.                 #{userPWD},  
27.                 #{userName},  
28.                 #{userBirthday},  
29.                 #{userSalary}  
30.              )  
31.     </insert>  
32.   
33. </mapper>  

测试：

    随便找个地方新建一个JUnitTest.class

[java] view plain copy

1. package com.junit.test;  
2.   
3. import org.junit.Test;  
4. import org.junit.runner.RunWith;  
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.test.context.ContextConfiguration;  
7. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
8.   
9. import com.entity.UserEntity;  
10. import com.service.UserService;  
11.   
12. @RunWith(SpringJUnit4ClassRunner.class)  
13. //因为我们没有启动web工程，所以无法通过web.xml执行执行spring-configuration.xml文件了，所以在这里要显示的声明执行。  
14. @ContextConfiguration(locations = { "classpath:/spring-configuration.xml" })  
15. public class JUnitTest {  
16.    
17.     // 还记得我们之前做了两件事吗？  
18.     // 1. <context:component-scan base-package="com.service" />    
19.     // 2. @Service   
20.     //    public class UserService  
21.     // 第一告诉Spring扫描com.service下的所有类，第二告诉UserService是一个Service，让Spring准备处理  
22.     // 所以这里用@Autowired注解的时候就可以将UserService注入进来了。无需我们写UserService userService = new UserService()  
23.     @Autowired  
24.   UserService userService;  
25.       
26.     @Test   
27.     public void start(){  
28.         //ApplicationContext ct =new ClassPathXmlApplicationContext("spring-configuration.xml");  
29.         //UserService userService = (UserService)ct.getBean("userService");  
30.         try{  
31.             UserEntity user = new UserEntity();  
32.             user.setUserID("10");  
33.             user.setUserPWD("1");  
34.             user.setUserName("asd");  
35.             user.setUserBirthday("20120228");  
36.             user.setUserSalary("15000.26");  
37.               
38.             userService.insertUser(user);  
39.         }catch(Exception e){  
40.             e.printStackTrace();  
41.         }  
42.           
43.     }  
44. }  

OK，现在打开JUnitTest.class.然后鼠标右键以JUnit方式运行就可以测试了。

因为是拿JUnit测试，所以并没有编写web.xml，在这里补上。

[html] view plain copy

1.        <servlet>  
2.     <servlet-name>spring-dispatcher</servlet-name>  
3.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
4.     <init-param>  
5.         <param-name>contextConfigLocation</param-name>  
6.         <param-value>spring-configuration.xml</param-value>  
7.     </init-param>  
8. </servlet>  
9.   
10. <servlet-mapping>  
11.     <servlet-name>spring-dispatcher</servlet-name>  
12.     <!-- 这里不能写"/*",这样会拦截所有消息，连Index.jsp都被拦截而进步了了 -->  
13.     <url-pattern>*.do</url-pattern>  
14. </servlet-mapping>  

其中第6行，可能会有点错误，这个地方，我之后如果有时间的话，会测试并改回来。

例行惯例，写一下响应流程：

1. 初始化spring-configration.xml中的userService文件。
2. 通过spring-configuration.xml中的 53 行将userService文件中的userDao赋值为 <bean id="userMapper"> 的值。
3. <bean id="userMapper"> 为com.dao.IUserDao文件加载sqlSessionFactory.openSession()产生的SqlSession属性。（猜~）所以我们不用像MyBatis那样自己生成SqlSession了。
4. sqlSessionFactory加载 <bean id="sqlSessionFactory">。
5. <bean id="userMapper">在spring-configuration.xml的 37 行加载了连接数据库的dataSource 和mybatis-configuration.xml文件。
6. mybatis-configuration.xml文件配置了缓存，延迟加载等等一系列属性，加载了UserMapper.xml文件。
7. UserMapper.xml文件中写了最关键的SQL语句。（暂时告一段落）
   
8. 在UserService.class的 46 行中可以看出UserService.insertUser(UserEntity user) 调用了userDao.insertUser(user)。
9. 而经过第三步骤，userDao.insertUser(user)实际上就是调用了sqlSessionFactory.openSession().insert("userDao的包名.insertUser",user);不理解这语句的朋友请看《MyBatis 基础笔记》。