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>

    <!-- //mvnrepository.com/artifact/junit/junit -->
    <!-- 测试依赖:junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- //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 Mapper 3.0//EN"
        "//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}"/>
                <!-- &转义&amp; -->
                <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"
        "//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"
                "//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、注解、级联等等,后面有时间了,我会进一步整理。

  感谢大家的耐心阅读,如有不足,请多多指教!☺