基于MyBatis3.0.6的基本操做介绍

时间 2019-11-06

标签基于 mybatis3.0.6 mybatis 基本介绍栏目 MyBatis 繁體版

原文原文链接

每一个 MyBatis 的应用程序都以一个 SqlSessionFactory 对象的实例为核心。SqlSessionFactory自己是由SqlSessionFactoryBuilder建立的，通常而言，在一个应用中，一个数据库只会对应一个SqlSessionFactory，因此通常咱们都把SqlSessionFactory定义成单例模式，或经过Spring等进行注入。java

SqlSessionFactoryBuilder建立SqlSessionFactory的方法有：sql

Java代码数据库

SqlSessionFactory build(InputStream inputStream) apache
SqlSessionFactory build(InputStream inputStream, String environment) 安全
SqlSessionFactory build(InputStream inputStream, Properties properties) 服务器
SqlSessionFactory build(InputStream inputStream, String env, Properties props) session
SqlSessionFactory build(Configuration config) mybatis

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

从XML中构建SqlSessionFactoryide

Java代码

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 映射应用于多种数据库之中。

Xml代码

<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 上下文的引用。这个数据源配置只须要两个属性:

initial_context – 这个属性用来从初始上下文中寻找环境 ( 也就是 initialContext.lookup(initial——context) 。这是个可选属性,若是被忽略,那么 data_source 属性将会直接以 initialContext 为背景再次寻找。
data_source – 这是引用数据源实例位置的上下文的路径。它会以由 initial_context 查询返回的环境为背景来查找,若是 initial_context 没有返回结果时,直接以初始上下文为环境来查找。

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

Java代码

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

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

Xml代码

<?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的时候都应该打开一个，而后在用完了以后再把它关上。

Java代码

SqlSession session = sqlSessionFactory.openSession();

SqlSessionFactory中湖区SqlSession的方法有：

Java代码

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

Java代码

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代码

<?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代码

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

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

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

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

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

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();
}
}

对应的建表语句：

Java代码

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