服务器之家

服务器之家 > 正文

整理Java的MyBatis框架中一些重要的功能及基本使用示例

时间：2020-04-16 14:04     来源/作者：234390216

基本用法回顾：
SQL语句存储在XML文件或Java 注解中。一个MaBatis映射的示例（其中用到了Java接口和MyBatis注解）：

?
1
2
3
4
5
6
package org.mybatis.example;
 
public interface BlogMapper {
  @Select("select * from Blog where id = #{id}")
  Blog selectBlog(int id);
}

执行的示例：

?
1
2
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);

SQL语句和映射也可以外化到一个XML文件中：

?
1
2
3
4
5
6
7
8
<?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="org.mybatis.example.BlogMapper">
  <select id="selectBlog" parameterType="int" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

也可以使用MyBatis API执行语句：

?
1
Blog blog = session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);

详细信息可以参考MyBatis网站所提供的用户手册。


与Spring集成
MyBatis与Spring Framework集成。Spring Framework允许MyBatis参与Spring事务，创建了MyBatis映射器和会话，并把他们注入到其他bean中。

如下是一个基本的XML配置示例：创建了映射器，并注入到“BlogService”bean中。

?
1
2
3
4
5
6
7
8
9
10
11
12
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
</bean>
 
<bean id="blogMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
  <property name="mapperInterface" value="org.mybatis.example.BlogMapper" />
</bean>
 
<bean id="blogService" class="org.mybatis.example.BlogServiceImpl">
  <property name="blogMapper" ref="blogMapper" />
</bean>

现在调用MyBatis只需要调用一个bean:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public class BlogServiceImpl implements BlogService {
 
  private BlogMapper blogMapper;
 
  public void setBlogMapper(BlogMapper blogMapper) {
    this.blogMapper = blogMapper;
  }
 
  public void doSomethingWithABlog(int blogId) {
    Blog blog = blogMapper.selectBlog(blogId);
    ...
  }
}

SqlSessionFactory
每 一 个 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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 映射应用于多种数据库之中。
?
1
2
3
4
5
6
7
8
9
10
11
<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 应用服务器的上下文) 默认 情况下它会关闭连接。 然而一些容器并不希望这样, 因此如果你需要从连接中停止 它,将 closeConnection 属性设置为 false。
dataSource

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

许多 MyBatis 的应用程序将会按示例中的例子来配置数据源。 然而它并不是必须的。 要知道为了方便使用延迟加载,数据源才是必须的。
有三种内建的数据源类型(也就是 type=”???”):

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

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

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

?
1
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 上下文的引用。

其中JNDI 这个数据源配置只需要两个属 性:

（1）initial_context – 这 个 属 性 用 来 从 初 始 上 下 文 中 寻 找 环 境 ( 也 就 是 initialContext.lookup(initial——context) 。这是个可选属性,如果被忽略,那么 data_source 属性将会直接以 initialContext 为背景再次寻找。
（2）data_source – 这是引用数据源实例位置的上下文的路径。它会以由 initial_context 查询返回的环境为背景来查找,如果 initial_context 没有返回结果时,直接以初始 上下文为环境来查找。
再之后就是Mapper了，Mapper就是映射SQL语句的，首先要告诉mybatis要到哪里去找这些SQL语句，即指定资源位置。

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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的时候都应该打开一个，然后在用完了之后再把它关上。

?
1
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的工具类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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的配置文件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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

  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. <!-- 查询所有记录，查询多条记录即返回结果是一个集合的时候，resultType不是集合类型，而是集合所包含的类型 --> 
  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映射语句中一些应该注意的问题：

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

Blog.java

  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

  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

  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

  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

  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. } 

对应的建表语句：

?
1
2
3
4
5
6
7
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`)
)

 

标签：
Java mybatis 

相关文章

热门资讯

沙雕群名称大全2019精选 今年最火的微信群名沙雕有创意
沙雕群名称大全2019精选 今年最火的微信群名沙雕有创意 2019-07-07
玄元剑仙肉身有什么用 玄元剑仙肉身境界等级划分
玄元剑仙肉身有什么用 玄元剑仙肉身境界等级划分 2019-06-21
男生常说24816是什么意思？女生说13579是什么意思？
男生常说24816是什么意思？女生说13579是什么意思？ 2019-09-17
超A是什么意思 你好a表达的是什么
超A是什么意思 你好a表达的是什么 2019-06-06
华为nova5pro和p30pro哪个好 华为nova5pro和华为p30pro对比详情
华为nova5pro和p30pro哪个好 华为nova5pro和华为p30pro对比详情 2019-06-22
返回顶部