Mybatis应用

JavaEE企业级开发中的分层架构

微软推荐的分层式结构一般分为三层，从下至上分别为：数据访问层、业务逻辑层、表示层。分层式设计可以达至目的：分散关注、松散耦合、逻辑复用、标准定义。

JavaEE中分层架构：表现层、业务层、持久层

轻量级开发中采用的是：表现层、业务层、持久层、域对象层

• 表现层：MVC模式，SpringMVC，收集客户动作和显示业务数据

• 业务层：Spring框架，封装业务逻辑，逻辑复用

• 持久层：DAO模式、ORM模式，MyBatis，封装数据访问逻辑

• 域对象层：实现层和层之间的数据传递

上层依赖于下层，不允许下层依赖上层，而且不允许跨层访问

为了解除耦合，所以上层是通过接口依赖于下层

持久层和业务层

业务层：主要封装业务逻辑

持久层：主要封装数据访问逻辑

##MyBatis工作原理

MyBatis就是对JDBC操作的浅封装，实现一个针对对象的操作转换为JDBC操作

1）读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。

<environments default="yan">
        <environment id="yan">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///test?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
</environments>

2）加载映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yan.mapper.UserMapper">
    <insert id="create" parameterType="com.yan.entity.UserBean">
        insert into t_users(username, password, birth, sex)
        values (#{username}, #{password}, #{birth}, #{sex})
    </insert>

 <mappers>
        <mapper resource="com/yan/mapper/UserMapper.xml"/>
</mappers>

3）构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory

 Reader r= Resources.getResourceAsReader("mybatis-config.xml");
 SqlSessionFactory fac=new SqlSessionFactoryBuilder().build(r);

4）创建会话对象：由会话工厂创建 SqlSession 对象【实体管理器】，该对象中包含了执行 SQL 语句的所有方法。

SqlSession session=fac.openSession();

session.insert/update/delete/selectOne/selectList

5）Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。

session.selectList("com.yan.dao.UserMapper.selectByExample",user);

6）MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。

7）输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。

select * from t_users where 1=1 and username=#{username} and password=#{password}

select * from t_users where 1=1 and username=? and password=?  这是因为statementType="PREPARED"
ps.setString(1,"yanjun");
ps.setString(2,"123456");

8）输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。

resultMap="userResultMapper"   resultSet==>UserBean

MyBatis核心组件

MyBatis 的核心组件分为 4 个部分。

1）SqlSessionFactoryBuilder构造器：它会根据配置或者代码来生成SqlSessionFactory，采用的是分步构建的Builder模式。

Reader r= Resources.getResourceAsReader("mybatis-config.xml");
factory=new SqlSessionFactoryBuilder().build(r);

• 属于一个即用即丢型对象，创建SqlSessionFactory对象后则没有保留的必要
• 生命周期应该是在一个方法内容

2）SqlSessionFactory工厂接口：依靠它来生成SqlSession，使用的是工厂模式。

SqlSession session=factory.openSession();

• 是一个线程安全的重量级长生命周期对象，应该避免频繁的创建和销毁
• 最佳编程实践是单例模式

3）SqlSession会话：一个既可以发送SQL执行返回结果，也可以获取Mapper的接口。在现有的技术中，一般会让其在业务逻辑代码中消失，而使用的是MyBatis提供的SQL Mapper接口编程技术，它能提高代码的可读性和可维护性。

• 是一个线程不安全的短生命周期对象
• 是Connection对象的浅封装，所以应该使用try/finally结构保证session及时关闭
• 最佳编程实践：采用ThreadLocal管理SqlSession，从而实现一请求对应一个SqlSession对象

4）SQL Mapper映射器：MyBatis设计存在的组件，它由一个Java接口和XML文件或注解构成，需要给出对应的SQL和映射规则。它负责发送SQL去执行，并返回结果。

ThreadLocal本地化线程变量

threadlocal而是一个线程内部的存储类，可以在指定线程内存储数据，数据存储以后，只有指定线程可以得到存储数据

可以理解threadLocal是在JVM中存储的一个Map,其中以线程对象作为key值，可以在map中存取数据。

static ThreadLocal<String> localVar = new ThreadLocal<>();  //保证在VM中localVar只有一个

//清除本地内存中的本地变量
localVar.remove();

 //设置当前线程中本地变量的值
localVar.set("localVar1存储的数据");

//获取当前线程存储的数据
localVar.get()

MyBatis对动态SQL的支持

使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分。

标签if

<select id="findActiveBlogWithTitleLike" resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <if test="title != null">  test属性中是一个表达式，用于判断title参数是否为空，如果不为空则指向标签体
     AND title like #{title}
  </if>
</select>

用户管理系统的开发

1、创建一个Java Enterprise项目

<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

2、引入MyBatis框架

引入依赖

<dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
<!--为了在控制台上显示所执行的SQL语句，方便开发调试 -->
 <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

定义核心配置文件 resources/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 resource="database.properties"/>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <environments default="yan">
        <environment id="yan">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

将数据库相关的配置信息分离到一个properties文件种

resources/database.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///test?serverTimezone=UTC
username=root
password=123456

为了实现日志输出，resources/log4j.properties

# 全局日志配置
log4j.rootLogger=DEBUG, stdout
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%m%n

3、数据库设计

逻辑数据模型(ER图)—数据库选型—物理数据模型(SQL语句)

规范化法：创建模式—应用范式—反范式

create table t_users(
	id bigint primary key auto_increment,
	username varchar(20) not null unique,
	password varchar(20) not null,
	birth datetime default now(),
	sex boolean default 1,
	salary numeric(8,2) default 0
)engine=innodb default charset utf8;

建立和表对应的实体类，引入lombok

@Data
public class UserBean implements Serializable {
    private Long id;
    private String username;
    private String password;
    private Date birth;
    private Boolean sex;
    private Double salary;
}

定义相关的映射元文件 resources/com/yan/dao/UserBean-mapper.xml

为了简化映射元文件种引用类名编写的问题，在mybatis-config.xml中定义类型别名

 <typeAliases>
        <typeAlias type="com.yan.entity.UserBean" alias="User"/>
</typeAliases>

在映射元文件种如果要使用com.yan.entity.UserBean类型全名，可以使用别名User替代

<?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.yan.dao.UserMapper">
    <resultMap id="userResultMapper" type="User" autoMapping="true">
        <id column="id" property="id" javaType="long"/>
        <result column="username" property="username" javaType="string"/>
        <result column="password" property="password" javaType="string"/>
        <result column="birth" property="birth" jdbcType="DATE"/>
    </resultMap>
</mapper>

定义对应的映射接口 com.yan.dao.UserMapper.java

public interface UserMapper {
}

4、在DAO的基础上构建业务层

• 用户登录是一个具体的业务逻辑
• 按照用户名和口令查询数据库是一个持久层操作

业务接口

package com.yan.biz;

public interface IUserServ {
}

具体的业务实现类

package com.yan.biz;

public class UserServImpl implements IUserServ{
}

业务工厂类

• 简化版的静态工厂方法模式

package com.yan.util;

import com.yan.biz.IUserServ;
import com.yan.biz.UserServImpl;

public class ServiceFactory {
    public static IUserServ getUserService(){
        return new UserServImpl();
    }
}

5、尝试添加一个登录操作

在业务接口中添加登录方法声明

public interface IUserServ {
    boolean login(UserBean user);
}

在业务实现类中添加方法的实现

public class UserServImpl implements IUserServ{
    
    public boolean login(UserBean user) {
        boolean res=false;
        //业务数据验证
        if(user==null || user.getUsername()==null || user.getPassword()==null)
            throw new IllegalArgumentException("参数不合法!");
        // TODO 调用DAO完成数据库的访问,不允许跨层访问
        return res;
    }
}

在DAO中新增按照用户名和口令的查询

• 参考JDBC编程中的动态SQL语句编程，传递的参数是一个UserBean，这个对象中的非空数据就是查询条件

public interface UserMapper {
    List<UserBean> selectByExample(UserBean user);
}

MyBatis中针对动态SQL提供支持

<select id="selectByExample" parameterType="User" resultMap="userResultMapper">
        select <include refid="columns"/> from t_users where 1=1
        <if test="username!=null">
            and username = #{username}
        </if>
        <if test="password!=null">
            and password=#{password}
        </if>
</select>

在MyBatis框架中UserMapper接口没有实现类，是由框架提供代理实现

针对动态SQL进行单元测试

添加依赖

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
</dependency>

编写测试类

public class UserMapperTest {
    private static SqlSessionFactory factory;
    @BeforeClass
    public static void bb() throws Exception{
        Reader r= Resources.getResourceAsReader("mybatis-config.xml");
        factory=new SqlSessionFactoryBuilder().build(r);
    }
    @AfterClass
    public static void aa()throws Exception{
        factory=null;
    }
    @Test
    public void testSelectByExample(){
        SqlSession session=factory.openSession();
        UserMapper userMapper=session.getMapper(UserMapper.class);
        UserBean user=new UserBean();
//        user.setUsername("zhangsan");
//        user.setPassword("123456");
        List<UserBean> userList=userMapper.selectByExample(null);
        userList.forEach(System.out::println);
        session.close();
    }
}

• 传递参数user时如果username或者password中一个属性非空，则出现一个查询条件
• 传递参数user时如果username和password都为空，则不会出现查询条件
• 如果参数为null，则不会出现查询条件
• 传递参数user时如果username或者password属性值为""，则出现查询条件，只是按照空字符串进行查询