概述
MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代
码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的
POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
-----搬自官网
利用mybatis操作对数据的操作的过程一般是这样的
1. 从配置文件(通常是XML配置文件中)得到 sessionfactory.
2. 由sessionfactory 产生 session
3. 在session 中完成对数据的增删改查和事务提交等.
4. 在用完之后关闭session 。
5. 在Java对象和数据库之间有做mapping 的配置文件，也通常是xml 文件。
利用IntelliJ Idea搭建一个mybatis开发环境
所需资源
1. IntelliJ Idea 15
2. mybatis-3.4.4.jar
3. mysql-connector-java-5.1.39-bin.jar
准备工作:先创建一个数据库user
Create TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`userName` varchar(50) DEFAULT NULL,
`userAge` int(11) DEFAULT NULL,
`userAddress` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
Insert INTO `user` VALUES ('1', 'Peter', '15', 'NewYork US');
Insert INTO `user` VALUES ('2', 'Jack', '18', 'L.A US');
Insert INTO `user` VALUES ('3', 'Linda', '17', 'London UK');
Insert INTO `user` VALUES ('4', 'Lily', '21', 'Shanghai CN');
1、打开IntelliJ Idea，创建一个Java工程,工程命名为DemoForMybatis
将src目录修改为src_test,创建src_user目录，并将src_user目录变成Sources类型
2、导入所需包mybatis-3.4.4.jar和mysql-connector-java-5.1.39-bin.jar
3、现在来创建项目
在目录 src_user下创建一个配置文件Configuration.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>
<typeAliases>
<typeAlias alias="User" type="com.mybatis.model.User"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/test" />
<property name="username" value="root"/>
<property name="password" value="password"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/mybatis/model/User.xml"/>
</mappers>
</configuration>
在src_user中创建一个包，命名为com.mybatis.model，并在这个包中创建一个POJO User如下
public class User {
private int id;
private String userName;
private String userAge;
private String userAddress;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserAge() {
return userAge;
}
public void setUserAge(String userAge) {
this.userAge = userAge;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
}
在包com.mybatis.model中创建一个xml文件User.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.mybatis.models.UserMapper">
<select id="selectUserByID" parameterType="int" resultType="User">
select * from `user` where id = #{id}
</select>
</mapper>
现在来利用mybatis里面的类来完成一个简单的查询功能,在src_test创建一个Java文件Test.java,代码如下
import com.mybatis.model.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.Reader;
/**
* Created by Alpha on 17/4/12.
*/
public class Test {
private static SqlSessionFactory sqlSessionFactory;
private static Reader reader;
static{
try{
reader = Resources.getResourceAsReader("Configuration.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
}catch(Exception e){
e.printStackTrace();
}
}
public static SqlSessionFactory getSession(){
return sqlSessionFactory;
}
public static void SimpleSearch(int id){
SqlSession session = sqlSessionFactory.openSession();
try {
User user = (User) session.selectOne("com.mybatis.models.UserMapper.selectUserByID", id);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
}
创建测试类Main,代码如下：
/**
* Created by Alpha on 17/4/12.
*/
public class Main {
public static void main(String[] args){
Test.SimpleSearch(2);
}
}
运行测试代码，结果如下
上述的方法可以采用更好维护的一种方式来修改一下
在src_user目录下面创建一个包com.mybatis.inter,并在包中创建一个接口IUserOperation，里面包含一个方法selectUserByID代码如下
package com.mybatis.model;
/**
* Created by Alpha on 17/4/12.
*/
public interface IUserOperation {
public User selectUserByID(int id);
}
修改User.xml文件的命名空间为IUserOperation
<?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.mybatis.inter.IUserOperation">
<select id="selectUserByID" parameterType="int" resultType="User">
select * from `user` where id = #{id}
</select>
</mapper>
在Test类中新增一个方法SimpleSearchByInterface,代码如下
public static void SimpleSearchByInterface(int id){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(id);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
执行，查看结果如下
按照上面的步骤类似，我们可以对数据进行基本的增删改查，过程不再赘述，下面我把最终的代码贴到下面
User.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.mybatis.inter.IUserOperation">
<select id="selectUserByID" parameterType="int" resultType="User">
select * from `user` where id = #{id}
</select>
<resultMap id="resultListUser" type="User">
<id column="id" property="id"/>
<result column="userName" property="userName"/>
<result column="userAge" property="userAge"/>
<result column="userAddress" property="userAddress"></result>
</resultMap>
<select id="selectUsers" parameterType="string" resultMap="resultListUser">
SELECT * from USER WHERE userName LIKE #{userName}
</select>
<insert id="addUser" parameterType="User" useGeneratedKeys="true"
keyProperty="id">
INSERT INTO USER (userName,userAge,userAddress) VALUES (#{userName},#{userAge},#{userAddress})
</insert>
<update id="updateUser" parameterType="User">
UPDATE USER SET userName=#{userName},userAge=#{userAge},userAddress=#{userAddress} WHERE id=#{id}
</update>
<delete id="deleteUser" parameterType="int">
DELETE FROM USER WHERE id=#{id}
</delete>
</mapper>
Test.java
/**
* 执行查询并返回查询的结果集
*/
public static void getResultList(){
SqlSession session = sqlSessionFactory.openSession();
try{
IUserOperation userOperation = session.getMapper(IUserOperation.class);
List<User> users = userOperation.selectUsers("summer");
for(User user : users){
System.out.println(user.getId() + ":" + user.getUserName() + ":" + user.getUserAddress());
}
}finally {
session.close();
}
}
/**
* 添加数据到数据库中
*/
public static void addUser(User user){
SqlSession session = sqlSessionFactory.openSession();
try{
IUserOperation userOperation = session.getMapper(IUserOperation.class);
userOperation.addUser(user);
//添加后需要提交事务,否则数据库中不会有改变
session.commit();
System.out.println("当前增加的用户id为:" + user.getId());
}finally {
session.close();
}
}
/**
* 更新数据库的数据
*/
public static void updateUser(int id){
SqlSession session = sqlSessionFactory.openSession();
try{
IUserOperation userOperation = session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(id);
user.setUserName("猪头三");
userOperation.updateUser(user);
session.commit();
}finally {
session.close();
}
}
/**
* 删除数据库中的数据
*/
public static void deleteUser(int id){
SqlSession session = sqlSessionFactory.openSession();
try{
IUserOperation userOperation = session.getMapper(IUserOperation.class);
userOperation.deleteUser(id);
session.commit();
}finally {
session.close();
}
}
IUserOperation.java
package com.mybatis.inter;
import com.mybatis.model.User;
import java.util.List;
/**
* Created by Alpha on 17/4/12.
*/
public interface IUserOperation {
public User selectUserByID(int id);
public List<User> selectUsers(String userName);
public void addUser(User user);
public void updateUser(User user);
public void deleteUser(int id);
public List<Article> getUserArticles(int id);
}
好了，既然我们已经利用mybatis完成了一个数据库的增删改查操作，那么接下来我们讨论一下mybatis的XML的配置
XML的配置
mybatis3的配置大标签Configuration的树结构如下所示
configuration
|--- properties
|--- settings
|--- typeAliases
|--- typeHandlers
|--- objectFactory
|--- plugins
|--- environments
|--- |--- environment
|--- |--- |--- transactionManager
|--- |--- |__ dataSource
|__ mappers
在配置的时候需要注意的是配置文件中的属性顺序必须和上面的Configuration的树结构顺序一致，否则就会出现错误
下面让我们来详细讲一讲mybatis的配置
properties
我们对之前的配置文件做一下修改,修改的结果如下:
<configuration>
<properties resource="com/mybatis/model/config.properties">
<property name="username" value="root"/>
<property name="password" value="Jackson"/>
</properties>
<typeAliases>
<typeAlias alias="User" type="com.mybatis.model.User"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/test" />
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/mybatis/model/User.xml"/>
</mappers>
</configuration>
上面在peoperties中有两个成员username和password，在下面引用的时候我们采用的方式是${username}和${password},也就是说properties的作用是定义在其它地方使用的属性，properties的resource的属性定义的是将它所指向的配置文件给包含进来，也就是说我们这么做了就可以直接使用resource中的属性
settings
setting是mybatis中极其重要的属性，它们会改变mybatis运行时的行为。
看下面一个代码
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="multipleResultSetsEnabled" value="true"/>
<setting name="useColumnLabel" value="true"/>
<setting name="useGeneratedKeys" value="false"/>
<setting name="autoMappingBehavior" value="PARTIAL"/>
<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
<setting name="defaultExecutorType" value="SIMPLE"/>
<setting name="defaultStatementTimeout" value="25"/>
<setting name="defaultFetchSize" value="100"/>
<setting name="safeRowBoundsEnabled" value="false"/>
<setting name="mapUnderscoreToCamelCase" value="false"/>
<setting name="localCacheScope" value="SESSION"/>
<setting name="jdbcTypeForNull" value="OTHER"/>
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>
让我们具体看一下其中的意义
cacheEnabled :该配置影响的所有映射器中配置的缓存的全局开关。默认值为true，一般不用进行设置即可
lazyLoadingEnabled:延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置`fetchType`属性来覆盖该项的开关状态，默认值为false
multipleResultSetsEnabled:是否允许单一语句返回多结果集（需要兼容驱动）,默认为true，所以一般不用进行设置
useColumnLabel:使用列标签代替列名。默认设置为true
useGeneratedKeys:允许 JDBC 支持自动生成主键，需要驱动兼容。 如果设置为 true 则这个设置强制使用自动生成主键,默认为false
autoMappingBehavior:指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集,默认为PARTIAL
autoMappingUnknownColumnBehavior:指定发现自动映射目标未知列（或者未知属性类型）的行为。NONE: 不做任何反应,WARNING: 输出提醒日志,('org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN),FAILING: 映射失败 (抛出 SqlSessionException),默认为NONE
defaultExecutorType:配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。默认为SIMPLE
defaultStatementTimeout:设置超时时间，它决定驱动等待数据库响应的秒数。默认什么都没设置，表示等待任意时间
defaultFetchSize: 为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖,默认什么都没设
safeRowBoundsEnabled:允许在嵌套语句中使用分页（RowBounds）,默认为false
mapUnderscoreToCamelCase:是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。默认为false
localCacheScope:MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。默认值为SESSION
jdbcTypeForNull：当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER，默认为OTHER
lazyLoadTriggerMethods:指定哪个对象的方法触发一次延迟加载。默认为equals,clone,hashCode,toString
还有一些其它的配置，在此不再赘述，详情请见官方文档
typeAliases
为Java类型设置一个短的名字，存在的意义仅在于用来减少类完全限定名的冗余，例如
<typeAliases>
<typeAlias alias="User" type="com.mybatis.model.User"/>
</typeAliases>
这个是利用短名User来替代com.mybatis.model.User来进行使用
typeHandlers
如果我们想在数据库中存储一个Date型的字段，但是我们将该字段已经设为了varchar类型了，那么我们怎么去做到这一点呢，也许我们可以先将Date转化为String类型再进行存储，其实我们不必这样操作，我们可以使用TypeHandler的工具来做到这一点，下面我们来用一个例子说明一下这个属性的用法
1. 创建一个继承自BaseTypeHandler的类ExampleTypeHandler，代码如下所示
package com.mybatis.util;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
/**
* Created by Alpha on 17/4/13.
*/
public class ExampleTypeHandler extends BaseTypeHandler<Date> {
@Override
public void setNonNullParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
ps.setString(i,String.valueOf(((Date)parameter).getTime()));
}
@Override
public Date getNullableResult(ResultSet rs, String columnName) throws SQLException {
String sqlTimetamp = rs.getString(columnName);
if(null != sqlTimetamp){
return new Date(Long.valueOf(sqlTimetamp));
}
return null;
}
@Override
public Date getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
String sqlTimetamp = rs.getString(columnIndex);
if(null != sqlTimetamp)
return new Date(Long.valueOf(sqlTimetamp));
return null;
}
@Override
public Date getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
String sqlTimetamp = cs.getString(columnIndex);
if(null != sqlTimetamp)
return new Date(Long.valueOf(sqlTimetamp));
return null;
}
}
2. 创建一个pojo类Note用来存储存入数据库的对象
package com.mybatis.model;
import java.util.Date;
/**
* Created by Alpha on 17/4/13.
*/
public class Note {
private int id;
private Date date;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}
3. 创建一个队Note对象进行数据库操作的xml文件NoteMappper.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.mybatis.inter.NoteMappper">
<resultMap id="note-base" type="com.mybatis.model.Note">
<result property="id" column="id"/>
<result property="date" column="date" typeHandler="com.mybatis.util.ExampleTypeHandler"/>
</resultMap>
<select id="queryNote" parameterType="int" resultMap="note-base">
select * from note where id = #{id}
</select>
<insert id="insertNote" parameterType="com.mybatis.model.Note">
insert into note (id,date) values(#{id},#{date,typeHandler=com.mybatis.util.ExampleTypeHandler})
</insert>
</mapper>
4. 创建映射接口NoteMappper
public interface NoteMappper {
Note queryNote(int id);
void insertNote(Note note);
}
5. 在Configuration添加typeHandler以及映射的NoteMappper.xml文件
<typeHandlers>
<typeHandler handler="com.mybatis.util.ExampleTypeHandler"/>
</typeHandlers>
<mapper resource="com/mybatis/model/NoteMappper.xml"/>
6. 添加测试代码
public static void testTypeHandler(){
SqlSession session = sqlSessionFactory.openSession();
try {
NoteMappper noteMappper = session.getMapper(NoteMappper.class);
Note note = new Note();
note.setId(1);
note.setDate(new Date());
noteMappper.insertNote(note);
session.commit();//默认的自动提交是关闭的,因此需要在此手动提交
note = noteMappper.queryNote(1);
System.out.println(note.getDate());
}finally {
session.close();
}
}
上述操作的的目录结构如下
下面是运行这个程序的结果
看一下数据库中什么情况
所以我们就利用typeHandler实现了特殊类型的存储,当然除了重写BaseTypeHandler,mybatis3还提供了一些已经写好的typeHandler,具体的可以见官方文档
objectFactory
MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象
工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。
--------摘自官网
也就是说默认的对象工厂只会帮我们创建一个未经初始化的类实例，假如我们要对类实例进行修改，我们可以通过覆写默认的对象工厂。
配置如下
<objectFactory type="com.mybatis.util.ExampleObjectFactory">
<property name="someProperty" value="10"/>
</objectFactory>
plugins
mybatis允许你在映射语句执行过程的某一点实施拦截调用,默认情况下，mybatis允许使用插件来拦截的方法调用如下
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)
如何使用plugins呢，我们通过实现Interceptor接口，并指定想要拦截的方法签名即可
environments
mybatis可以配置成多种环境，在我们使用多个数据库时会用到这一点，但是一个SqlSessionFactory实例只能使用其中的一个环境,配置文件的形式如下
<configuration>
<environments default="environment1">
<environment id="environment1">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
.
.
</dataSource>
</environment>
.
.
<environment id="environment3">
<transactionManager type="MANAGED"></transactionManager>
<dataSource type="UNPOOLED">
.
.
</dataSource>
</environment>
</environments>
</configuration>
我们可以使用下面的方法来选择使用哪一个环境
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment,properties);
从上面的代码我们可以看到环境中包括了事务管理器和数据源
事务管理器
事务管理器有两种，JDBC和MANAGED，说明如下
JDBC-这个配置就是直接使用了 JDBC 的提交和回滚设置。
MANAGED-这个配置几乎没做什么。
数据源
数据源包含3中，UNPOOLED、POOLED以及JNDI
UNPOOLED-这个对数据的操作是没有启用数据库连接池的，在每次使用的时候都会打开和关闭连接，由于这样的原因，因此它在使用的时候的速度会比较慢，但是占用的资源相对较少,它的配置参数有下面5个
driver – 这是 JDBC 驱动的 Java 类的完全限定名（并不是JDBC驱动中可能包含的数据源类）。
url – 这是数据库的 JDBC URL 地址。
username – 登录数据库的用户名。
password – 登录数据库的密码。
defaultTransactionIsolationLevel – 默认的连接事务隔离级别。
POOLED-相对于UNPOOLED连接，它的做法是创建了一个包含数个数据库连接的连接池，而且连接不会在使用的时候被关闭，所以它的速度更快，性能更好，但是占用的资源也较多,它的配置属性除了上面的属性之外，还包括下面的部分
poolMaximumActiveConnections – 在任意时间可以存在的活动（也就是正在使用）连接数量，默认值：10
poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
poolTimeToWait – 这是一个底层设置，如果获取连接花费的相当长的时间，它会给连接池打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直安静的失败），默认值：20000 毫秒（即 20 秒）。
poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否处在正常工作秩序中并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
poolPingEnabled – 是否启用侦测查询。若开启，也必须使用一个可执行的 SQL 语句设置 poolPingQuery 属性（最好是一个非常快的 SQL），默认值：false。
poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的使用频度。这可以被设置成匹配具体的数据库连接超时时间，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。
mappers
在上面的例子中，我们创建的配置文件有Configuration.xml、User.xml以及NoteMapper.xml，其中User.xml和NoteMapper.xml是SQL语句映射的配置文件，那么我们在初始化Configuration.xml时如何找到这两个xml文件呢，实际上是通过mappers属性做到的，如下
<mappers>
<mapper resource="com/mybatis/model/User.xml"/>
<mapper resource="com/mybatis/model/NoteMappper.xml"/>
</mappers>
下面我们详细讲一讲Mapper的XML配置文件
网友评论