Mybatis

<!-- 引入数据库依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

程序代码：JdbcTest.java使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作

public class JdbcTest {

    public static void main(String[] args) {

        Connection connection = null;

        PreparedStatement preparedStatement = null;

        ResultSet resultSet = null;

        try {

            Class.forName("com.mysql.cj.jdbc.Driver"); // 加载数据库驱动

            // 通过驱动管理类获取数据库链接

            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai", "root", "root");

            String sql = "select * from user where username = ?"; // 定义sql语句 ?表示占位符

            preparedStatement = connection.prepareStatement(sql); // 获取预处理statement

            // 设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值

            preparedStatement.setString(1, "王五");

            resultSet = preparedStatement.executeQuery();// 向数据库发出sql执行查询，查询出结果集

            while (resultSet.next()) { // 遍历查询结果集

                System.out.println(resultSet.getString("id") + "  " + resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {

                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.问题总结

1)、数据库连接，使用时就创建，不使用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能。

设想：使用数据库连接池管理数据库连接。

2)、将sql语句硬编码到java代码中，如果sql 语句修改，需要重新编译java代码，不利于系统维护。

设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译。

3)、向preparedStatement中设置参数，对占位符号位置和设置参数值，硬编码在java代码中，不利于系统维护。

设想：将sql语句及占位符号和参数全部配置在xml中。

4)、从ResultSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，不利于系统维护。

设想：将查询的结果集，自动映射成java对象。

二，Mybatis框架原理

1.mybatis是什么？

mybatis是一个==持久层的框架==，是apache下的顶级项目。mybatis托管到goolecode下，再后来托管到github下(Releases · mybatis/mybatis-3 · GitHub)。

常见持久层的框架：Mybatis 、 Mybatis_Plus、通用Mapper、JPA、hibernate等

mybatis让程序员将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成（半自动化，大部分需要程序员编写sql）满足需要sql语句。 mybatis可以将向 preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象。（输出映射）

2.mybatis框架原理

1、 mybatis配置

SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

2、通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

3、由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

4、 mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、 Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

6、 Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

7、 Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

三.mybatis入门程序

1.工程结构

1.1 需求

根据用户id（主键）查询用户信息

根据用户名称模糊查询用户信息

添加用户

删除用户

更新用户

1.2 修改pom.xml，引入相关依赖

<!-- 引入mybatis依赖 -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.6</version>
</dependency>

1.3 新建log4j.properties日志属性文件

mybatis默认使用log4j作为输出日志信息。

在src文件夹下，创建了resources文件夹，右击选择Mark Directory as --> resources root，在其里面创建log4j.properties文件如下：

# Global logging configuration
# 在开发环境下日志级别要设置成DEBUG，生产环境设置成info或error
log4j.rootLogger=DEBUG, stdout
# 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

修改pom.xml，添加日志依赖

<!-- 引入日志依赖 -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

1.4 新建db.properties属性文件

#mysql
db.user=root
db.password=root
db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
db.driverClass=com.mysql.cj.jdbc.Driver
db.maxPoolSize=30
db.minPoolSize=3
db.initialPoolSize=5
db.acquireIncrement=5

修改pom.xml，添加mysql依赖

<!--mysql驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

1.5 SqlMapConfig.xml核心配置文件

SqlMapConfig.xml是mybatis核心配置文件，配置mybatis的运行环境，数据源、事务等。

在src文件夹下，创建了resources文件夹，在其里面创建SqlMapConfig.xml文件。

首先，先创建mybatis核心配置文件模版

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

</configuration>

其次，再新建SqlMapConfig.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>
    
    <!-- 加载属性文件  db.properties -->
    <properties resource="db.properties"></properties>

    <!-- 配置全局参数 -->
    <!--<settings></settings>-->

    <!-- 自定义别名:扫描指定包下的实体类，给这些类取别名，默认是它的类名或者类名首字母小写 -->
    <typeAliases>
        <package name="com.cm.entity"/>
    </typeAliases>

    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理,事务控制由mybatis-->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池，由mybatis管理，通过${}直接加载属性文件上的值-->
            <!--  -->
            <dataSource type="POOLED">
                <property name="driver" value="${db.driverClass}" />
                <property name="url" value="${db.jdbcUrl}" />
                <property name="username" value="${db.username}" />
                <property name="password" value="${db.password}" />
            </dataSource>
        </environment>
    </environments>


    <!-- 批量加载mapper映射文件：指定mapper接口所在的包名，mybatis为其生成代理对象 -->
    <mappers>
        <package name=" " />
    </mappers>
  
</configuration>

1.6 Mapper映射文件

若想在与同名接口同路径下创建Mapper映射文件，需要修改pom.xml。

原因是IDEA编译后默认会把resources下的文件放到target的classpath下，但是src下的只有Java文件编译生成.class文件放入classpath下，其他文件会忽略的，例如.xml文件。

<build>
  <!-- 识别在src/main/java路径下的xml文件 -->
  <resources>
    <resource>
      <directory>src/main/java</directory>
      <includes>
        <include>**/*.xml</include>
      </includes>
    </resource>
  </resources>
</build>

首先，先创建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=" ">
    
</mapper>

其次，再新建Mapper映射文件

1.7 工程结构

2.根据id查询用户

2.1 创建entity.User类

User.java作为mybatis进行sql映射使用，通常属性名与数据库表字段对应

import java.util.Date;

//属性名称和数据库表的字段对应
public class User {

    private int id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日  java.util.Date;
    private String address;// 地址

    public User() {
    }

    public User(int id, String username, String sex, Date birthday, String address) {
        this.id = id;
        this.username = username;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    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 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 String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

2.2 修改映射文件UserMapper.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">

<!--
    namespace 命名空间，作用就是对sql进行分类化管理，用于隔离sql语句
    注意：将来使用mapper代理方法开发，namespace有特殊重要的作用
-->
<mapper namespace="com.cm.ch01.mapper.UserMapper">

    <!-- 根据用户id（主键）查询用户信息
        1.id ：作为唯一标识
        2.parameterType ：输入参数映射的类型
        3.resultType ：输出参数映射的类型，可以直接使用别名
        4.? 占位符 ： #{} 
            若是简单数据类型，{}里面的名字可以任意写；
            若是引用数据类型，{}里面的名字只能与此类型中的    属性名一致
     -->
    <select id="selectUserById" parameterType="Integer" resultType="User">
            select * from user where id = #{id}
    </select>

</mapper>

2.3 创建UserMapper.java接口

/**
  MyBatis 实现映射关系的规范：
  1.Mapper接口和Mapper的xml文件，必须要同名且在同包下
  2.Mapper的xml文件中的，namespace的值必须是同名Mapper接口的全类名
  3.Mapper接口中的，方法名必须与Mapper的xml中的id一致
  4.Mapper接口中的方法的形参类型，必须与Mapper的xml中的parameterType的值一致
  5.Mapper接口中的方法的返回值类型，必须与Mapper的xml中的resultType的值一致
*/
public interface UserMapper {
    //通过id查询用户信息
    public User selectUserById(Integer id);
}

2.4 在SqlMapConfig.xml中加载映射文件

在sqlMapConfig.xml中加载User.xml:

 <!-- 批量加载mapper映射文件：指定mapper接口所在的包名，mybatis为其生成代理对象 -->
<mappers>
  <package name="com.cm.ch01.mapper" />
</mappers>

2.5 新建junit测试类

1). 修改test目录，右击选择Mark Directory as -> Test Resources Root

2). 选择需要建junit测试类的接口，右击选择Go To -> Test

3). 创建UserMapperTest类，勾选需要测试的方法

4). 编写测试类

public class UserMapperTest {

    //创建会话工厂对象
    private SqlSessionFactory factory;

    @Before
    public void setUp() throws Exception {
        //加载mybatis核心配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        factory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    @Test
    public void selectUserById() {
        SqlSession sqlSession = factory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.selectUserById(1);
        System.out.println(user);
        sqlSession.close();
    }
  
}

3.根据用户名称模糊查询用户信息

3.1 修改映射文件UserMapper.xml

<!-- 根据用户名进行模糊查询 -->
<select id="selectUserByName" parameterType="String" resultType="User">
  <!-- concat()函数，实现拼接 -->
  select * from user where username like CONCAT('%',#{username},'%')
</select>

3.2 修改UserMapper.java接口

 //通过名称模糊查询用户信息
 public List<User> selectUserByName(String name);

3.3 修改junit测试类

@Test
public void selectUserByName() {
  SqlSession sqlSession = factory.openSession();
  UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  List<User> userList = userMapper.selectUserByName("小明");
  for (User user : userList) {
    System.out.println(user);
  }
  sqlSession.close();
}

4.添加用户

4.1 修改映射文件UserMapper.xml

<!-- 添加用户 -->
<insert id="insertUser" parameterType="User">
    <!-- 获得当前插入对象的id值 -->
    <selectKey keyProperty="id" order="AFTER" resultType="Integer">
      select LAST_INSERT_ID()
    </selectKey>
    
  insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>

4.2 修改UserMapper.java接口

//插入用户信息
public void insertUser(User user);

4.3 修改junit测试类

@Test
public void insertUser() throws ParseException {
  SqlSession sqlSesison = factory.openSession();
  UserMapper userMapper = sqlSesison.getMapper(UserMapper.class);
  
  String str = "2019-09-09 12:12:12";
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  Date date = sdf.parse(str);
  User user = new User("里斯","2",date,"苏州");
  
  userMapper.insertUser(user);
  System.out.println(user);
  sqlSesison.commit();
  sqlSesison.close();
}

5.修改用户

5.1 修改映射文件UserMapper.xml

<!-- 更新用户 -->
<update id="updateUser" parameterType="User">
  update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}
  where id = #{id}
</update>

5.2 修改UserMapper.java接口

//更新用户信息
public void updateUser(User user);

5.3 修改junit测试类

@Test
public void updateUser() {
  SqlSession sqlSesison = factory.openSession();
  UserMapper userMapper = sqlSesison.getMapper(UserMapper.class);
  User user = userMapper.selectUserById(29);
  user.setUsername("李四");
  userMapper.updateUser(user);
  sqlSesison.commit();
  sqlSesison.close();
}

6.删除用户

6.1 修改映射文件UserMapper.xml

<!-- 删除用户 -->
<delete id="deleteUser" parameterType="int">
  delete from user where id = #{id}
</delete>

6.2 修改UserMapper.java接口

//删除用户信息
public void deleteUser(Integer id);

6.3 修改junit测试类

@Test
public void deleteUser() {
  SqlSession sqlSesison = factory.openSession();
  UserMapper userMapper = sqlSesison.getMapper(UserMapper.class);
  userMapper.deleteUser(29);
  sqlSesison.commit();
  sqlSesison.close();
}