基本用法回顾:
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
- <?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();
- }
- }
对应的建表语句:
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`) ) |