基于MyBatis3.0.6的基本操作介绍

你的名字 2022-08-09 17:31 130阅读 0赞

每 一 个 MyBatis 的 应 用 程 序 都 以 一 个 SqlSessionFactory 对 象 的 实 例 为 核 心 。SqlSessionFactory本身是由SqlSessionFactoryBuilder创建的，一般而言，在一个应用中，一个数据库只会对应一个SqlSessionFactory，所以一般我们都把SqlSessionFactory定义成单例模式，或通过Spring等进行注入。

SqlSessionFactoryBuilder创建SqlSessionFactory的方法有：

Java代码   ![收藏代码][icon_star.png]

1.  SqlSessionFactory build(InputStream inputStream)  
2.  SqlSessionFactory build(InputStream inputStream, String environment)  
3.  SqlSessionFactory build(InputStream inputStream, Properties properties)  
4.  SqlSessionFactory build(InputStream inputStream, String env, Properties props)  
5.  SqlSessionFactory build(Configuration config)

这些方法主要设计到的参数有InputStream，environment，properties，其中InputStream是从配置文件中获取的一个输入流；environment表示在配置文件里面配置的众多的environment中，当前要使用的是哪一个environment，包括数据源和事务，缺省则使用默认的environment；使用properties，MyBatis则会加载对应的属性或文件，它们可以在配置文件中使用。

从XML中构建SqlSessionFactory

Java代码   ![收藏代码][icon_star.png]

1.  **private** **static** SqlSessionFactory sqlSessionFactory = **null**;  
2.        
3.      **static** \{  
4.          **try** \{  
5.              InputStream is = Resources.getResourceAsStream("config/mybatis\_config.xml");  
6.              sqlSessionFactory = **new** SqlSessionFactoryBuilder().build(is);  
7.          \} **catch** (IOException e) \{  
8.              // TODO Auto-generated catch block  
9.              e.printStackTrace();  
10.         \}  
11.           
12.     \}  
13.       
14.     **public** **static** SqlSessionFactory getSqlSessionFactory() \{  
15.         **return** sqlSessionFactory;  
16.     \}

下面讲讲配置文件的基本结构：

mybatis的配置文件一般包括如下几个部分：

properties：properties用于定义或导入属性，然后在后面的环境中使用

settings:settings用于设置一些mybatis在运行时的行为方式，具体的设置信息可以查看mybatis的文档

typeAliases:typeAliases是为系统中的Java类型指定一个较短的别名

environments:MyBatis 可以配置多种环境。这会帮助你将 SQL 映射应用于多种数据库之中。

Xml代码   ![收藏代码][icon_star.png]

1.  **<****environments** default="development"**>**  
2.          **<****environment** id="development"**>**  
3.              **<****transactionManager** type="JDBC" **/>**  
4.              **<****dataSource** type="POOLED"**>**  
5.                  **<****property** name="driver" value="$\{jdbc.driver\}" **/>**  
6.                  **<****property** name="url" value="$\{jdbc.url\}" **/>**  
7.                  **<****property** name="username" value="$\{jdbc.username\}" **/>**  
8.                  **<****property** name="password" value="$\{jdbc.password\}" **/>**  
9.              **</****dataSource****>**  
10.         **</****environment****>**  
11.     **</****environments****>**

由于MyBatis可以配置多个environment，所以可以在创建SqlSessionFactory的时候指定具体的环境来创建特定的环境下的SqlSessionFactory，  不指定则使用默认的环境。

**transactionManager**

在 MyBatis 中有两种事务管理器类型(也就是 type=”\[JDBC|MANAGED\]”):

*  JDBC – 这个配置直接简单使用了 JDBC 的提交和回滚设置。 它依赖于从数据源得 到的连接来管理事务范围。
 *  MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让 容器来管理事务的整个生命周期(比如 Spring 或 JEE 应用服务器的上下文) 默认 情况下它会关闭连接。 然而一些容器并不希望这样, 因此如果你需要从连接中停止 它,将 closeConnection 属性设置为 false。

**dataSource**

dataSource 元素使用基本的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

*  许多 MyBatis 的应用程序将会按示例中的例子来配置数据源。 然而它并不是必须的。 要知道为了方便使用延迟加载,数据源才是必须的。

有三种内建的数据源类型(也就是 type=”???”):

**UNPOOLED** – 这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢, 这是对简单应用程序的一个很好的选择, 因为它不需要及时的可用连接。 不同的数据库对这 个的表现也是不一样的, 所以对某些数据库来说配置数据源并不重要, 这个配置也是闲置的。 UNPOOLED 类型的数据源仅仅用来配置以下 5 种属性:

*  driver – 这是 JDBC 驱动的 Java 类的完全限定名(如果你的驱动包含,它也不是 数据源类)。
 *  url – 这是数据库的 JDBC URL 地址。
 *  username – 登录数据库的用户名。
 *  password – 登录数据库的密码。
 *  defaultTransactionIsolationLevel – 默认的连接事务隔离级别。

作为可选项,你可以传递数据库驱动的属性。要这样做,属性的前缀是以“driver.”开 头的,例如:

*  driver.encoding=UTF8

这 样 就 会 传 递 以 值 “ UTF8 ” 来 传 递 属 性 “ encoding ”, 它 是 通 过 DriverManager.getConnection(url,driverProperties)方法传递给数据库驱动。

**POOLED** – 这是 JDBC 连接对象的数据源连接池的实现,用来避免创建新的连接实例 时必要的初始连接和认证时间。这是一种当前 Web 应用程序用来快速响应请求很流行的方 法。

除了上述(UNPOOLED)的属性之外,还有很多属性可以用来配置 POOLED 数据源:

*  poolMaximumActiveConnections – 在任意时间存在的活动(也就是正在使用)连 接的数量。默认值:10
 *  poolMaximumIdleConnections – 任意时间存在的空闲连接数。
 *  poolMaximumCheckoutTime – 在被强制返回之前,池中连接被检查的时间。默认 值:20000 毫秒(也就是 20 秒)
 *  poolTimeToWait – 这是给连接池一个打印日志状态机会的低层次设置,还有重新 尝试获得连接, 这些情况下往往需要很长时间 为了避免连接池没有配置时静默失 败)。默认值:20000 毫秒(也就是 20 秒)
 *  poolPingQuery – 发送到数据的侦测查询,用来验证连接是否正常工作,并且准备 接受请求。默认是“NO PING QUERY SET” ,这会引起许多数据库驱动连接由一 个错误信息而导致失败。
 *  poolPingEnabled – 这是开启或禁用侦测查询。如果开启,你必须用一个合法的 SQL 语句(最好是很快速的)设置 poolPingQuery 属性。默认值:false。
 *  poolPingConnectionsNotUsedFor – 这是用来配置 poolPingQuery 多次时间被用一次。 这可以被设置匹配标准的数据库连接超时时间, 来避免不必要的侦测。 默认值: 0(也就是所有连接每一时刻都被侦测-但仅仅当 poolPingEnabled 为 true 时适用)。

**JNDI** – 这个数据源的实现是为了使用如 Spring 或应用服务器这类的容器, 容器可以集 中或在外部配置数据源,然后放置一个 JNDI 上下文的引用。这个数据源配置只需要两个属 性:

*  initial\_context – 这 个 属 性 用 来 从 初 始 上 下 文 中 寻 找 环 境 ( 也 就 是 initialContext.lookup(initial——context) 。这是个可选属性,如果被忽略,那么 data\_source 属性将会直接以 initialContext 为背景再次寻找。
 *  data\_source – 这是引用数据源实例位置的上下文的路径。它会以由 initial\_context 查询返回的环境为背景来查找,如果 initial\_context 没有返回结果时,直接以初始 上下文为环境来查找。

再之后就是Mapper了，Mapper就是映射SQL语句的，首先要告诉mybatis要到哪里去找这些SQL语句，即指定资源位置。

Java代码   ![收藏代码][icon_star.png]

1.  <mappers>  
2.          <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>  
3.      </mappers>

下面是我在测试过程中的一个简单的配置文件：

Xml代码   ![收藏代码][icon_star.png]

1.  **<?****xml** version="1.0" encoding="UTF-8" **?>**  
2.  <!DOCTYPE configuration  
3.    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
4.    "http://mybatis.org/dtd/mybatis-3-config.dtd"**>**  
5.  **<****configuration****>**  
6.      **<****properties** resource="config/jdbc.properties"**>****</****properties****>**  
7.      **<****typeAliases****>**  
8.          **<****typeAlias** alias="Blog" type="com.tiantian.mybatis.model.Blog"**/>**  
9.      **</****typeAliases****>**  
10.     **<****environments** default="development"**>**  
11.         **<****environment** id="development"**>**  
12.             **<****transactionManager** type="JDBC" **/>**  
13.             **<****dataSource** type="POOLED"**>**  
14.                 **<****property** name="driver" value="$\{jdbc.driver\}" **/>**  
15.                 **<****property** name="url" value="$\{jdbc.url\}" **/>**  
16.                 **<****property** name="username" value="$\{jdbc.username\}" **/>**  
17.                 **<****property** name="password" value="$\{jdbc.password\}" **/>**  
18.             **</****dataSource****>**  
19.         **</****environment****>**  
20.     **</****environments****>**  
21.     **<****mappers****>**  
22.         **<****mapper** resource="com/tiantian/mybatis/model/BlogMapper.xml"**/>**  
23.     **</****mappers****>**  
24. **</****configuration****>**

在上面配置文件中导入了一个外部的属性文件，MyBatis配置文件中的属性引入可以是直接包含在properties元素中的，也可以是利用properties元素从外部引入的，还可以是在创建SqlSessionFactory的时候，作为一个参数properties传入。既然MyBatis配置文件中的属性可以从这么多地方引入，那就牵涉到一个优先级的问题，MyBatis将会按照下面的顺序来寻找它们：

*  先是配置文件中，properties元素体中的属性被读取
 *  再是利用properties元素从外部引入的属性文件中的属性被读取，会覆盖前面读取的相同的属性
 *  最后是创建SqlSessionFactory时传入的properties中的属性被读取，同样会覆盖前面相同的属性

在有了SqlSessionFactory之后就是获取特定的SqlSession了，在使用mybatis的过程中每一个操作都是离不开SqlSession的，所以获取SqlSession是相当重要的。此外，SqlSession是不能被共享、线程不安全的，所以在每次需要SqlSession的时候都应该打开一个，然后在用完了之后再把它关上。

Java代码   ![收藏代码][icon_star.png]

1.  SqlSession session = sqlSessionFactory.openSession();

SqlSessionFactory中湖区SqlSession的方法有：

Java代码   ![收藏代码][icon_star.png]

1.  SqlSession openSession()  
2.  SqlSession openSession(**boolean** autoCommit)  
3.  SqlSession openSession(Connection connection)  
4.  SqlSession openSession(TransactionIsolationLevel level)  
5.  SqlSession openSession(ExecutorType execType,TransactionIsolationLevel level)  
6.  SqlSession openSession(ExecutorType execType)  
7.  SqlSession openSession(ExecutorType execType, **boolean** autoCommit)  
8.  SqlSession openSession(ExecutorType execType, Connection connection)  
9.  Configuration getConfiguration();

它们的主要区别在于：

*  **Transaction (事务)**: 你想为 session 使用事务或者使用自动提交
 *  **Connection (连接)**: 你想 MyBatis 获得来自配置的数据源的连接还是提供你自己
 *  **Execution (执行)**: 你想 MyBatis 复用预处理语句和/或批量更新语句(包括插入和 删除)

默认的opensession方法没有参数，它会创建有如下特性的SqlSession：

*  会开启一个事务，也就是不自动提交
 *  连接对象会从当前正在使用的environment中的数据源中得到
 *  事务隔离级别将会使用驱动或数据源的默认值
 *  预处理语句不会被复用，也不会批量更新语句

ExecutorType有三个值：

*  ExecutorType.SIMPLE 它会为每个语句的执行创建一个新的预处理语句
 *  ExecutorType.REUSE 它会复用预处理语句
 *  ExecutorType.BATCH 这个执行器会批量执行更新语句

mybatis的基本操作就是增、删、改、查，即insert、delete、update和select。在进行这些基本的操作的时候可以直接利用SqlSession访问Mapper配置文件里面的映射来进行，也可以利用与Mapper配置文件相对应的Mapper接口来进行操作，条件是Mapper接口中定义的方法的参数和返回值要与Mapper配置文件中定义的参数和返回值相同。此外，在使用Mapper接口的时候，对应的SQL语句是可以写在Mapper配置文件中的，也可以直接利用对应的注解在Mapper接口中对应的方法上进行标明，这将在下面的示例代码中看到。

下面是一系列的示例代码：

先贴一个用于获取SqlSessionFactory的工具类：

Java代码   ![收藏代码][icon_star.png]

1.  **import** java.io.IOException;  
2.  **import** java.io.InputStream;  
3.    
4.  **import** org.apache.ibatis.io.Resources;  
5.  **import** org.apache.ibatis.session.SqlSessionFactory;  
6.  **import** org.apache.ibatis.session.SqlSessionFactoryBuilder;  
7.    
8.  **public** **class** Util \{  
9.        
10.     **private** **static** SqlSessionFactory sqlSessionFactory = **null**;  
11.       
12.     **static** \{  
13.         **try** \{  
14.             InputStream is = Resources.getResourceAsStream("config/mybatis\_config.xml");  
15.             sqlSessionFactory = **new** SqlSessionFactoryBuilder().build(is);  
16.         \} **catch** (IOException e) \{  
17.             // TODO Auto-generated catch block  
18.             e.printStackTrace();  
19.         \}  
20.           
21.     \}  
22.       
23.     **public** **static** SqlSessionFactory getSqlSessionFactory() \{  
24.         **return** sqlSessionFactory;  
25.     \}  
26.       
27. \}

mybatis的配置文件：

Xml代码   ![收藏代码][icon_star.png]

BlogMapper.xml

Xml代码   ![收藏代码][icon_star.png]

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.  **<****mapper** namespace="com.tiantian.mybatis.model.BlogMapper"**>**  
7.    
8.      **<****insert** id="insertBlog" parameterType="Blog"**>**  
9.          insert into t\_blog(title,content,owner) values(\#\{title\},\#\{content\},\#\{owner\})  
10.     **</****insert****>**  
11.   
12.     **<****select** id="selectBlog" parameterType="int" resultType="Blog"**>**  
13.         select \* from t\_blog where id = \#\{id\}  
14.     **</****select****>**  
15.   
16.     **<****update** id="updateBlog" parameterType="Blog"**>**  
17.         update t\_blog set title = \#\{title\},content = \#\{content\},owner = \#\{owner\} where id = \#\{id\}  
18.     **</****update****>**  
19.   
20.     **<****select** id="selectAll" resultType="Blog"**>**  
21.         select \* from t\_blog  
22.     **</****select****>**  
23.   
24.     **<****select** id="fuzzyQuery" resultType="Blog" parameterType="java.lang.String"**>**  
25.         select \* from t\_blog where title like "%"\#\{title\}"%"  
26.     **</****select****>**  
27.   
28.     **<****delete** id="deleteBlog" parameterType="int"**>**  
29.         delete from t\_blog where id = \#\{id\}  
30.     **</****delete****>**  
31. **</****mapper****>**

**SQL映射语句中一些应该注意的问题：**

1.   resultType的值应该是返回类型的完全名或别名，当返回的结果是一个集合的时候，resultType应为集合中所包含的类型，而不是集合类型，如上面的Blog
2.  resultType和resultMap都是表示指定返回结果的，但两者不能同时使用
3.  对于Insert映射语句有一个useGeneratedKeys属性，该属性的**默认值为false，**当该属性的值为true时，在进行插入操作时，mybatis会取到当前正在插入的记录在数据库中的自动递增的主键值，并把它设置给指定的实体的属性，这就需要设置一个keyProperty属性，用于指定实体中表示主键的属性

Blog.java

Java代码   ![收藏代码][icon_star.png]

1.  **package** com.tiantian.mybatis.model;  
2.    
3.  **public** **class** Blog \{  
4.    
5.      **private** **int** id;  
6.    
7.      **private** String title;  
8.    
9.      **private** String content;  
10.   
11.     **private** String owner;  
12.   
13.     **public** **int** getId() \{  
14.         **return** id;  
15.     \}  
16.   
17.     **public** **void** setId(**int** id) \{  
18.         **this**.id = id;  
19.     \}  
20.   
21.     **public** String getTitle() \{  
22.         **return** title;  
23.     \}  
24.   
25.     **public** **void** setTitle(String title) \{  
26.         **this**.title = title;  
27.     \}  
28.   
29.     **public** String getContent() \{  
30.         **return** content;  
31.     \}  
32.   
33.     **public** **void** setContent(String content) \{  
34.         **this**.content = content;  
35.     \}  
36.   
37.     **public** String getOwner() \{  
38.         **return** owner;  
39.     \}  
40.   
41.     **public** **void** setOwner(String owner) \{  
42.         **this**.owner = owner;  
43.     \}  
44.   
45.     @Override  
46.     **public** String toString() \{  
47.         **return** "id: " + id + ", title: " + title + ", content: " + content  
48.                 + ", owner: " + owner;  
49.     \}  
50.   
51. \}

BlogMapper.java

Java代码   ![收藏代码][icon_star.png]

1.  **package** com.tiantian.mybatis.model;  
2.    
3.  **import** java.util.List;  
4.    
5.  **import** org.apache.ibatis.annotations.Delete;  
6.  **import** org.apache.ibatis.annotations.Insert;  
7.  **import** org.apache.ibatis.annotations.Select;  
8.  **import** org.apache.ibatis.annotations.Update;  
9.    
10. /\*\* 
11.  \* 以下的操作1都是把SQL写在配置文件里面的，而操作2都是直接用注解标明要执行的SQL语句 
12.  \* 因为该Mapper的全名跟BlogMapper.xml文件里面的namespace是一样的，所以不能在这里面 
13.  \* 用注解定义一个与BlogMapper.xml文件里面同名的映射 
14.  \* @author andy 
15.  \* 
16.  \*/  
17. **public** **interface** BlogMapper \{  
18.   
19.     **public** Blog selectBlog(**int** id);  
20.       
21.     @Select("select \* from t\_blog where id = \#\{id\}")  
22.     **public** Blog selectBlog2(**int** id);  
23.       
24.     **public** **void** insertBlog(Blog blog);  
25.       
26.     @Insert("insert into t\_blog(title,content,owner) values(\#\{title\},\#\{content\},\#\{owner\})")  
27.     **public** **void** insertBlog2(Blog blog);  
28.       
29.     **public** **void** updateBlog(Blog blog);  
30.       
31.     @Update("update t\_blog set title=\#\{title\},content=\#\{content\},owner=\#\{owner\} where id=\#\{id\}")  
32.     **public** **void** updateBlog2(Blog blog);  
33.       
34.     **public** **void** deleteBlog(**int** id);   
35.       
36.     @Delete("delete from t\_blog where id = \#\{id\}")  
37.     **public** **void** deleteBlog2(**int** id);  
38.       
39.     **public** List<Blog> selectAll();  
40.       
41.     @Select("select \* from t\_blog")  
42.     **public** List<Blog> selectAll2();  
43.       
44.     **public** List<Blog> fuzzyQuery(String title);  
45.       
46.     @Select("select \* from t\_blog where title like \\"%\\"\#\{title\}\\"%\\"")  
47.     **public** List<Blog> fuzzyQuery2(String title);  
48.       
49. \}

Test1.java

Java代码   ![收藏代码][icon_star.png]

1.  **package** com.tiantian.mybatis.test;  
2.    
3.  **import** java.util.List;  
4.    
5.  **import** org.apache.ibatis.session.SqlSession;  
6.  **import** org.junit.Test;  
7.    
8.  **import** com.tiantian.mybatis.model.Blog;  
9.  **import** com.tiantian.mybatis.util.Util;  
10.   
11. /\*\* 
12.  \* 该系列操作是通过把SQL写在配置文件里面， 
13.  \* 然后利用SqlSession进行操作的 
14.  \* @author andy 
15.  \* 
16.  \*/  
17. **public** **class** Test1 \{  
18.   
19.     /\*\* 
20.      \* 新增记录 
21.      \*/  
22.     @Test  
23.     **public** **void** testInsertBlog() \{  
24.         SqlSession session = Util.getSqlSessionFactory().openSession();  
25.         Blog blog = **new** Blog();  
26.         blog.setTitle("中国人");  
27.         blog.setContent("五千年的风和雨啊藏了多少梦");  
28.         blog.setOwner("天天");  
29.         session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog", blog);  
30.         session.commit();  
31.         session.close();  
32.     \}  
33.       
34.     /\*\* 
35.      \* 查询单条记录 
36.      \*/  
37.     @Test  
38.     **public** **void** testSelectOne() \{  
39.         SqlSession session = Util.getSqlSessionFactory().openSession();  
40.         Blog blog = (Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog", 8);  
41.         System.out.println(blog);  
42.         session.close();  
43.     \}  
44.       
45.     /\*\* 
46.      \* 修改记录 
47.      \*/  
48.     @Test  
49.     **public** **void** testUpdateBlog() \{  
50.         SqlSession session = Util.getSqlSessionFactory().openSession();  
51.         Blog blog = **new** Blog();  
52.         blog.setId(7);//需要修改的Blog的id  
53.         blog.setTitle("中国人2");//修改Title  
54.         blog.setContent("黄色的脸，黑色的眼，不变是笑容");//修改Content  
55.         blog.setOwner("天天2");//修改Owner  
56.         session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog", blog);  
57.         session.commit();  
58.         session.close();  
59.     \}  
60.       
61.     /\*\* 
62.      \* 查询所有的记录 
63.      \*/  
64.     @Test  
65.     **public** **void** testSelectAll() \{  
66.         SqlSession session = Util.getSqlSessionFactory().openSession();  
67.         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");  
68.         **for** (Blog blog:blogs)  
69.             System.out.println(blog);  
70.         session.close();  
71.     \}  
72.       
73.     /\*\* 
74.      \* 模糊查询 
75.      \*/  
76.     @Test  
77.     **public** **void** testFuzzyQuery() \{  
78.         SqlSession session = Util.getSqlSessionFactory().openSession();  
79.         String title = "中国";  
80.         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery", title);  
81.         **for** (Blog blog:blogs)  
82.             System.out.println(blog);  
83.         session.close();  
84.     \}  
85.       
86.     /\*\* 
87.      \* 删除记录 
88.      \*/  
89.     @Test  
90.     **public** **void** testDeleteBlog() \{  
91.         SqlSession session = Util.getSqlSessionFactory().openSession();  
92.         session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog", 8);  
93.         session.commit();  
94.         session.close();  
95.     \}  
96.       
97. \}

Test2.java

Java代码   ![收藏代码][icon_star.png]

1.  **package** com.tiantian.mybatis.test;  
2.    
3.  **import** java.util.List;  
4.    
5.  **import** org.apache.ibatis.session.SqlSession;  
6.  **import** org.junit.Test;  
7.    
8.  **import** com.tiantian.mybatis.model.Blog;  
9.  **import** com.tiantian.mybatis.model.BlogMapper;  
10. **import** com.tiantian.mybatis.util.Util;  
11.   
12. /\*\* 
13.  \* 该系列操作是将SQL语句写在配置文件里面， 
14.  \* 然后通过对应Mapper接口来进行操作的 
15.  \* @author andy 
16.  \* 
17.  \*/  
18. **public** **class** Test2 \{  
19.   
20.     /\*\* 
21.      \* 新增记录 
22.      \*/  
23.     @Test  
24.     **public** **void** testInsertBlog() \{  
25.         SqlSession session = Util.getSqlSessionFactory().openSession();  
26.         Blog blog = **new** Blog();  
27.         blog.setTitle("中国人");  
28.         blog.setContent("五千年的风和雨啊藏了多少梦");  
29.         blog.setOwner("天天");  
30.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
31.         blogMapper.insertBlog(blog);  
32.         session.commit();  
33.         session.close();  
34.     \}  
35.   
36.     /\*\* 
37.      \* 查询单条记录 
38.      \*/  
39.     @Test  
40.     **public** **void** testSelectOne() \{  
41.         SqlSession session = Util.getSqlSessionFactory().openSession();  
42.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
43.         Blog blog = blogMapper.selectBlog(7);  
44.         System.out.println(blog);  
45.         session.close();  
46.     \}  
47.   
48.     /\*\* 
49.      \* 修改记录 
50.      \*/  
51.     @Test  
52.     **public** **void** testUpdateBlog() \{  
53.         SqlSession session = Util.getSqlSessionFactory().openSession();  
54.         Blog blog = **new** Blog();  
55.         blog.setId(9);// 需要修改的Blog的id  
56.         blog.setTitle("中国人2");// 修改Title  
57.         blog.setContent("黄色的脸，黑色的眼，不变是笑容");// 修改Content  
58.         blog.setOwner("天天2");// 修改Owner  
59.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
60.         blogMapper.updateBlog(blog);  
61.         session.commit();  
62.         session.close();  
63.     \}  
64.   
65.     /\*\* 
66.      \* 查询所有记录 
67.      \*/  
68.     @Test  
69.     **public** **void** testSelectAll() \{  
70.         SqlSession session = Util.getSqlSessionFactory().openSession();  
71.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
72.         List<Blog> blogs = blogMapper.selectAll();  
73.         **for** (Blog blog : blogs)  
74.             System.out.println(blog);  
75.         session.close();  
76.     \}  
77.   
78.     /\*\* 
79.      \* 模糊查询 
80.      \*/  
81.     @Test  
82.     **public** **void** testFuzzyQuery() \{  
83.         SqlSession session = Util.getSqlSessionFactory().openSession();  
84.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
85.         String title = "中国";  
86.         List<Blog> blogs = blogMapper.fuzzyQuery(title);  
87.         **for** (Blog blog : blogs)  
88.             System.out.println(blog);  
89.         session.close();  
90.     \}  
91.   
92.     /\*\* 
93.      \* 删除记录 
94.      \*/  
95.     @Test  
96.     **public** **void** testDeleteBlog() \{  
97.         SqlSession session = Util.getSqlSessionFactory().openSession();  
98.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
99.         blogMapper.deleteBlog(10);  
100.         session.commit();  
101.         session.close();  
102.     \}  
103.   
104. \}

Test3.java

Java代码   ![收藏代码][icon_star.png]

1.  **package** com.tiantian.mybatis.test;  
2.    
3.  **import** java.util.List;  
4.    
5.  **import** org.apache.ibatis.session.SqlSession;  
6.  **import** org.junit.Test;  
7.    
8.  **import** com.tiantian.mybatis.model.Blog;  
9.  **import** com.tiantian.mybatis.model.BlogMapper;  
10. **import** com.tiantian.mybatis.util.Util;  
11.   
12. /\*\* 
13.  \* 该系列操作是利用Mapper接口来进行的 
14.  \* ，然而其相应的SQL语句是通过对应的 
15.  \* 注解Annotation在Mapper中对应的方法上定义的 
16.  \* @author andy 
17.  \* 
18.  \*/  
19. **public** **class** Test3 \{  
20.   
21.     /\*\* 
22.      \* 新增记录 
23.      \*/  
24.     @Test  
25.     **public** **void** testInsert() \{  
26.         SqlSession session = Util.getSqlSessionFactory().openSession();  
27.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
28.         Blog blog = **new** Blog();  
29.         blog.setTitle("title2");  
30.         blog.setContent("content2");  
31.         blog.setOwner("owner2");  
32.         blogMapper.insertBlog2(blog);  
33.         session.commit();  
34.         session.close();  
35.     \}  
36.       
37.     /\*\* 
38.      \* 查找单条记录 
39.      \*/  
40.     @Test  
41.     **public** **void** testSelectOne() \{  
42.         SqlSession session = Util.getSqlSessionFactory().openSession();  
43.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
44.         Blog blog = blogMapper.selectBlog2(1);  
45.         System.out.println(blog);  
46.         session.close();  
47.     \}  
48.       
49.     /\*\* 
50.      \* 查找多条记录，返回结果为一集合 
51.      \*/  
52.     @Test  
53.     **public** **void** testSelectAll() \{  
54.         SqlSession session = Util.getSqlSessionFactory().openSession();  
55.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
56.         List<Blog> blogs = blogMapper.selectAll2();  
57.         **for** (Blog blog:blogs)  
58.             System.out.println(blog);  
59.         session.close();  
60.     \}  
61.       
62.     /\*\* 
63.      \* 修改某条记录 
64.      \*/  
65.     @Test  
66.     **public** **void** testUpdate() \{  
67.         SqlSession session = Util.getSqlSessionFactory().openSession();  
68.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
69.         Blog blog = **new** Blog();  
70.         blog.setId(3);  
71.         blog.setTitle("title3");  
72.         blog.setContent("content3");  
73.         blog.setOwner("owner3");  
74.         blogMapper.updateBlog2(blog);  
75.         session.commit();  
76.         session.close();  
77.     \}  
78.       
79.     /\*\* 
80.      \* 删除记录 
81.      \*/  
82.     @Test  
83.     **public** **void** testDelete() \{  
84.         SqlSession session = Util.getSqlSessionFactory().openSession();  
85.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
86.         blogMapper.deleteBlog2(5);  
87.         session.commit();  
88.         session.close();  
89.     \}  
90.       
91.     @Test  
92.     **public** **void** testFuzzyQuery() \{  
93.         SqlSession session = Util.getSqlSessionFactory().openSession();  
94.         BlogMapper blogMapper = session.getMapper(BlogMapper.**class**);  
95.         List<Blog> blogs = blogMapper.fuzzyQuery2("中国");  
96.         **for** (Blog blog:blogs)  
97.             System.out.println(blog);  
98.         session.close();  
99.     \}  
100.       
101. \}

对应的建表语句：

Java代码   ![收藏代码][icon_star.png]

1.  CREATE TABLE \`t\_blog\` (  
2.    \`id\` **int**(11) NOT NULL AUTO\_INCREMENT,  
3.    \`title\` varchar(255) DEFAULT NULL,  
4.    \`content\` varchar(255) DEFAULT NULL,  
5.    \`owner\` varchar(50) DEFAULT NULL,  
6.    PRIMARY KEY (\`id\`)  
7.  )

[icon_star.png]: /images/20220731/997dcfeabbed41f3a66dd00690a59368.png