mybaits入门（含实例教程和源码）

admin

前言：mybatis是一个非常优秀的存储过程和高级映射的优秀持久层框架。大大简化了，数据库操作中的常用操作。下面将介绍mybatis的一些概念和在eclipse上的实际项目搭建使用。

一、mybatis的概念介绍

1.1、背景介绍

MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。

用xml文件构建SqlSessionFactory实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但你可以使用任何Reader实例，包括用文件路径或file://开头的url创建的实例。MyBatis有一个实用类—-Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。

1.2、总体流程

(1)加载配置并初始化
触发条件：加载配置文件
将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

(2)接收调用请求
触发条件：调用Mybatis提供的API
传入参数：为SQL的ID和传入参数对象
处理过程：将请求传递给下层的请求处理层进行处理。

(3)处理操作请求 触发条件：API接口层传递请求过来
传入参数：为SQL的ID和传入参数对象
处理过程：
(A)根据SQL的ID查找对应的MappedStatement对象。
(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。
(C)获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。
(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。
(E)释放连接资源。

(4)返回处理结果将最终的处理结果返回。

1.3、功能架构

功能架构讲解：
我们把Mybatis的功能架构分为三层：

(1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

(2)数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

(3)基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

1.4、框架架构

框架架构讲解：

（1）加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

（2）SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。

（3）SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。

（4）结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。

1.5、动态SQL

MyBatis 最强大的特性之一就是它的动态语句功能。如果您以前有使用JDBC或者类似框架的经历，您就会明白把SQL语句条件连接在一起是多么的痛苦，要确保不能忘记空格或者不要在columns列后面省略一个逗号等。动态语句能够完全解决掉这些痛苦。尽管与动态SQL一起工作不是在开一个party，但是MyBatis确实能通过在任何映射SQL语句中使用强大的动态SQL来改进这些状况。

动态SQL元素对于任何使用过JSTL或者类似于XML之类的文本处理器的人来说，都是非常熟悉的。在上一版本中，需要了解和学习非常多的元素，但在MyBatis 3 中有了许多的改进，现在只剩下差不多二分之一的元素。MyBatis使用了基于强大的OGNL表达式来消除了大部分元素。

二、mybatis实例

接下来的mybatis的实例是在eclipse+maven+MySQL的基础上写的，如果猿友们，没有搭建好maven，甚至没有听过maven的，那么请阅读博主的关于maven的文章：http://blog.csdn.net/u013142781/article/details/50316383（含实例哦）
如果mysql没有搭建好的话，可以阅读博主的另外一篇文章：http://blog.csdn.net/u013142781/article/details/50300233

1、创建表，并插入数据：

1. CREATE TABLE `t_user` (
   
2.   `USER_ID` int(11) NOT NULL AUTO_INCREMENT,
   
3.   `USER_NAME` char(30) NOT NULL,
   
4.   `USER_PASSWORD` char(10) NOT NULL,
   
5.   PRIMARY KEY (`USER_ID`),
   
6.   KEY `IDX_NAME` (`USER_NAME`)
   
7. ) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8

复制代码

1. INSERT INTO t_user (USER_ID, USER_NAME, USER_PASSWORD) VALUES (1, 'luoguohui', '123456');
   
2. INSERT INTO t_user (USER_ID, USER_NAME, USER_PASSWORD) VALUES (2, 'zhangsan', '123456');

复制代码

2、添加包的依赖，我的文章 Maven之初恋，已经创建好的maven项目，现在只需要添加如下依赖：

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
2.   <modelVersion>4.0.0</modelVersion>
   
3.   <groupId>com.luo</groupId>
   
4.   <artifactId>first_maven_project</artifactId>
   
5.   <version>0.0.1-SNAPSHOT</version>
   
6. 
   
7.   <properties>
   
8.         <!-- spring版本号 -->
   
9.         <spring.version>3.2.8.RELEASE</spring.version>
   
10.         <!-- log4j日志文件管理包版本 -->
    
11.         <slf4j.version>1.6.6</slf4j.version>
    
12.         <log4j.version>1.2.12</log4j.version>
    
13.         <!-- junit版本号 -->
    
14.         <junit.version>4.10</junit.version>
    
15.         <!-- mybatis版本号 -->
    
16.         <mybatis.version>3.2.1</mybatis.version>
    
17.   </properties>
    
18. 
    
19.   <dependencies>
    
20.         <!-- 添加Spring依赖 -->
    
21.         <dependency>
    
22.             <groupId>org.springframework</groupId>
    
23.             <artifactId>spring-core</artifactId>
    
24.             <version>${spring.version}</version>
    
25.         </dependency>
    
26.         <dependency>
    
27.             <groupId>org.springframework</groupId>
    
28.             <artifactId>spring-webmvc</artifactId>
    
29.             <version>${spring.version}</version>
    
30.         </dependency>
    
31.         <dependency>
    
32.             <groupId>org.springframework</groupId>
    
33.             <artifactId>spring-context</artifactId>
    
34.             <version>${spring.version}</version>
    
35.         </dependency>
    
36.         <dependency>
    
37.             <groupId>org.springframework</groupId>
    
38.             <artifactId>spring-context-support</artifactId>
    
39.             <version>${spring.version}</version>
    
40.         </dependency>
    
41.         <dependency>
    
42.             <groupId>org.springframework</groupId>
    
43.             <artifactId>spring-aop</artifactId>
    
44.             <version>${spring.version}</version>
    
45.         </dependency>
    
46.         <dependency>
    
47.             <groupId>org.springframework</groupId>
    
48.             <artifactId>spring-aspects</artifactId>
    
49.             <version>${spring.version}</version>
    
50.         </dependency>
    
51.         <dependency>
    
52.             <groupId>org.springframework</groupId>
    
53.             <artifactId>spring-tx</artifactId>
    
54.             <version>${spring.version}</version>
    
55.         </dependency>
    
56.         <dependency>
    
57.             <groupId>org.springframework</groupId>
    
58.             <artifactId>spring-jdbc</artifactId>
    
59.             <version>${spring.version}</version>
    
60.         </dependency>
    
61.         <dependency>
    
62.             <groupId>org.springframework</groupId>
    
63.             <artifactId>spring-web</artifactId>
    
64.             <version>${spring.version}</version>
    
65.         </dependency>
    
66. 
    
67.         <!--单元测试依赖 -->
    
68.         <dependency>
    
69.             <groupId>junit</groupId>
    
70.             <artifactId>junit</artifactId>
    
71.             <version>${junit.version}</version>
    
72.             <scope>test</scope>
    
73.         </dependency>
    
74. 
    
75.         <!-- 日志文件管理包 -->
    
76.         <!-- log start -->
    
77.         <dependency>
    
78.             <groupId>log4j</groupId>
    
79.             <artifactId>log4j</artifactId>
    
80.             <version>${log4j.version}</version>
    
81.         </dependency>
    
82.         <dependency>
    
83.             <groupId>org.slf4j</groupId>
    
84.             <artifactId>slf4j-api</artifactId>
    
85.             <version>${slf4j.version}</version>
    
86.         </dependency>
    
87.         <dependency>
    
88.             <groupId>org.slf4j</groupId>
    
89.             <artifactId>slf4j-log4j12</artifactId>
    
90.             <version>${slf4j.version}</version>
    
91.         </dependency>
    
92.         <!-- log end -->
    
93. 
    
94.         <!--spring单元测试依赖 -->
    
95.         <dependency>
    
96.             <groupId>org.springframework</groupId>
    
97.             <artifactId>spring-test</artifactId>
    
98.             <version>${spring.version}</version>
    
99.             <scope>test</scope>
    
100.         </dependency>
     
101. 
     
102.         <!--mybatis依赖 -->
     
103.         <dependency>
     
104.             <groupId>org.mybatis</groupId>
     
105.             <artifactId>mybatis</artifactId>
     
106.             <version>${mybatis.version}</version>
     
107.         </dependency>
     
108. 
     
109.         <!-- mybatis/spring包 -->
     
110.         <dependency>
     
111.             <groupId>org.mybatis</groupId>
     
112.             <artifactId>mybatis-spring</artifactId>
     
113.             <version>1.2.0</version>
     
114.         </dependency>
     
115. 
     
116.         <!-- mysql驱动包 -->
     
117.         <dependency>
     
118.             <groupId>mysql</groupId>
     
119.             <artifactId>mysql-connector-java</artifactId>
     
120.             <version>5.1.29</version>
     
121.         </dependency>
     
122.     </dependencies>
     
123. 
     
124. </project>

复制代码

3、配置文件：

3.1、mybatis包下添加mybatis-config.xml文件（mybatis配置文件）：

1. <?xml version="1.0" encoding="UTF-8"?>  
   
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
   
3. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
   
4. <configuration>   
   
5. </configuration>
   

复制代码

3.2、properties包下添加jdbc.properties文件（数据源配置文件）：

1. jdbc_driverClassName=com.mysql.jdbc.Driver
   
2. jdbc_url=jdbc:mysql://localhost:3306/luo
   
3. jdbc_username=root
   
4. jdbc_password=root

复制代码

3.3、mapper包下userMapper.xml配置文件（表映射文件）：

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. <mapper namespace="com.luo.dao.UserDao">
   
5. <!--设置domain类和数据库中表的字段一一对应，注意数据库字段和domain类中的字段名称不致，此处一定要！-->
   
6.     <resultMap id="BaseResultMap" type="com.luo.domain.User">
   
7.         <id column="USER_ID" property="userId" jdbcType="INTEGER" />
   
8.         <result column="USER_NAME" property="userName" jdbcType="CHAR" />
   
9.         <result column="USER_PASSWORD" property="userPassword" jdbcType="CHAR" />
   
10.     </resultMap>
    
11.     <!-- 查询单条记录 -->
    
12.     <select id="selectUserById" parameterType="int" resultMap="BaseResultMap">
    
13.         SELECT * FROM t_user WHERE USER_ID = #{userId}
    
14.     </select>
    
15. </mapper>

复制代码

3.4、spring配置文件application.xml：

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" xmlns:context="http://www.springframework.org/schema/context"
   
4.     xmlns:aop="http://www.springframework.org/schema/aop"
   
5.     xsi:schemaLocation="  
   
6.            http://www.springframework.org/schema/beans  
   
7.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
   
8.            http://www.springframework.org/schema/aop  
   
9.            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   
10.            http://www.springframework.org/schema/context  
    
11.            http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    
12. 
    
13.      <!-- 引入jdbc配置文件 -->  
    
14.      <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    
15.         <property name="locations">
    
16.             <list>
    
17.                <value>classpath:properties/*.properties</value>
    
18.                 <!--要是有多个配置文件，只需在这里继续添加即可 -->
    
19.             </list>
    
20.         </property>
    
21.     </bean>
    
22. 
    
23. 
    
24. 
    
25.     <!-- 配置数据源 -->
    
26.     <bean id="dataSource"
    
27.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    
28.         <!-- 不使用properties来配置 -->
    
29.         <!-- <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    
30.             <property name="url" value="jdbc:mysql://localhost:3306/learning" />
    
31.             <property name="username" value="root" />
    
32.             <property name="password" value="christmas258@" /> -->
    
33.        <!-- 使用properties来配置 -->
    
34.         <property name="driverClassName">
    
35.             <value>${jdbc_driverClassName}</value>
    
36.         </property>
    
37.         <property name="url">
    
38.             <value>${jdbc_url}</value>
    
39.         </property>
    
40.         <property name="username">
    
41.             <value>${jdbc_username}</value>
    
42.         </property>
    
43.         <property name="password">
    
44.             <value>${jdbc_password}</value>
    
45.         </property>
    
46.     </bean>
    
47. 
    
48.     <!-- 自动扫描了所有的XxxxMapper.xml对应的mapper接口文件，这样就不用一个一个手动配置Mpper的映射了，只要Mapper接口类和Mapper映射文件对应起来就可以了。 -->
    
49.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    
50.         <property name="basePackage"
    
51.             value="com.luo.dao" />
    
52.     </bean>
    
53. 
    
54.     <!-- 配置Mybatis的文件 ，mapperLocations配置**Mapper.xml文件位置，configLocation配置mybatis-config文件位置-->
    
55.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    
56.         <property name="dataSource" ref="dataSource" />
    
57.         <property name="mapperLocations" value="classpath:mapper/*.xml"/>  
    
58.         <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />
    
59.         <!-- <property name="typeAliasesPackage" value="com.tiantian.ckeditor.model"
    
60.             /> -->
    
61.     </bean>
    
62. 
    
63.     <!-- 自动扫描注解的bean -->
    
64.     <context:component-scan base-package="com.luo.service" />
    
65. 
    
66. </beans>

复制代码

4、接口和类的配置：

4.1、com.luo.domain下添加User.java文件：

1. package com.luo.domain;
   
2. 
   
3. public class User {
   
4. 
   
5.     private Integer userId;  
   
6.     private String userName;  
   
7.     private String userPassword;  
   
8. 
   
9. 
   
10.     public Integer getUserId() {  
    
11.         return userId;  
    
12.     }  
    
13. 
    
14.     public void setUserId(Integer userId) {  
    
15.         this.userId = userId;  
    
16.     }  
    
17. 
    
18.     public String getUserName() {  
    
19.         return userName;  
    
20.     }  
    
21. 
    
22.     public void setUserName(String userName) {  
    
23.         this.userName = userName;  
    
24.     }  
    
25. 
    
26.     public String getUserPassword() {  
    
27.         return userPassword;  
    
28.     }  
    
29. 
    
30.     public void setUserPassword(String userPassword) {  
    
31.         this.userPassword = userPassword;  
    
32.     }  
    
33. 
    
34. }

复制代码

4.2、com.luo.dao下添加UserDao.java文件

1. package com.luo.dao;
   
2. 
   
3. import com.luo.domain.User;
   
4. 
   
5. public interface UserDao {
   
6. 
   
7.     /**
   
8.      * @param userId
   
9.      * @return User
   
10.      */
    
11.     public User selectUserById(Integer userId);  
    
12. 
    
13. }

复制代码

4.3、com.luo.service下添加UserService.java接口和UserServiceImpl实现类：

1. package com.luo.service;
   
2. 
   
3. import com.luo.domain.User;
   
4. 
   
5. public interface UserService {
   
6.     User selectUserById(Integer userId);  
   
7. }

复制代码

1. package com.luo.service;
   
2. 
   
3. import org.springframework.beans.factory.annotation.Autowired;
   
4. import org.springframework.stereotype.Service;
   
5. import com.luo.dao.UserDao;
   
6. import com.luo.domain.User;
   
7. 
   
8. @Service  
   
9. public class UserServiceImpl implements UserService {
   
10. 
    
11.     @Autowired  
    
12.     private UserDao userDao;  
    
13. 
    
14.     public User selectUserById(Integer userId) {  
    
15.         return userDao.selectUserById(userId);  
    
16. 
    
17.     }  
    
18. }

复制代码

5、单元测试

5.1、com.luo.baseTest下添加SpringTestCase.java：

1. package com.luo.baseTest;
   
2. 
   
3. import org.junit.runner.RunWith;  
   
4. import org.springframework.test.context.ContextConfiguration;  
   
5. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
   
6. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
   
7. 
   
8. //指定bean注入的配置文件  
   
9. @ContextConfiguration(locations = { "classpath:application.xml" })  
   
10. //使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner  
    
11. @RunWith(SpringJUnit4ClassRunner.class)  
    
12. public class SpringTestCase extends AbstractJUnit4SpringContextTests {
    
13. 
    
14. }

复制代码

5.2、com.luo.service添加UserServiceTest.java：

1. package com.luo.service;
   
2. 
   
3. import org.junit.Test;  
   
4. import org.springframework.beans.factory.annotation.Autowired;  
   
5. import com.luo.baseTest.SpringTestCase;  
   
6. import com.luo.domain.User;
   
7. 
   
8. public class UserServiceTest extends SpringTestCase {
   
9. 
   
10.     @Autowired  
    
11.     private UserService userService;
    
12. 
    
13.     @Test  
    
14.     public void selectUserByIdTest(){  
    
15.         User user = userService.selectUserById(1);  
    
16.         System.out.println(user.getUserName() + ":" + user.getUserPassword());
    
17.     }  
    
18. }

复制代码

5.3、运行单元测试，UserServiceTest右键Run As –>Junit Test，运行结果：

6、实例源码下载

http://download.csdn.net/detail/u013142781/9374560

。。