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

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

package org.mybatis.example;

public interface BlogMapper {
  @Select("select * from Blog where id = #{id}")
  Blog selectBlog(int id);
}

执行的示例:

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

SQL语句和映射也可以外化到一个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="org.mybatis.example.BlogMapper">
  <select id="selectBlog" parameterType="int" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

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

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

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

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

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

<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:

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

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 应用服务器的上下文) 默认 情况下它会关闭连接。 然而一些容器并不希望这样, 因此如果你需要从连接中停止 它,将 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 上下文的引用。

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

(1)initial_context – 这 个 属 性 用 来 从 初 始 上 下 文 中 寻 找 环 境 ( 也 就 是 initialContext.lookup(initial——context) 。这是个可选属性,如果被忽略,那么 data_source 属性将会直接以 initialContext 为背景再次寻找。
(2)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映射语句中一些应该注意的问题:

  • resultType的值应该是返回类型的完全名或别名,当返回的结果是一个集合的时候,resultType应为集合中所包含的类型,而不是集合类型,如上面的Blog
  • resultType和resultMap都是表示指定返回结果的,但两者不能同时使用
  • 对于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`)
)
时间: 2016-04-05

oracle+mybatis 使用动态Sql当插入字段不确定的情况下实现批量insert

最近做项目遇到一个挺纠结的问题,由于业务的关系,DB的数据表无法确定,在使用过程中字段可能会增加,这样在insert时给我造成了很大的困扰. 先来看一下最终我是怎么实现的: <insert id="batchInsertLine" parameterType="HashMap"> <![CDATA[ INSERT INTO tg_fcst_lines(${lineColumn}) select result.*,sq_fcst_lines.next

MyBatis如何使用(三)

在前边阐述了单独使用mybatis的方法,在实际开发过程中mybatis经常和spring一起使用,即mybatis和spring进行集成,现在我们来看如何集成. mybatis和spring进行集成需要用到集成包:mybatis-spring-1.1.1.jar,此包提供mybatis和spring集成的支持,把此包导入到项目的lib目录下. 我们先看mybatis单独使用的时候的过程,mybatis配置文件==>读取配置文件==>操作数据库,具体的使用方法可参照前两篇文章. 下面进行myb

MyBatis如何使用(一)

mybatis作为ORM轻量级框架一出现就吸引了无数人的眼球,比hibernate要简单且入门较容易,下面开始我的第一个mybatis程序. 一.下载mybatis的包 我们知道任何一个框架都会有其包,我们从其官方网站下载其包,官网网址为:http://www.mybatis.org/mybatis-3/,我这里使用的版本为3.3.0.下载完成之后解压可看到如下的目录结构: mybatis-3.3.0.jar是其包,lib目录下是其依赖包,我们把这些包放到我们的项目中.我这里创建的是javawe

Java的MyBatis框架中Mapper映射配置的使用及原理解析

Mapper的内置方法 model层就是实体类,对应数据库的表.controller层是Servlet,主要是负责业务模块流程的控制,调用service接口的方法,在struts2就是Action.Service层主要做逻辑判断,Dao层是数据访问层,与数据库进行对接.至于Mapper是mybtis框架的映射用到,mapper映射文件在dao层用. 下面是介绍一下Mapper的内置方法: 1.countByExample ===>根据条件查询数量 int countByExample(UserE

Mybatis学习总结之mybatis使用建议

简介:什么是MyBatis? (前身为iBatis) MyBatis 是一个可以自定义SQL.存储过程和高级映射的持久层框架.MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索.MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录. 1.Mapper层参数为Map,由Service层负责重载. Mapper由于机制的问题,不能重载,参数一般设置成Ma

MyBatis如何使用(二)

前边阐述了如何在java项目中使用mybatis,我们使用的是映射文件的方式,在获得具体的数据操作方法时需要传入映射文件中namespace+"."方法名称,这种方式有时候会感觉很不爽,很麻烦.我们在开发中不是常说要面向接口变成吗,mybatis也支持接口,下面在前面的例子的基础上做相应修改. 前面的例子的环境及映射文件均保持不变,如下是我的映射文件, <mapper namespace="com.cn.inter.IMessageOperation">

MyBatis入门初体验之使用大全(2)

MyBatis简介 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis .2013年11月迁移到Github. iBATIS一词来源于"internet"和"abatis"的组合,是一个基于Java的持久层框架.iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO) 1.所需jar包

MyBatis学习教程(二)—如何使用MyBatis对users表执行CRUD操作

上一篇文章MyBatis入门学习教程(一)-MyBatis快速入门中我们讲了如何使用Mybatis查询users表中的数据,算是对MyBatis有一个初步的入门了,今天讲解一下如何使用MyBatis对users表执行CRUD操作.在没奔主题之前,先给大家补充点有关mybatis和crud的基本知识. 什么是 MyBatis? MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架. MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及对结果集的检索.MyBa

MyBatis学习教程(六)-调用存储过程

一.提出需求 查询得到男性或女性的数量, 如果传入的是0就女性否则是男性 二.准备数据库表和存储过程 create table p_user( id int primary key auto_increment, name varchar(), sex char() ); insert into p_user(name,sex) values('A',"男"); insert into p_user(name,sex) values('B',"女"); insert

MyBatis学习教程(四)-如何快速解决字段名与实体类属性名不相同的冲突问题

在项目开发中,我们经常会遇到表中的字段名和表对应实体类的属性名称不一定都是完全相同的情况,下面小编给大家演示一下这种情况下的如何解决字段名与实体类属性名不相同的冲突问题,感兴趣的朋友一起学习吧. 一.准备演示需要使用的表和数据 CREATE TABLE orders( order_id INT PRIMARY KEY AUTO_INCREMENT, order_no VARCHAR(20), order_price FLOAT ); INSERT INTO orders(order_no, or

MyBatis入门学习教程(一)-MyBatis快速入门

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis .2013年11月迁移到Github. iBATIS一词来源于"internet"和"abatis"的组合,是一个基于Java的持久层框架.iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO) 首先给大家介绍MyBatis的含义

MyBatis学习教程(三)-MyBatis配置优化

一.连接数据库的配置单独放在一个properties文件中 之前,我们是直接将数据库的连接配置信息写在了MyBatis的conf.xml文件中,如下: <?xml version="." encoding="UTF-"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config .//EN" "http://mybatis.org/dtd/mybatis--

MyBatis学习教程(五)-实现关联表查询方法详解

一.一对一关联  1.1.提出需求 根据班级id查询班级信息(带老师的信息) 1.2.创建表和数据 创建一张教师表和班级表,这里我们假设一个老师只负责教一个班,那么老师和班级之间的关系就是一种一对一的关系. CREATE TABLE teacher( t_id INT PRIMARY KEY AUTO_INCREMENT, t_name VARCHAR() ); CREATE TABLE class( c_id INT PRIMARY KEY AUTO_INCREMENT, c_name VAR

mybatis 通过拦截器打印完整的sql语句以及执行结果操作

开发过程中,如果使用mybatis做为ORM框架,经常需要打印出完整的sql语句以及执行的结果做为参考. 虽然mybatis结合日志框架可以做到,但打印出来的通常都是sql和参数分开的. 有时我们需要调试这条sql的时候,就需要把参数填进去,这样未免有些浪费时间. 此时我们可以通过实现mybatis拦截器来做到打印带参数的完整的sql,以及结果通过json输出到控制台. 直接看代码和使用方法吧: MyBatis拦截器打印不带问号的完整sql语句拦截器 import java.text.DateF

MyBatis学习笔记(二)之关联关系

今天主要学习的关联关系是一对一关系与一对多关系. 一.一对一关系 还是通过例子来解释说明.(一个妻子对应一个丈夫). 1)数据库信息 create table t_wife( id int primary key auto_increment, wife_name varchar(), fk_husband_id int ); create table t_husband( id int primary key auto_increment, husband_name varchar() );

MyBatis学习教程(八)-Mybatis3.x与Spring4.x整合图文详解

一.搭建开发环境 1.1.使用Maven创建Web项目 执行如下命令: 复制代码 代码如下: mvn archetype:create -DgroupId=me.gacl -DartifactId=spring4-mybatis3 -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false 如下图所示: 创建好的项目如下: 编辑pom.xml文件 <project xmlns="http://maven.apac

MyBatis学习教程之开发Dao的方法教程

简介 使用Mybatis开发Dao,通常有两个方法,即原始Dao开发方法和Mapper接口开发方法.下面话不多说,来一起看看详细的介绍: 主要概念介绍: MyBatis中进行Dao开发时候有几个重要的类,它们是SqlSessionFactoryBuilder.SqlSessionFactory.SqlSession. SqlSession中封装了对数据库的操作,如:查询.插入.更新.删除等.通过SqlSessionFactory创建SqlSession,而SqlSessionFactory是通过