每 一 个 MyBatis 的 应 用 程 序 都 以 一 个 SqlSessionFactory 对 象 的 实 例 为 核 心 。

SqlSessionFactory本身是由SqlSessionFactoryBuilder创建的，一般而言。在一个应用中，一个数据库仅仅会相应一个SqlSessionFactory。所以一般我们都把SqlSessionFactory定义成单例模式。或通过Spring等进行注入。

SqlSessionFactoryBuilder创建SqlSessionFactory的方法有：

 

 SqlSessionFactory build(InputStream inputStream)
 SqlSessionFactory build(InputStream inputStream, String environment)
 SqlSessionFactory build(InputStream inputStream, Properties properties)
 SqlSessionFactory build(InputStream inputStream, String env, Properties props)
 SqlSessionFactory build(Configuration config)

 

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

 

 

从XML中构建SqlSessionFactory

 

 private static SqlSessionFactory sqlSessionFactory = null;

     static {
         try {
             InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

     public static SqlSessionFactory getSqlSessionFactory() {
         return sqlSessionFactory;
     }

 

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

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

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

settings:settings用于设置一些mybatis在执行时的行为方式。详细的设置信息能够查看mybatis的文档

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

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

 

 <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC" />
             <dataSource type="POOLED">
                 <property name="driver" value="${jdbc.driver}" />
                 <property name="url" value="${jdbc.url}" />
                 <property name="username" value="${jdbc.username}" />
                 <property name="password" value="${jdbc.password}" />
             </dataSource>
         </environment>
     </environments>

因为MyBatis能够配置多个environment，所以能够在创建SqlSessionFactory的时候指定详细的环境来创建特定的环境下的SqlSessionFactory，  不指定则使用默认的环境。

 

 

transactionManager

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

• JDBC – 这个配置直接简单使用了 JDBC 的提交和回滚设置。

  它依赖于从数据源得 到的连接来管理事务范围。

• MANAGED – 这个配置差点儿没做什么。它从来不提交或回滚一个连接。而它会让 容器来管理事务的整个生命周期(比方 Spring 或 JEE 应用server的上下文) 默认 情况下它会关闭连接。 然而一些容器并不希望这样, 因此假设你须要从连接中停止 它,将 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 或应用server这类的容器, 容器能够集 中或在外部配置数据源,然后放置一个 JNDI 上下文的引用。

这个数据源配置仅仅须要两个属 性:

• initial_context – 这 个 属 性 用 来 从 初 始 上 下 文 中 寻 找 环 境 ( 也 就 是 initialContext.lookup(initial——context) 。这是个可选属性,假设被忽略,那么 data_source 属性将会直接以 initialContext 为背景再次寻找。

• data_source – 这是引用数据源实例位置的上下文的路径。它会以由 initial_context 查询返回的环境为背景来查找,假设 initial_context 没有返回结果时,直接以初始 上下文为环境来查找。

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

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

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

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration
   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
     <properties resource="config/jdbc.properties"></properties>
     <typeAliases>
         <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
     </typeAliases>
     <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC" />
             <dataSource type="POOLED">
                 <property name="driver" value="${jdbc.driver}" />
                 <property name="url" value="${jdbc.url}" />
                 <property name="username" value="${jdbc.username}" />
                 <property name="password" value="${jdbc.password}" />
             </dataSource>
         </environment>
     </environments>
     <mappers>
         <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
     </mappers>
 </configuration>

 

在上面配置文件里导入了一个外部的属性文件，MyBatis配置文件里的属性引入能够是直接包括在properties元素中的，也能够是利用properties元素从外部引入的。还能够是在创建SqlSessionFactory的时候，作为一个參数properties传入。

既然MyBatis配置文件里的属性能够从这么多地方引入，那就牵涉到一个优先级的问题。MyBatis将会依照以下的顺序来寻找它们：

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

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

 SqlSession session = sqlSessionFactory.openSession();

 

SqlSessionFactory中湖区SqlSession的方法有：

 SqlSession openSession()
 SqlSession openSession(boolean autoCommit)
 SqlSession openSession(Connection connection)
 SqlSession openSession(TransactionIsolationLevel level)
 SqlSession openSession(ExecutorType execType,TransactionIsolationLevel level)
 SqlSession openSession(ExecutorType execType)
 SqlSession openSession(ExecutorType execType, boolean autoCommit)
 SqlSession openSession(ExecutorType execType, Connection connection)
 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的工具类：

 import java.io.IOException;
 import java.io.InputStream;

 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;

 public class Util {

     private static SqlSessionFactory sqlSessionFactory = null;

     static {
         try {
             InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

     public static SqlSessionFactory getSqlSessionFactory() {
         return sqlSessionFactory;
     }

 }

 

mybatis的配置文件：

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration
   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
     <properties resource="config/jdbc.properties"></properties>
     <typeAliases>
         <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
     </typeAliases>
     <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC" />
             <dataSource type="POOLED">
                 <property name="driver" value="${jdbc.driver}" />
                 <property name="url" value="${jdbc.url}" />
                 <property name="username" value="${jdbc.username}" />
                 <property name="password" value="${jdbc.password}" />
             </dataSource>
         </environment>
     </environments>
     <mappers>
         <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
     </mappers>
 </configuration>

 

BlogMapper.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 <mapper namespace="com.tiantian.mybatis.model.BlogMapper">
 <!--  新增记录  -->
     <insert id="insertBlog" parameterType="Blog">
         insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})
     </insert>
 <!--  查询单条记录 -->
     <select id="selectBlog" parameterType="int" resultType="Blog">
         select * from t_blog where id = #{id}
     </select>
 <!--  改动记录   -->
     <update id="updateBlog" parameterType="Blog">
         update t_blog set title = #{title},content = #{content},owner = #{owner} where id = #{id}
     </update>
 <!--  查询全部记录，查询多条记录即返回结果是一个集合的时候。resultType不是集合类型。而是集合所包括的类型 -->
     <select id="selectAll" resultType="Blog">
         select * from t_blog
     </select>
 <!--  模糊查询   -->
     <select id="fuzzyQuery" resultType="Blog" parameterType="java.lang.String">
         select * from t_blog where title like "%"#{title}"%"
     </select>
 <!--  删除记录   -->
     <delete id="deleteBlog" parameterType="int">
         delete from t_blog where id = #{id}
     </delete>
 </mapper>

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

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

Blog.java

 package com.tiantian.mybatis.model;

 public class Blog {

     private int id;

     private String title;

     private String content;

     private String owner;

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getTitle() {
         return title;
     }

     public void setTitle(String title) {
         this.title = title;
     }

     public String getContent() {
         return content;
     }

     public void setContent(String content) {
         this.content = content;
     }

     public String getOwner() {
         return owner;
     }

     public void setOwner(String owner) {
         this.owner = owner;
     }

     @Override
     public String toString() {
         return "id: " + id + ", title: " + title + ", content: " + content
                 + ", owner: " + owner;
     }

 }

 

BlogMapper.java

 package com.tiantian.mybatis.model;

 import java.util.List;

 import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Insert;
 import org.apache.ibatis.annotations.Select;
 import org.apache.ibatis.annotations.Update;

 /**
  * 下面的操作1都是把SQL写在配置文件中面的，而操作2都是直接用注解标明要运行的SQL语句
  * 由于该Mapper的全名跟BlogMapper.xml文件中面的namespace是一样的。所以不能在这里面
  * 用注解定义一个与BlogMapper.xml文件中面同名的映射
  * @author andy
  *
  */
 public interface BlogMapper {

     public Blog selectBlog(int id);

     @Select("select * from t_blog where id = #{id}")
     public Blog selectBlog2(int id);

     public void insertBlog(Blog blog);

     @Insert("insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})")
     public void insertBlog2(Blog blog);

     public void updateBlog(Blog blog);

     @Update("update t_blog set title=#{title},content=#{content},owner=#{owner} where id=#{id}")
     public void updateBlog2(Blog blog);

     public void deleteBlog(int id);

     @Delete("delete from t_blog where id = #{id}")
     public void deleteBlog2(int id);

     public List<Blog> selectAll();

     @Select("select * from t_blog")
     public List<Blog> selectAll2();

     public List<Blog> fuzzyQuery(String title);

     @Select("select * from t_blog where title like \"%\"#{title}\"%\"")
     public List<Blog> fuzzyQuery2(String title);

 }

 

Test1.java

 package com.tiantian.mybatis.test;

 import java.util.List;

 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;

 import com.tiantian.mybatis.model.Blog;
 import com.tiantian.mybatis.util.Util;

 /**
  * 该系列操作是通过把SQL写在配置文件中面，
  * 然后利用SqlSession进行操作的
  * @author andy
  *
  */
 public class Test1 {

     /**
      * 新增记录
      */
     @Test
     public void testInsertBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         Blog blog = new Blog();
         blog.setTitle("中国人");
         blog.setContent("五千年的风和雨啊藏了多少梦");
         blog.setOwner("天天");
         session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog", blog);
         session.commit();
         session.close();
     }

     /**
      * 查询单条记录
      */
     @Test
     public void testSelectOne() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         Blog blog = (Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog", 8);
         System.out.println(blog);
         session.close();
     }

     /**
      * 改动记录
      */
     @Test
     public void testUpdateBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         Blog blog = new Blog();
         blog.setId(7);//须要改动的Blog的id
         blog.setTitle("中国人2");//改动Title
         blog.setContent("黄色的脸，黑色的眼，不变是笑容");//改动Content
         blog.setOwner("天天2");//改动Owner
         session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog", blog);
         session.commit();
         session.close();
     }

     /**
      * 查询全部的记录
      */
     @Test
     public void testSelectAll() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");
         for (Blog blog:blogs)
             System.out.println(blog);
         session.close();
     }

     /**
      * 模糊查询
      */
     @Test
     public void testFuzzyQuery() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         String title = "中国";
         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery", title);
         for (Blog blog:blogs)
             System.out.println(blog);
         session.close();
     }

     /**
      * 删除记录
      */
     @Test
     public void testDeleteBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog", 8);
         session.commit();
         session.close();
     }

 }

 

Test2.java

 package com.tiantian.mybatis.test;

 import java.util.List;

 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;

 import com.tiantian.mybatis.model.Blog;
 import com.tiantian.mybatis.model.BlogMapper;
 import com.tiantian.mybatis.util.Util;

 /**
  * 该系列操作是将SQL语句写在配置文件中面，
  * 然后通过相应Mapper接口来进行操作的
  * @author andy
  *
  */
 public class Test2 {

     /**
      * 新增记录
      */
     @Test
     public void testInsertBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         Blog blog = new Blog();
         blog.setTitle("中国人");
         blog.setContent("五千年的风和雨啊藏了多少梦");
         blog.setOwner("天天");
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         blogMapper.insertBlog(blog);
         session.commit();
         session.close();
     }

     /**
      * 查询单条记录
      */
     @Test
     public void testSelectOne() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         Blog blog = blogMapper.selectBlog(7);
         System.out.println(blog);
         session.close();
     }

     /**
      * 改动记录
      */
     @Test
     public void testUpdateBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         Blog blog = new Blog();
         blog.setId(9);// 须要改动的Blog的id
         blog.setTitle("中国人2");// 改动Title
         blog.setContent("黄色的脸，黑色的眼，不变是笑容");// 改动Content
         blog.setOwner("天天2");// 改动Owner
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         blogMapper.updateBlog(blog);
         session.commit();
         session.close();
     }

     /**
      * 查询全部记录
      */
     @Test
     public void testSelectAll() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         List<Blog> blogs = blogMapper.selectAll();
         for (Blog blog : blogs)
             System.out.println(blog);
         session.close();
     }

     /**
      * 模糊查询
      */
     @Test
     public void testFuzzyQuery() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         String title = "中国";
         List<Blog> blogs = blogMapper.fuzzyQuery(title);
         for (Blog blog : blogs)
             System.out.println(blog);
         session.close();
     }

     /**
      * 删除记录
      */
     @Test
     public void testDeleteBlog() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         blogMapper.deleteBlog(10);
         session.commit();
         session.close();
     }

 }

 

Test3.java

 package com.tiantian.mybatis.test;

 import java.util.List;

 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;

 import com.tiantian.mybatis.model.Blog;
 import com.tiantian.mybatis.model.BlogMapper;
 import com.tiantian.mybatis.util.Util;

 /**
  * 该系列操作是利用Mapper接口来进行的
  * 。然而其相应的SQL语句是通过相应的
  * 注解Annotation在Mapper中相应的方法上定义的
  * @author andy
  *
  */
 public class Test3 {

     /**
      * 新增记录
      */
     @Test
     public void testInsert() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         Blog blog = new Blog();
         blog.setTitle("title2");
         blog.setContent("content2");
         blog.setOwner("owner2");
         blogMapper.insertBlog2(blog);
         session.commit();
         session.close();
     }

     /**
      * 查找单条记录
      */
     @Test
     public void testSelectOne() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         Blog blog = blogMapper.selectBlog2(1);
         System.out.println(blog);
         session.close();
     }

     /**
      * 查找多条记录，返回结果为一集合
      */
     @Test
     public void testSelectAll() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         List<Blog> blogs = blogMapper.selectAll2();
         for (Blog blog:blogs)
             System.out.println(blog);
         session.close();
     }

     /**
      * 改动某条记录
      */
     @Test
     public void testUpdate() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         Blog blog = new Blog();
         blog.setId(3);
         blog.setTitle("title3");
         blog.setContent("content3");
         blog.setOwner("owner3");
         blogMapper.updateBlog2(blog);
         session.commit();
         session.close();
     }

     /**
      * 删除记录
      */
     @Test
     public void testDelete() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         blogMapper.deleteBlog2(5);
         session.commit();
         session.close();
     }

     @Test
     public void testFuzzyQuery() {
         SqlSession session = Util.getSqlSessionFactory().openSession();
         BlogMapper blogMapper = session.getMapper(BlogMapper.class);
         List<Blog> blogs = blogMapper.fuzzyQuery2("中国");
         for (Blog blog:blogs)
             System.out.println(blog);
         session.close();
     }

 }

 

相应的建表语句：

 CREATE TABLE `t_blog` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `title` varchar(255) DEFAULT NULL,
   `content` varchar(255) DEFAULT NULL,
   `owner` varchar(50) DEFAULT NULL,
   PRIMARY KEY (`id`)
 )