MyBatis——MyBatis开发流程
目录
创建项目（IDEA 中）
在 IDEA 中创建 MyBatis 项目，详细流程如下：
这里有一点需要注意，我们创建的是 Maven 项目，如果大家以前没有配置过 Maven 环境的话，在创建完项目之后，需要配置一下 Maven 环境，否则就无法成功导入相关的依赖包。
创建完成后的项目是这个样子的：
项目概述：
★ src 目录就是我们项目的开发目录，里面有两个目录：main 和 test。
➷ main 目录是我们开发项目的目录，里面是项目的几乎所有信息，包括 Java 的类文件、一些 properties 配置文件和 MyBatis 配置文件等。
✈ main 目录下有两个文件夹：Java 和 resources，顾名思义，Java 目录下肯定就是 Java 类文件了；resources 目录下放的的是配置文件。
➷ test 目录是我们项目开发的测试目录，我们在这个目录下来写我们的测试类，来测试我们所写的功能是否能够正常运作。
✄ 还有一个 pom.xml 文件，这个文件是我们所创建的 Maven 项目的依赖导入配置文件，我们在这个配置文件中写上项目所需要依赖的包的相关信息，Maven 会替我们自动导入项目，不用我们主动下载并添加依赖包，这样能极大的减轻我们的工作量。
其他文件我们不用过多关注，都是一些项目配置信息，一般很少用到。
导入依赖（配置 pom 文件）
我们需要导入的项目依赖主要由以下几个：
① MyBatis 核心依赖
② MySql 驱动依赖
③ 日志依赖：Log4J
④ 测试依赖：junit
⑤ 连接池依赖
这些都是项目基础的依赖配置，后面根据项目需求可添加其他的依赖项，比如：分页组件依赖等。
我们是在 pom.xml 文件中配置的，在 pom.xml 文件中的 project 标签中加入下面的信息：
<!-- 导入依赖 -->
<dependencies>
<!--MyBatis 核心依赖 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<!--MySql 驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.25</version>
</dependency>
<!-- 日志依赖：Log4J -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<!-- 测试依赖：junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<!-- 连接池依赖：阿里的 druid（可选其他，目前这个是比较好的） -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
</dependencies>
我这里选用的连接池是阿里的 druid 连接池，目前来说应该是比较好的连接池了，大家可根据自己的需求自行调整，更换其他的连接池。
依赖的版本之间可能存在冲突现象，大家可选择普遍都用的版本，可参考Maven 存储库。
创建并编写 MyBatis 配置文件（mybatis-config.xml）
在 resources 目录下创建『mybatis-config.xml』配置文件，这个文件就是我们 MyBatis 项目的配置文件，之后我们也要通过它来创建 SqlSessionFactory 对象，因一步来创建 SqlSession 对象。
『mybatis-config.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?, settings?, typeAliases?,
typeHandlers?, objectFactory?, objectWrapperFactory?,
reflectorFactory?, plugins?, environments?,
databaseIdProvider?, mappers?)-->
</configuration>
我们是在 configuration 标签中添加我们的配置项的，配置项是有顺序的，必须依照官方给的顺序从上往下依次放置，否则会导致一些问题，比如配置失效等。
数据库配置信息（jdbc.properties）
MyBatis 要和数据库打交道，那肯定需要连接数据库了，所以，我们现在要配置的就是数据库信息。
首先，在 resources 目录下创建『jdbc.properties』配置文件, 这个是数据库配置文件，在里面添加如下信息：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/{数据库名}?useUnicode=true&characterEncoding=utf-8
jdbc.username={用户名}
jdbc.password={密码}
大家根据自己的信息，替换配置中的 {XXX}。上面这个是 MySQL 的连接配置，如果大家连接的是其他数据库的话，可更该此配置中的信息。
然后，我们需要『mybatis-config.xml』的 configuration 标签中配置相关信息：
<configuration>
<!-- 导入外部的参数 -->
<properties resource="jdbc.properties"></properties>
<!-- 核心配置信息 -->
<environments default="ss_config">
<!-- 数据库相关配置 -->
<environment id="ss_config">
<!-- 事务控制类型 -->
<transactionManager type="jdbc"></transactionManager>
<!-- 数据库连接配置 -->
<dataSource type="org.apache.ibatis.datasource.pooled.PooledDataSourceFactory">
<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>
</configuration>
我们导入了 jdbc 的配置文件，然后在 environments 标签项中配置相关信息，default 属性和 id 属性可根据自己意愿填写（其实就是个名字而已），我们在这选用的是 MyBatis 默认的连接池，dataSource 标签的 type 属性就是，之后我们可选择更改性能更好的连接池。
其他的配置信息应和上述配置一致。
日志配置信息（log4j.properties）
我们之前已经导入了 Log4j 日志框架的依赖，这个日志框架可以帮我们输出日志信息，以便我们更好的调试可开发项目。我们还需要做的是编写一个日志配置文件，填写相关配置信息。
在 resources 目录下创建『log4j.properties』配置文件, 注意名称是全小写的，在其内添加如下信息：
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
好了，日志配置已完成，MyBatis 会自动检索配置信息。
创建表（数据库表）
在刚才『jdbc.properties』配置文件中所填的数据库中创建数据表，我们在这以 users 表为例：
CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL,
`password` varchar(50) DEFAULT '12345',
`sex` varchar(1) DEFAULT NULL,
`birthday` datetime DEFAULT NULL,
`registtime` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
)DEFAULT CHARSET=utf8;
创建成功后，在表中添加一些信息，如：
创建实体映射（entity 实体）
好了，我们需要创建一个实体，来对应数据库中的表中的数据项。
在 java 目录下创建 com.entity 实体类包，在包中创建 User 实体类：
User 实体类的属性要和数据表的字段对应，类型和名字要相同，最好使用驼峰命名法，因为当 MyBatis 从数据库中得到数据后时进行 set 注入的，就是调用对应属性名字的 set 方法进行赋值，如果属性名字不一致，MyBatis 就无法找到其 set 方法，其值会为默认值。
当名字不一致时我们的解决方法是：Sql 语句加别名 或者 添加关系映射（推荐使用）。
例如下面的 User 实体的最后一个属性名就和数据表的最后一个字段名不一致，我们在后面会进行处理。
User 实体类如下：
package com.entity;
import java.util.Date;
public class User {
private Integer id;
private String name;
private String password;
private String sex;
private Date birthday;
private Date registTime;
public User() {}
public User(Integer id, String name, String password, String sex, Date birthday, Date registTime) {
this.id = id;
this.name = name;
this.password = password;
this.sex = sex;
this.birthday = birthday;
this.registTime = registTime;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", password='" + password + '\'' +
", sex='" + sex + '\'' +
", birthday=" + birthday +
", registTime=" + registTime +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public Date getRegistTime() {
return registTime;
}
public void setRegistTime(Date registTime) {
this.registTime = registTime;
}
}
定义别名
我们还需要在 MyBatis 配置文件『mybatis-config.xml』中为我们的实体类定义别名，这样我们就不用总带着包名一起来书写了，可以提高我们的书写效率。
定义别名有两种方式，一般我们选择第二种：
<!-- 实体类别名 -->
<typeAliases>
<!-- 方式一：单独定义 -->
<!--<typeAlias type="com.entity.User" alias="user_shine"/>-->
<!-- 方式二：定义实体类所在的 package，每个实体类都会自动注册一个别名 = 类名 -->
<package name="com.entity"/>
</typeAliases>
在『mybatis-config.xml』的 configuration 标签内的 properties 标签后面添加上述配置信息。
创建 Dao 层
接下来我们要编写数据访问层了，也就是 DAO 层。
在 java 目录下创建一个包：com.Dao。
创建 xxDao 接口文件
在刚才所创建的包内创建 User 实体类所对应的 Dao 接口文件：UserDao.java。
在这个接口文件中，定义我们要对数据进行的操作方法，如：
package com.Dao;
import com.entity.User;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface UserDao {
// 查询全部
public List<User> queryAll();
// 通过 id 查询
public User selectUserById(@Param("id") Integer id);
// 模糊查询
public List<User> selectUserByKeyword(@Param("keyword") String keyword);
// 插入
public Integer insertUser(User user);
// 删除
public Integer deleteUser(@Param("id") Integer id);
// 修改
public Integer updateUser(User user);
}
在上面的方法中涉及到参数的传递，也就是参数绑定方式，常见的参数绑定方式有：
➷ 序号参数绑定
➷ 注解参数绑定（推荐）
➷ Map 参数绑定
➷ 对象参数绑定
我们上面所用的就是注解参数绑定，因为篇幅考虑，就不做过多阐述了。
创建 xxDaoMapper.xml 配置文件
创建了上面的这些方法，如何去实现它们呢？
这就要靠我们的 Mapper 配置文件了，一个 Dao 接口文件对应一个 Mapper 配置文件。MyBatis 替我们封装了数据访问的其他操作，我们只需要关注 Sql 语句本身就可以了，而 Sql 语句写在哪呢？就是 Mappe 配置文件中。
在 com.Dao 包中创建 Mapper 配置：UserDaoMapper.xml。
配置 xxDaoMapper.xml
下面是 Mapper 文件的初始模板：
<?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.dao.UserDao">
</mapper>
mapper 标签中的 namespace 属性是我们这个 Mapper 文件所对应的 Dao 接口文件，mapper 标签中书写 Dao 接口中每个方法所对应的 Sql 语句。
上面的 Dao 接口所对应的完整 Mapper 配置如下：
<?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.Dao.UserDao">
<resultMap id="UserResultMap" type="com.entity.User">
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="password" column="password"/>
<result property="sex" column="sex"/>
<result property="birthday" column="birthday" />
<result property="registTime" column="registtime" />
</resultMap>
<sql id="user_field">
select id, name, password,sex,birthday,registtime
from s_user where
</sql>
<select id="queryAll" resultType="User">
select * from s_user
</select>
<select id="selectUserById" resultMap="UserResultMap">
<include refid="user_field"/>
id = #{id}
</select>
<select id="selectUserByKeyword" resultMap="UserResultMap">
<include refid="user_field"/>
name like concat('%',#{keyword},'%')
</select>
<insert id="insertUser" parameterType="User">
<selectKey keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID()
</selectKey>
insert into s_user
values(#{id},#{name},#{password},#{sex},#{birthday},#{registTime})
</insert>
<delete id="deleteUser" parameterType="int">
delete from s_user
where id=#{id}
</delete>
<update id="updateUser" parameterType="User">
update s_user set name=#{name},password=#{password},sex=#{sex},birthday=#{birthday},
registtime=#{registTime} where id=#{id}
</update>
</mapper>
resultMap 标签就是我们上面提到的属性关系映射，来解决字段名不一致的问题，当我们需要用的时候，将 select 标签的 resultType 属性改为 resultMap 就可以了。
每种操作有对应的标签，id 就是其方法名，后面是传递的值类型。
注册 Mapper
写完 Mapper 后，是需要注册的，在『mybatis-config.xml』的 configuration 标签内添加如下信息：
<!-- 注册 mapper 文件 -->
<mappers>
<mapper resource="com/Dao/UserDaoMapper.xml"/>
</mappers>
注册成功后，MyBatis 才会去寻找这个配置文件。
配置编译路径
此时这个配置文件，MyBatis 是找不到的，为什么呢？因为 MyBatis 只会自动查找 resources 目录下的配置文件，而我们的 Mapper 配置文件并不在 resources 目录下。那如何解决呢？
我们需要在 pom.xml 文件的 project 标签中添加如下信息：
<build>
<!-- 更改 maven 编译规则 -->
<resources>
<resource>
<!-- 资源目录 -->
<directory>src/main/java</directory>
<includes>
<include>*.xml</include><!-- 默认（新添加自定义则失效） -->
<include>**/*.xml</include><!-- 新添加 */ 代表 1 级目录 **/ 代表多级目录 -->
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
自此，Mapper 配置才会生效。
编写工具类
MyBatis 的核心是 SqlSessionFactoryBuider、SqlSessionFactory 和 SqlSession 对象，三者依次为创建关系，最终我们要得到的是 SqlSession 对象，通过 SqlSession 对象来进项数据的访问，但每次访问时都需要编写创建 SqlSession 对象的这一系列过程，完成后又要反向依次关闭，使得代码有很多的重复。
因此，我们可以编写一个工具类，帮我们同一来完成这些操作，每次访问数据时调用工具类来获取 SqlSession 对象，完成后用工具类统一来关闭对象。
在 java 目录下创建一个工具包：com.Utils。
在包中创建工具类：MyBatisUtils.java。
MyBatisUtils.java 详细信息如下：
package com.Utils;
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.IOException;
import java.io.InputStream;
/**
* 1. 加载配置
* 2. 创建 SqlSessionFactory
* 3. 创建 Session
* 4. 事务管理
* 5. Mapper 获取
*/
public class MyBatisUtils {
// 获取 SqlSessionFactory
private static SqlSessionFactory factory;
// 创建 ThreadLocal 绑定当前线程中的 SqlSession 对象
private static final ThreadLocal<SqlSession> t1 = new ThreadLocal<SqlSession>();
// 加载配置信息, 并构建 session 工厂
static{
try {
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
factory = new SqlSessionFactoryBuilder().build(is);
} catch (IOException e) {e.printStackTrace();
}
}
// 获取连接（从 t1 中获取当前线程 SqlSession）
private static SqlSession openSession(){SqlSession session = t1.get();
if (session == null){session = factory.openSession();
t1.set(session);
}
return session;
}
// 获取连接（新创建的）
public static SqlSession getSession(){
return factory.openSession();}
// 释放连接（释放当前线程中的 SqlSession）
public static void closeSession(){SqlSession sqlSession = t1.get();
sqlSession.close();}
// 提交事务（提交当前线程中的 SqlSession 所管理的事务）
public static void commit(){SqlSession sqlSession = openSession();
sqlSession.commit();
closeSession();}
// 回滚事务（回滚当前线程中 SqlSession 所管理的事务）
public static void rollback(){SqlSession sqlSession = openSession();
sqlSession.rollback();
closeSession();}
// 获取接口实现类对象
public static <T> T getMapper(Class<T> mapper){SqlSession sqlSession = openSession();
return sqlSession.getMapper(mapper);
}
}
编写测试类
在 test 目录下的 java 目录下创建测试类包：com.Test，并创建测试类 test.java。
编写测试类：
package com.Test;
import com.Utils.MyBatisUtils;
import com.Dao.UserDao;
import com.entity.User;
import org.junit.Before;
import java.util.Date;
import java.util.List;
public class Test {
UserDao userDao;
@Before
public void init(){userDao = MyBatisUtils.getMapper(UserDao.class);
}
// 测试查询全部
@org.junit.Test
public void TestQueryAll(){List<User> users = userDao.queryAll();
for (User user : users) {System.out.println(user);
}
}
// 测试通过 id 查询
@org.junit.Test
public void TestselectUserById(){
User user = userDao.selectUserById(2);
System.out.println(user);
}
// 测试模糊查询
@org.junit.Test
public void TestselectUserByKeyword(){
List<User> users = userDao.selectUserByKeyword("明");
for (User user : users) {System.out.println(user);
}
}
// 测试插入
@org.junit.Test
public void TestinsertUser(){
User user = new User(null, "辰东", "123472", "男", new Date(), new Date());
userDao.insertUser(user);
MyBatisUtils.commit();
System.out.println("刚插入的用户 id 为：" + user.getId());}
// 测试删除
@org.junit.Test
public void TestdeleteUser(){
userDao.deleteUser(15);
MyBatisUtils.commit();}
// 测试修改
@org.junit.Test
public void TestupdateUser(){
User user = new User(14, "辰南", "888888", "男", new Date(), new Date());
userDao.updateUser(user);
MyBatisUtils.commit();}
}
运行 TestQueryAll 方法，结果如下：
一个简单的 MyBatis 项目搭建完毕。除了上述的这些点之外，还有许多的知识点，如缓存、动态 SQL、注解、级联等等，后面有时间了，我会进一步整理。
感谢大家的耐心阅读，如有不足，请多多指教！☺
__EOF__