MyBatis使用大全(1)------入门初体验

1.所需jar包

这里单独讨论MyBatis的使用，只需要放入mybatis-x.x.x.jar包即可。

如果使用maven构建项目，则需要在pom.xml的dependency中放入如下配置：

[html] view plain copy

1. <dependency>  
2.      <groupId>org.mybatis</groupId>  
3.      <artifactId>mybatis</artifactId>  
4.      <version>3.2.2</version>  
5. </dependency>  

公司目前用的3.2.2的，可以根据自己的jar包放入版本号。

如果你是与相应的框架一起集成，则需要放入集成包，比如，我们公司用mybatis与spring集成，

则还需要加入mybatis-spring-xxx.jar包，根据实际情况决定。当然了，数据库驱动jar包也是少不了的。

2.从XML中构建SqlSessionFactory

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的。

SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。

而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。

但是也可以使用任意的输入流(InputStream)实例，包括字符串形式的文件路径或者 file:// 的 URL 形式的文件路径来配置。

MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，可使从 classpath 或其他位置加载资源文件更加容易。

例如：

[html] view plain copy

1. String resource = "mybatis-config.xml";  
2. InputStream is = Resources.getResourceAsStream(resource);  
3. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  

XML 配置文件（configuration XML）中包含了对 MyBatis 系统的核心设置，包含获取数据库连接实例的数据源（DataSource）

和决定事务范围和控制方式的事务管理器（TransactionManager）。配置文件详细往后再说。

例如：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  
3. <configuration>  
4.     <environments default="development">  
5.         <environment id="development">  
6.          <transactionManager type="JDBC"/>  
7.          <dataSource type="POOLED">  
8.            <property name="driver" value="com.mysql.jdbc.Driver"/>  
9.            <property name="url" value="jdbc:mysql://192.168.200.12:3306/test_mybatis"/>  
10.            <property name="username" value="root"/>  
11.            <property name="password" value="root123"/>  
12.          </dataSource>  
13.         </environment>  
14.     </environments>  
15.     <mappers>  
16.         <!-- 注册UserMainMapper.xml文件，UserMainMapper.xml位于com.lanhuigu.mybatis.map这个包下，  
17.         所以resource写成com/lanhuigu/mybatis/map/UserMainMapper.xml-->  
18.         <mapper resource="com/lanhuigu/mybatis/map/UserMainMapper.xml"></mapper>  
19.     </mappers>  
20. </configuration>  

environment 元素体中包含了事务管理和连接池的配置。mappers 元素则是包含一组 mapper 映射器（这些 mapper 的 XML 文件包含了 SQL 代码和映射定义信息）。

3.从SqlSessionFactory中获取SqlSession

既然有了 SqlSessionFactory ，我们就可以从中获得 SqlSession 的实例。SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。

你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如：

[java] view plain copy

1. SqlSessionFactory sqlSessionFactory = null;// XML构建SqlSessionFactory工厂实例  
2. SqlSession session = null;// 从SqlSessionFactory工厂实例中获取SqlSession对象  
3. try {  
4.      String resource = "mybatis-config.xml";  
5.      InputStream is = Resources.getResourceAsStream(resource);  
6.      sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
7.      session = sqlSessionFactory.openSession();  
8.      User user = (User)session.selectOne("com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById", 1);  
9.      System.out.println(user.getUsername());  
10. } finally {  
11.      session.close();  
12. }  

用这种方式执行映射没什么问题，我们也可以用一种更加简洁的方式执行映射。

使用对于给定语句能够合理描述参数和返回值的接口（比如说UserMainMapper.class），

你现在不但可以执行更清晰和类型安全的代码，而且还不用担心易错的字符串字面值以及强制类型转换。例如：

[java] view plain copy

1. SqlSession session = sqlSessionFactory.openSession();  
2. UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class);  
3. User user = userMainMapper .queryUserMainById(1);  

4.实例

光看不练容易迷糊，看看实例，在回去读文档，或许效果会更好。

准备jar包：

mybatis-3.2.2.jar(mybatis)

MySQL-connector-Java-5.1.21.jar(数据库驱动)

junit-4.4.jar(测试，不想用这个junit，用main方法测试也行)

项目结构：

数据库：

[sql] view plain copy

1. CREATE TABLE `t_user_main` (  
2.   `f_id` int(11) NOT NULL,  
3.   `f_username` varchar(20) DEFAULT NULL,  
4.   `f_age` int(3) DEFAULT NULL,  
5.   PRIMARY KEY (`f_id`)  
6. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;  
7.   
8. INSERT INTO t_user_main VALUES(1,'testMyBatis',25);  

mybatis的xml配置--mybatis-config.xml:

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  
3. <configuration>  
4.     <environments default="development">  
5.         <environment id="development">  
6.          <transactionManager type="JDBC"/>  
7.          <dataSource type="POOLED">  
8.            <property name="driver" value="com.mysql.jdbc.Driver"/>  
9.            <property name="url" value="jdbc:mysql://192.168.200.12:3306/test_mybatis"/>  
10.            <property name="username" value="root"/>  
11.            <property name="password" value="root123"/>  
12.          </dataSource>  
13.         </environment>  
14.     </environments>  
15.     <mappers>  
16.         <!-- 注册UserMainMapper.xml文件，UserMainMapper.xml位于com.lanhuigu.mybatis.map这个包下，  
17.         所以resource写成com/lanhuigu/mybatis/map/UserMainMapper.xml-->  
18.         <mapper resource="com/lanhuigu/mybatis/map/UserMainMapper.xml"></mapper>  
19.     </mappers>  
20. </configuration>  

User.java:

[java] view plain copy

1. package com.lanhuigu.mybatis.entity;  
2.   
3. import java.io.Serializable;  
4.   
5. public class User implements Serializable{  
6.   
7.     private static final long serialVersionUID = -3412068097348759984L;  
8.       
9.     private Integer id;  
10.     private String username;  
11.     private Integer age;  
12.     public Integer getId() {  
13.         return id;  
14.     }  
15.     public void setId(Integer id) {  
16.         this.id = id;  
17.     }  
18.     public String getUsername() {  
19.         return username;  
20.     }  
21.     public void setUsername(String username) {  
22.         this.username = username;  
23.     }  
24.     public Integer getAge() {  
25.         return age;  
26.     }  
27.     public void setAge(Integer age) {  
28.         this.age = age;  
29.     }  
30.   
31. }  

UserMainMapper.xml:

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>    
2. <!DOCTYPE mapper    
3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"    
4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">    
5.     
6. <!--   
7.     为这个mapper指定一个唯一的namespace，namespace的值习惯上设置成包名+去掉sql映射文件后缀的文件名，  
8.     这样就能够保证namespace的值是唯一的,例如namespace="com.lanhuigu.mybatis.map.UserMainMapper"  
9.     就是com.lanhuigu.mybatis.map(包名)+UserMainMapper(UserMainMapper.xml文件去除后缀)  
10. -->  
11. <mapper namespace="com.lanhuigu.mybatis.map.UserMainMapper">    
12.   <!--   
13.      在select标签中编写查询的SQL语句， 设置select标签的id属性为queryUserMainById，id属性值必须是唯一的，  
14.      不能够重复使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型  
15.          resultType="com.lanhuigu.mybatis.entity.User"就表示将查询结果封装成一个User类的对象返回  
16.          User类就是users表所对应的实体类  
17.   -->  
18.   <select id="queryUserMainById" parameterType="int"   
19.           resultType="com.lanhuigu.mybatis.entity.User">    
20.      select     
21.         f_id id,    
22.         f_username username,    
23.         f_age age    
24.      from t_user_main     
25.      where f_id = #{id}    
26.   </select>    
27. </mapper>    

MyBatisTest.java测试代码：

[java] view plain copy

1. package com.lanhuigu.mybatis;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5.   
6. import org.apache.ibatis.io.Resources;  
7. import org.apache.ibatis.session.SqlSession;  
8. import org.apache.ibatis.session.SqlSessionFactory;  
9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
10. import org.junit.Test;  
11.   
12. import com.lanhuigu.mybatis.entity.User;  
13.   
14. public class MyBatisTest {  
15.     @Test  
16.     public void testMyBatis() throws IOException {  
17.         SqlSessionFactory sqlSessionFactory = null;// 从SqlSessionFactoryBuilder中获取的SqlSessionFactory工厂实例  
18.         SqlSession session = null;// 从SqlSessionFactory工厂中获取的sqlSession实例，包括了MyBatis操作数据库SQL命令的所有方法  
19.         try {  
20.                  //1.mybatis的配置文件路径,这里放在classpath下，相当于src下  
21.                  String resource = "mybatis-config.xml";  
22.                  //2.读取mybatis配置文件，同时构建SqlSessionFactoryBuilder,然后获取SqlSessionFactory工厂实例  
23.                  //======2.1使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）  
24.                  //InputStream is = MyBatisTest.class.getClassLoader().getResourceAsStream(resource);  
25.                  //构建SqlSessionFactory工厂  
26.                  //sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
27.               
28.                  //======2.2使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）  
29.                  //Reader reader = Resources.getResourceAsReader(resource);   
30.                  //构建SqlSessionFactory工厂  
31.                  //sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);  
32.               
33.                  //======2.3 使用MyBatis提供的Resources类加载mybatis的配置文件  
34.                  InputStream is = Resources.getResourceAsStream(resource);  
35.                  //构建SqlSessionFactory工厂  
36.                  sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
37.               
38.                  //3.从SqlSessionFactory工厂实例获取sqlSession,sqlSession中包含执行sql命令的所有方法  
39.                  session = sqlSessionFactory.openSession();  
40.                 /** 
41.                 * 映射sql的标识字符串: 
42.                 * com.lanhuigu.mybatis.map.UserMainMapper是UserMainMapper.xml文件中mapper标签的namespace属性的值， 
43.                 * queryUserMainById是UserMainMapper.xml文件select标签的id属性值，通过select标签的id属性值， 
44.                 * 通过这两个的组合就可以找到要执行的SQL 
45.                 */  
46.                 //执行查询返回一个唯一user对象的sql，注意："com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById"为映射sql的标识字符串  
47.                 User user = (User)session.selectOne("com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById", 1);  
48.                 System.out.println(user.getUsername());  
49.         } finally {  
50.           session.close();  
51.         }  
52.     }  
53. }  

控制台输出：

对于以上实例，在测试代码中：

User user = (User)session.selectOne("com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById", 1);
System.out.println(user.getUsername());

这段代码使用起来是不是很不爽，我们说过有种更直接的方式：

在项目结构map下加上一个映射接口：

[java] view plain copy

1. package com.lanhuigu.mybatis.map;  
2.   
3. import com.lanhuigu.mybatis.entity.User;  
4.   
5. public interface UserMainMapper {  
6.     public User queryUserMainById(int id);  
7. }  

同时，将测试的代码做如下修改：

[java] view plain copy

1. package com.lanhuigu.mybatis;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5.   
6. import org.apache.ibatis.io.Resources;  
7. import org.apache.ibatis.session.SqlSession;  
8. import org.apache.ibatis.session.SqlSessionFactory;  
9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
10. import org.junit.Test;  
11.   
12. import com.lanhuigu.mybatis.entity.User;  
13. import com.lanhuigu.mybatis.map.UserMainMapper;  
14.   
15. public class MyBatisTest {  
16.     @Test  
17.     public void testMyBatis() throws IOException {  
18.         SqlSessionFactory sqlSessionFactory = null;// 从SqlSessionFactoryBuilder中获取的SqlSessionFactory工厂实例  
19.         SqlSession session = null;// 从SqlSessionFactory工厂中获取的sqlSession实例，包括了MyBatis操作数据库SQL命令的所有方法  
20.         try {  
21.             //1.mybatis的配置文件路径,这里放在classpath下，相当于src下  
22.                 String resource = "mybatis-config.xml";  
23.                //2.读取mybatis配置文件，同时创建SqlSessionFactory工厂实例  
24.                //======2.1使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）  
25.                //InputStream is = MyBatisTest.class.getClassLoader().getResourceAsStream(resource);  
26.                //构建SqlSessionFactory工厂  
27.                //sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
28.               
29.                //======2.2使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）  
30.               //Reader reader = Resources.getResourceAsReader(resource);   
31.               //构建SqlSessionFactory工厂  
32.               //sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);  
33.               
34.               //======2.3 使用MyBatis提供的Resources类加载mybatis的配置文件  
35.               InputStream is = Resources.getResourceAsStream(resource);  
36.               //构建SqlSessionFactory工厂  
37.               sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
38.               
39.               //3.从SqlSessionFactory工厂实例获取sqlSession,sqlSession中包含执行sql命令的所有方法  
40.               session = sqlSessionFactory.openSession();  
41.               /** 
42.                * 映射sql的标识字符串: 
43.                * com.lanhuigu.mybatis.map.UserMainMapper是UserMainMapper.xml文件中mapper标签的namespace属性的值， 
44.                * queryUserMainById是UserMainMapper.xml文件select标签的id属性值，通过select标签的id属性值， 
45.                * 通过这两个的组合就可以找到要执行的SQL 
46.                */  
47.               //执行查询返回一个唯一user对象的sql，注意："com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById"为映射sql的标识字符串  
48.               /*User user = (User) session.selectOne("com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById", 1); 
49.               System.out.println(user.getUsername());*/  
50.   
51.                  UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class);  
52.               User user = userMainMapper.queryUserMainById(1);  
53.               System.out.println(user.getUsername());  
54.         } finally {  
55.           session.close();  
56.         }  
57.     }  
58. }  

把之前的查询部分修改成：

UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class);
User user = userMainMapper.queryUserMainById(1);

使用对于给定语句能够合理描述参数和返回值的接口（比如说UserMainMapper.class），

现在不但可以执行更清晰和类型安全的代码，而且还不用担心易错的字符串字面值以及强制类型转换。

运行测试代码，效果一样。

userMainMapper接口位置：

既然我们加完了接口，mybatis-config.xml对于映射器部分可以换一种配置，直接映射UserMainMapper接口所在包文件：

也就是将<mapper resource="com/lanhuigu/mybatis/map/UserMainMapper.xml"></mapper>

修改成<package name="com.lanhuigu.mybatis.map"/>

完整配置如下，运行测试代码即可检验，这种做法维护更轻松，统一对map进行管理：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  
3. <configuration>  
4.     <environments default="development">  
5.         <environment id="development">  
6.          <transactionManager type="JDBC"/>  
7.          <dataSource type="POOLED">  
8.            <property name="driver" value="com.mysql.jdbc.Driver"/>  
9.            <property name="url" value="jdbc:mysql://192.168.200.12:3306/test_mybatis"/>  
10.            <property name="username" value="root"/>  
11.            <property name="password" value="root123"/>  
12.          </dataSource>  
13.         </environment>  
14.     </environments>  
15.     <mappers>  
16.         <!-- 注册UserMainMapper.xml文件，UserMainMapper.xml位于com.lanhuigu.mybatis.map这个包下，  
17.         所以resource写成com/lanhuigu/mybatis/map/UserMainMapper.xml-->  
18.         <!-- <mapper resource="com/lanhuigu/mybatis/map/UserMainMapper.xml"></mapper> -->  
19.         <package name="com.lanhuigu.mybatis.map"/>  
20.     </mappers>  
21. </configuration>  

以上我们可以看到不管我们怎么玩，sql是不是还在UserMainMapper.xml中映射？

这种方式实现是唯一的吗？难道我必须要用xml?

当然不是了，如果以上你的代码是一路修改下来测试成功的，那么我们再做最后一个修改，

不用UserMainMapper.xml实现映射，我们采用java注解来实现映射。

主要修改的地方是UserMainMapper.java这个接口，新加一个方法queryUserMainByIdNew，用注解实现映射

mybatis自解析接口映射。

修改后的UserMainMapper.java接口：

[java] view plain copy

1. package com.lanhuigu.mybatis.map;  
2.   
3. import org.apache.ibatis.annotations.Param;  
4. import org.apache.ibatis.annotations.Select;  
5.   
6. import com.lanhuigu.mybatis.entity.User;  
7.   
8. public interface UserMainMapper {  
9.     /** 
10.      * xml 
11.      */  
12.     public User queryUserMainById(int id);  
13.     /** 
14.      * java注解 
15.      */  
16.     @Select("select f_id id,f_username username,f_age age from t_user_main where f_id = ${id} ")  
17.     public User queryUserMainByIdNew(@Param("id") int id);  
18. }  

修改后的测试代码，运行感受下：

[java] view plain copy

1. package com.lanhuigu.mybatis;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5.   
6. import org.apache.ibatis.io.Resources;  
7. import org.apache.ibatis.session.SqlSession;  
8. import org.apache.ibatis.session.SqlSessionFactory;  
9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
10. import org.junit.Test;  
11.   
12. import com.lanhuigu.mybatis.entity.User;  
13. import com.lanhuigu.mybatis.map.UserMainMapper;  
14.   
15. public class MyBatisTest {  
16.     @Test  
17.     public void testMyBatis() throws IOException {  
18.         SqlSessionFactory sqlSessionFactory = null;// 从SqlSessionFactoryBuilder中获取的SqlSessionFactory工厂实例  
19.         SqlSession session = null;// 从SqlSessionFactory工厂中获取的sqlSession实例，包括了MyBatis操作数据库SQL命令的所有方法  
20.         try {  
21.             //1.mybatis的配置文件路径,这里放在classpath下，相当于src下  
22.             String resource = "mybatis-config.xml";  
23.             //2.读取mybatis配置文件，同时创建SqlSessionFactory工厂实例  
24.             //======2.1使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）  
25.             //InputStream is = MyBatisTest.class.getClassLoader().getResourceAsStream(resource);  
26.             //构建SqlSessionFactory工厂  
27.             //sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
28.               
29.             //======2.2使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）  
30.             //Reader reader = Resources.getResourceAsReader(resource);   
31.             //构建SqlSessionFactory工厂  
32.             //sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);  
33.               
34.             //======2.3 使用MyBatis提供的Resources类加载mybatis的配置文件  
35.             InputStream is = Resources.getResourceAsStream(resource);  
36.             //构建SqlSessionFactory工厂  
37.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
38.               
39.             //3.从SqlSessionFactory工厂实例获取sqlSession,sqlSession中包含执行sql命令的所有方法  
40.             session = sqlSessionFactory.openSession();  
41.             /** 
42.              * 映射sql的标识字符串: 
43.              * com.lanhuigu.mybatis.map.UserMainMapper是UserMainMapper.xml文件中mapper标签的namespace属性的值， 
44.              * queryUserMainById是UserMainMapper.xml文件select标签的id属性值，通过select标签的id属性值， 
45.              * 通过这两个的组合就可以找到要执行的SQL 
46.              */  
47.             //执行查询返回一个唯一user对象的sql，注意："com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById"为映射sql的标识字符串  
48.             /*User user = session.selectOne("com.lanhuigu.mybatis.map.UserMainMapper.queryUserMainById", 1); 
49.             System.out.println(user.getUsername());*/  
50.               
51.             /*UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class); 
52.             User user = userMainMapper.queryUserMainById(1); 
53.             System.out.println(user.getUsername());*/  
54.               
55.             UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class);  
56.             User user = userMainMapper.queryUserMainByIdNew(1);  
57.             System.out.println(user.getUsername());  
58.         } finally {  
59.           session.close();  
60.         }  
61.     }  
62. }