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

更新時間：2016年04月06日 18:18:26 作者：234390216

這篇文章主要介紹了Java的MyBatis框架中一些重要的功能及基本使用示例整理,MyBatis可以幫助Java程序進(jìn)行強大的數(shù)據(jù)庫操作,需要的朋友可以參考下

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

package org.mybatis.example;

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

執(zhí)行的示例：

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執(zhí)行語句：

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

詳細(xì)信息可以參考MyBatis網(wǎng)站所提供的用戶手冊。

與Spring集成
MyBatis與Spring Framework集成。Spring Framework允許MyBatis參與Spring事務(wù)，創(chuàng)建了MyBatis映射器和會話，并把他們注入到其他bean中。

如下是一個基本的XML配置示例：創(chuàng)建了映射器，并注入到“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>

現(xiàn)在調(diào)用MyBatis只需要調(diào)用一個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 的應(yīng) 用程序都以一個 SqlSessionFactory 對象的實例為核心。SqlSessionFactory本身是由SqlSessionFactoryBuilder創(chuàng)建的，一般而言，在一個應(yīng)用中，一個數(shù)據(jù)庫只會對應(yīng)一個SqlSessionFactory，所以一般我們都把SqlSessionFactory定義成單例模式，或通過Spring等進(jìn)行注入。
SqlSessionFactoryBuilder創(chuàng)建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)

這些方法主要設(shè)計到的參數(shù)有InputStream，environment，properties，其中InputStream是從配置文件中獲取的一個輸入流；environment表示在配置文件里面配置的眾多的environment中，當(dāng)前要使用的是哪一個environment，包括數(shù)據(jù)源和事務(wù)，缺省則使用默認(rèn)的environment；使用properties，MyBatis則會加載對應(yīng)的屬性或文件，它們可以在配置文件中使用。

從XML中構(gòu)建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; 
  }

下面講講配置文件的基本結(jié)構(gòu)：
mybatis的配置文件一般包括如下幾個部分：

properties：properties用于定義或?qū)雽傩?，然后在后面的環(huán)境中使用
settings:settings用于設(shè)置一些mybatis在運行時的行為方式，具體的設(shè)置信息可以查看mybatis的文檔
typeAliases:typeAliases是為系統(tǒng)中的Java類型指定一個較短的別名
environments:MyBatis 可以配置多種環(huán)境。這會幫助你將 SQL 映射應(yīng)用于多種數(shù)據(jù)庫之中。

<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，所以可以在創(chuàng)建SqlSessionFactory的時候指定具體的環(huán)境來創(chuàng)建特定的環(huán)境下的SqlSessionFactory，不指定則使用默認(rèn)的環(huán)境。
transactionManager

在 MyBatis 中有兩種事務(wù)管理器類型(也就是 type=”[JDBC|MANAGED]”):

JDBC – 這個配置直接簡單使用了 JDBC 的提交和回滾設(shè)置。它依賴于從數(shù)據(jù)源得到的連接來管理事務(wù)范圍。
MANAGED – 這個配置幾乎沒做什么。它從來不提交或回滾一個連接。而它會讓容器來管理事務(wù)的整個生命周期(比如 Spring 或 JEE 應(yīng)用服務(wù)器的上下文) 默認(rèn) 情況下它會關(guān)閉連接。然而一些容器并不希望這樣, 因此如果你需要從連接中停止它,將 closeConnection 屬性設(shè)置為 false。
dataSource

dataSource 元素使用基本的 JDBC 數(shù)據(jù)源接口來配置 JDBC 連接對象的資源。

許多 MyBatis 的應(yīng)用程序?qū)词纠械睦觼砼渲脭?shù)據(jù)源。然而它并不是必須的。要知道為了方便使用延遲加載,數(shù)據(jù)源才是必須的。
有三種內(nèi)建的數(shù)據(jù)源類型(也就是 type=”???”):

UNPOOLED – 這個數(shù)據(jù)源的實現(xiàn)是每次被請求時簡單打開和關(guān)閉連接。它有一點慢, 這是對簡單應(yīng)用程序的一個很好的選擇, 因為它不需要及時的可用連接。不同的數(shù)據(jù)庫對這個的表現(xiàn)也是不一樣的, 所以對某些數(shù)據(jù)庫來說配置數(shù)據(jù)源并不重要, 這個配置也是閑置的。 UNPOOLED 類型的數(shù)據(jù)源僅僅用來配置以下 5 種屬性:

driver – 這是 JDBC 驅(qū)動的 Java 類的完全限定名(如果你的驅(qū)動包含,它也不是數(shù)據(jù)源類)。
url – 這是數(shù)據(jù)庫的 JDBC URL 地址。
username – 登錄數(shù)據(jù)庫的用戶名。
password – 登錄數(shù)據(jù)庫的密碼。
defaultTransactionIsolationLevel – 默認(rèn)的連接事務(wù)隔離級別。

作為可選項,你可以傳遞數(shù)據(jù)庫驅(qū)動的屬性。要這樣做,屬性的前綴是以“driver.”開頭的,例如:

driver.encoding=UTF8

這樣就會傳遞以值 “ UTF8 ” 來傳遞屬性 “ encoding ”, 它是通過 DriverManager.getConnection(url,driverProperties)方法傳遞給數(shù)據(jù)庫驅(qū)動。

POOLED – 這是 JDBC 連接對象的數(shù)據(jù)源連接池的實現(xiàn),用來避免創(chuàng)建新的連接實例時必要的初始連接和認(rèn)證時間。這是一種當(dāng)前 Web 應(yīng)用程序用來快速響應(yīng)請求很流行的方法。

除了上述(UNPOOLED)的屬性之外,還有很多屬性可以用來配置 POOLED 數(shù)據(jù)源:

poolMaximumActiveConnections – 在任意時間存在的活動(也就是正在使用)連接的數(shù)量。默認(rèn)值:10
poolMaximumIdleConnections – 任意時間存在的空閑連接數(shù)。
poolMaximumCheckoutTime – 在被強制返回之前,池中連接被檢查的時間。默認(rèn) 值:20000 毫秒(也就是 20 秒)
poolTimeToWait – 這是給連接池一個打印日志狀態(tài)機會的低層次設(shè)置,還有重新嘗試獲得連接, 這些情況下往往需要很長時間為了避免連接池沒有配置時靜默失敗)。默認(rèn)值:20000 毫秒(也就是 20 秒)
poolPingQuery – 發(fā)送到數(shù)據(jù)的偵測查詢,用來驗證連接是否正常工作,并且準(zhǔn)備接受請求。默認(rèn)是“NO PING QUERY SET” ,這會引起許多數(shù)據(jù)庫驅(qū)動連接由一個錯誤信息而導(dǎo)致失敗。
poolPingEnabled – 這是開啟或禁用偵測查詢。如果開啟,你必須用一個合法的 SQL 語句(最好是很快速的)設(shè)置 poolPingQuery 屬性。默認(rèn)值:false。
poolPingConnectionsNotUsedFor – 這是用來配置 poolPingQuery 多次時間被用一次。這可以被設(shè)置匹配標(biāo)準(zhǔn)的數(shù)據(jù)庫連接超時時間, 來避免不必要的偵測。默認(rèn)值: 0(也就是所有連接每一時刻都被偵測-但僅僅當(dāng) poolPingEnabled 為 true 時適用)。
JNDI – 這個數(shù)據(jù)源的實現(xiàn)是為了使用如 Spring 或應(yīng)用服務(wù)器這類的容器, 容器可以集中或在外部配置數(shù)據(jù)源,然后放置一個 JNDI 上下文的引用。

其中JNDI 這個數(shù)據(jù)源配置只需要兩個屬性:

（1）initial_context – 這個屬性用來從初始上下文中尋找環(huán) 境 ( 也就是 initialContext.lookup(initial——context) 。這是個可選屬性,如果被忽略,那么 data_source 屬性將會直接以 initialContext 為背景再次尋找。
（2）data_source – 這是引用數(shù)據(jù)源實例位置的上下文的路徑。它會以由 initial_context 查詢返回的環(huán)境為背景來查找,如果 initial_context 沒有返回結(jié)果時,直接以初始上下文為環(huán)境來查找。
再之后就是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>

在上面配置文件中導(dǎo)入了一個外部的屬性文件，MyBatis配置文件中的屬性引入可以是直接包含在properties元素中的，也可以是利用properties元素從外部引入的，還可以是在創(chuàng)建SqlSessionFactory的時候，作為一個參數(shù)properties傳入。既然MyBatis配置文件中的屬性可以從這么多地方引入，那就牽涉到一個優(yōu)先級的問題，MyBatis將會按照下面的順序來尋找它們：
先是配置文件中，properties元素體中的屬性被讀取
再是利用properties元素從外部引入的屬性文件中的屬性被讀取，會覆蓋前面讀取的相同的屬性
最后是創(chuàng)建SqlSessionFactory時傳入的properties中的屬性被讀取，同樣會覆蓋前面相同的屬性

在有了SqlSessionFactory之后就是獲取特定的SqlSession了，在使用mybatis的過程中每一個操作都是離不開SqlSession的，所以獲取SqlSession是相當(dāng)重要的。此外，SqlSession是不能被共享、線程不安全的，所以在每次需要SqlSession的時候都應(yīng)該打開一個，然后在用完了之后再把它關(guān)上。

SqlSession session = sqlSessionFactory.openSession();

SqlSessionFactory中湖區(qū)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();

它們的主要區(qū)別在于：

Transaction (事務(wù)): 你想為 session 使用事務(wù)或者使用自動提交
Connection (連接): 你想 MyBatis 獲得來自配置的數(shù)據(jù)源的連接還是提供你自己
Execution (執(zhí)行): 你想 MyBatis 復(fù)用預(yù)處理語句和/或批量更新語句(包括插入和刪除)

默認(rèn)的opensession方法沒有參數(shù)，它會創(chuàng)建有如下特性的SqlSession：

會開啟一個事務(wù)，也就是不自動提交
連接對象會從當(dāng)前正在使用的environment中的數(shù)據(jù)源中得到
事務(wù)隔離級別將會使用驅(qū)動或數(shù)據(jù)源的默認(rèn)值
預(yù)處理語句不會被復(fù)用，也不會批量更新語句

ExecutorType有三個值：

ExecutorType.SIMPLE 它會為每個語句的執(zhí)行創(chuàng)建一個新的預(yù)處理語句
ExecutorType.REUSE 它會復(fù)用預(yù)處理語句
ExecutorType.BATCH 這個執(zhí)行器會批量執(zhí)行更新語句

mybatis的基本操作就是增、刪、改、查，即insert、delete、update和select。在進(jìn)行這些基本的操作的時候可以直接利用SqlSession訪問Mapper配置文件里面的映射來進(jìn)行，也可以利用與Mapper配置文件相對應(yīng)的Mapper接口來進(jìn)行操作，條件是Mapper接口中定義的方法的參數(shù)和返回值要與Mapper配置文件中定義的參數(shù)和返回值相同。此外，在使用Mapper接口的時候，對應(yīng)的SQL語句是可以寫在Mapper配置文件中的，也可以直接利用對應(yīng)的注解在Mapper接口中對應(yīng)的方法上進(jìn)行標(biāo)明，這將在下面的示例代碼中看到。

下面是一系列的示例代碼：
先貼一個用于獲取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> 
<!-- 查詢所有記錄，查詢多條記錄即返回結(jié)果是一個集合的時候，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映射語句中一些應(yīng)該注意的問題：

resultType的值應(yīng)該是返回類型的完全名或別名，當(dāng)返回的結(jié)果是一個集合的時候，resultType應(yīng)為集合中所包含的類型，而不是集合類型，如上面的Blog
resultType和resultMap都是表示指定返回結(jié)果的，但兩者不能同時使用
對于Insert映射語句有一個useGeneratedKeys屬性，該屬性的默認(rèn)值為false，當(dāng)該屬性的值為true時，在進(jìn)行插入操作時，mybatis會取到當(dāng)前正在插入的記錄在數(shù)據(jù)庫中的自動遞增的主鍵值，并把它設(shè)置給指定的實體的屬性，這就需要設(shè)置一個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都是直接用注解標(biāo)明要執(zhí)行的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進(jìn)行操作的 
 * @author andy 
 * 
 */ 
public class Test1 { 
 
  /** 
   * 新增記錄 
   */ 
  @Test 
  public void testInsertBlog() { 
    SqlSession session = Util.getSqlSessionFactory().openSession(); 
    Blog blog = new Blog(); 
    blog.setTitle("中國人"); 
    blog.setContent("五千年的風(fēng)和雨啊藏了多少夢"); 
    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語句寫在配置文件里面， 
 * 然后通過對應(yīng)Mapper接口來進(jìn)行操作的 
 * @author andy 
 * 
 */ 
public class Test2 { 
 
  /** 
   * 新增記錄 
   */ 
  @Test 
  public void testInsertBlog() { 
    SqlSession session = Util.getSqlSessionFactory().openSession(); 
    Blog blog = new Blog(); 
    blog.setTitle("中國人"); 
    blog.setContent("五千年的風(fēng)和雨啊藏了多少夢"); 
    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接口來進(jìn)行的 
 * ，然而其相應(yīng)的SQL語句是通過對應(yīng)的 
 * 注解Annotation在Mapper中對應(yīng)的方法上定義的 
 * @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(); 
  } 
   
  /** 
   * 查找多條記錄，返回結(jié)果為一集合 
   */ 
  @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(); 
  } 
   
}

對應(yīng)的建表語句：

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`) 
)

您可能感興趣的文章: