Mybatis学习笔记（上）

Mybatis

视频中环境：

• JDK1.8
• Mysql 5.7
• maven 3.6.1
• IDEA

个人环境：

• JDK 14.0.1
• Mysql 8.0.20
• maven 3.3.9（IDEA自带）
• IDEA 2019.1.3

1.简介

1.1 什么是Mybatis

MyBatis 是一款优秀的持久层框架

它支持自定义 SQL、存储过程以及高级映射

MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作

MyBatis可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects）为数据库中的记录。

本来是apache的一个开源项目ibatis，2010年迁移到Google，改名为mybatis，2013年迁移到Github

获取Mybatis

maven:

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

Github：https://github.com/mybatis/mybatis-3/releases

官方中文文档：https://mybatis.org/mybatis-3/zh/index.html

1.2 持久层

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库（JDBC）和 IO 文件持久化。

为什么需要持久化：

• 有一些对象的信息不能丢失
• 内存很贵

1.3 持久层

Dao层，Service层，Controller层

• 完成持久化工作的代码块
• 层界限十分明显

1.4 Mybatis存在理由

• 方便
• 传统的JDBC太复杂，需要框架来简化，自动化
• 帮助程序员将数据存到数据库中

优点

• 简单易学
• 灵活：不会对应用程序或数据库现有设计强加任何影响，sql写在xml里，便于统一规划管理
• 接触sql和程序代码之间的耦合，sql与代码分离，提高可维护性
• 提供映射标签，支持对象与数据库的orm字段映射
• 提供对象关系映射标签，支持对象关系组建维护
• 提供xml标签，支持编写动态sql

2. 第一个Mybatis程序

搭建环境，导入Mybatis，编写代码，测试

2.1搭建环境

1.搭建数据库 (使用SQLyog软件)

CREATE DATABASE `mybatis`;

USE `mybatis`; 

CREATE TABLE `user`(
	`id` INT(20) NOT NULL PRIMARY KEY, 
	`name` VARCHAR(30) DEFAULT NULL, 
	`pwd`VARCHAR(30) DEFAULT NULL
)ENGINE =INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user` (`id`,`name`,`pwd`) VALUES
(1,'张三','123456'),
(2,'李四','123456'),
(3,'王五','123456')

2.新建maven项目

3.删除src目录

4.导入maven依赖

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
    </dependencies>

2.2创建模块

1.编写Mybatis核心配置文件

url后面的东西要写好，不然在数据库中存储中文会出现问题（实际上这一段代码还会有问题，后面会详细说）

中的内容一定要写全，这是在核心配置文件中注册mappers（Mappers Registry）

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

    <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://localhost:3306/mybatis?useSSL=true&amp;useUnicode-true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    
<!--    每一个Mappers.xml都需要在Mybatis核心文件中注册-->
    <mappers>
        <mapper resource="com/tyrion/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

2.编写Mybatis工具类

使用到的类：

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此SqlSessionFactory 的最佳作用域是应用作用域。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的 SqlSession 实例。**SqlSession的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。**绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。如果你现在正在使用一种 Web 框架，考虑将SqlSession 放在一个和 HTTP 请求相似的作用域中。**换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。**这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。下面的示例就是一个确保 SqlSession 关闭的标准模式：

try (SqlSession session = sqlSessionFactory.openSession()) {
  // 你的应用逻辑代码
}

MybatisUtils工具类

package com.tyrion.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;

//sqlSessionFactory --> sqlSeeesion
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {

        try {
            //使用Mybatis第一步：获取sqlSessionFactory对象
            String resource="mybatis-config.xml";
            InputStream inputStream= Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


//    既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
//    SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
//    你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如：
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3 编写代码

1.实体类

package com.tyrion.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

2.Dao接口

package com.tyrion.Dao;

import com.tyrion.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUserList();
}

3.接口实现类（由原来的UseDaoImpl转换为一个Mapper配置文件）

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会绑定一个对应的Mapper（Dao）接口-->
<mapper namespace="com.tyrion.Dao.UserDao">

<!--    查询语句    id是接口中对应的方法名，resultType是返回的数据类型-->
    <select id="getUserList" resultType="com.tyrion.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4 测试

产生问题：

1.找不到文件

java.lang.ExceptionInInitializerError
Caused by: org.apache.ibatis.exceptions.PersistenceException: 

### Error building SqlSession.

### The error may exist in UserMapper.xml

### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.io.IOException: Could not find resource UserMapper.xml

解决方法：

在pom.xml文件中进行配置

<!--    在build中配置resources，防止我们自愿到出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

2.驱动更新

Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

需要在mybatis-config.xml文件中将驱动进行修改

<property name="driver" value="com.mysql.cj.jdbc.Driver"/>

3.时区问题

Error querying database.  Cause: java.sql.SQLException: The server time zone value '�й���׼ʱ��' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the 'serverTimezone' configuration property) to use a more specifc time zone value if you want to utilize time zone support.

解决方法：mybatis-config.xml文件中将url进行修改

<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode-true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC&amp;"/>

junit测试

package com.tyrion.Dao;

import com.tyrion.pojo.User;
import com.tyrion.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test() {

//        1.通过编写的工具类获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //使用官方建议的try进行包围
        try {
            //2.执行sql 方式一：sqlSession.getMapper()
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            List<User> userList = mapper.getUserList();

            for (User user : userList) {
                System.out.println(user);
            }

            //方式二：
//        List<User> userList=sqlSession.selectList("com.tyrion.Dao.UserDao.getUserList");
//
//        for (User user : userList) {
//            System.out.println(user);
//        }
        } finally {
            //3.关闭SqlSession
            sqlSession.close();
        }


    }
}

3.CRUD（增删改查）

3.1namespace

namespace中的包名要和mapper接口中的一致

3.2 select

选择，查询语句

• id：对应namespace里面的方法名
• resultType：Sql语句执行的返回值
• parameterType：参数类型

1.编写接口

User getUserById(int id);

2.写mapper中的sql语句

    <select id="getUserById" parameterType="int" resultType="com.tyrion.pojo.User">
        select * from mybatis.user where id=#{id}
    </select>

3.测试

@Test
public void getUserById(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();

    UserMapper mapper=sqlSession.getMapper(UserMapper.class);
    User user=mapper.getUserById(1);
    System.out.println(user);

    sqlSession.close();
}

3.3 insert

1.接口

int addUser(User user);

2.sql

    <insert id="addUser" parameterType="com.tyrion.pojo.User">
        insert into mybatis.user(id, name, pwd) values(#{id},#{name},#{pwd})
    </insert>

3.测试

//增删改需要提交事务
@Test
public void addUser(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();

    UserMapper mapper=sqlSession.getMapper(UserMapper.class);

    int result=mapper.addUser(new User(4,"新加用户","123456"));
    if (result>0)
        System.out.println("提交成功");

    //提交事务
    sqlSession.commit();

    sqlSession.close();
}

3.4update

1.接口

//修改用户
int updateUser(User user);

2.sql

    <update id="updateUser" parameterType="com.tyrion.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

3.测试

@Test
    public void updateUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(4,"更新后的用户","123456"));

        sqlSession.commit();

        sqlSession.close();
    }

3.5delete

1.接口

int deleteUser(int id);

2.sql

<delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id}
    </delete>

3.测试

@Test
public void deleteUser(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserMapper mapper=sqlSession.getMapper(UserMapper.class);

    mapper.deleteUser(4);

    sqlSession.commit();
    sqlSession.close();
}

注意点：

增删改需要提交事务

3.6万能的Map（了解）

假设，我们的实体类或者数据库中的字段/参数过多，我们可以考虑使用Map传参（但这种方法不是特别正规）

例如，在进行更新时，我们有数十几个字段，我们只传入两个参数，这时，我们可以map传值

1.接口

//使用map增加用户
    int addUser2(Map<String,Object>map);

2.sql

后面的values参数名称任意起名，但在测试中，map的值要与之对应

<!--    传递map的key值-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user(id, name, pwd) values(#{userId},#{userName},#{userPwd})
    </insert>

3.测试

//使用map传参
@Test
public void addUser2(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();

    UserMapper mapper=sqlSession.getMapper(UserMapper.class);

    Map<String,Object> map=new HashMap<String, Object>();

    map.put("userId",5);
    map.put("userName","map用户");
    map.put("userPwd","123456");

    mapper.addUser2(map);

    //提交事务
    sqlSession.commit();
    sqlSession.close();
}

Map传递参数，直接在sql中取出key即可

对象传递参数，直接在sql中取出对象的属性即可

只有一个基本类型的参数情况下，可以直接在sql中取到（在xml中可以省略写parameterType）

多个参数用map或者注解

3.7 模糊查询

1.Java代码查询的层面，传递通配符%%

sql

    <select id="getUserLike" resultType="com.tyrion.pojo.User">
        select * from mybatis.user where name like #{value}
</select>

测试

@Test
    public void getUserLike(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();

        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        List<User> userList=mapper.getUserLike("%李%");

        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

2.在sql拼接中使用通配符

    <select id="getUserLike" resultType="com.tyrion.pojo.User">
        select * from mybatis.user where name like "%"#{value}"%"
</select>

4.配置解析

4.1核心配置文件

• mybatis-config.xml
• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

configuration（配置）
	properties（属性）
	settings（设置）
	typeAliases（类型别名）
	typeHandlers（类型处理器）
	objectFactory（对象工厂）
	plugins（插件）
	environments（环境配置）
		environment（环境变量）
			transactionManager（事务管理器）
			dataSource（数据源）
	databaseIdProvider（数据库厂商标识）
	mappers（映射器）

4.2环境配置（environments）

MyBatis 可以配置成适应多种环境

尽管可以配置多个环境，但每个 SqlSessionFactory实例只能选择一种环境。

学会使用配置多套运行环境

mybatis默认的事务管理器就是JDBC，连接池：POOLED

4.3属性（properties）

可以通过属性来实现引用配置文件

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件【db.properties】中配置这些属性，也可以在 properties 元素的子元素中设置

编写一个配置文件

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode-true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=123456

在核心文件中进行引入

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

<!--    引入外部配置文件-->
    <properties resource="db.properties"/>

    <environments default="development">
        <environment id="development">
            <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>

<!--    每一个Mappers.xml都需要在Mybatis核心文件中注册-->
    <mappers>
        <mapper resource="com/tyrion/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

也可以在内部的properties中增加一些属性配置，例如：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

• 首先读取在 properties 元素体内指定的属性。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

4.4类型别名（typeAliases）

类型别名是为Java类型设置一个短的名字

意义在降低冗余的全限定类名书写

方法一：typeAlias

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

<!--    引入外部配置文件-->
    <properties resource="db.properties"/>

<!--    可以给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.tyrion.pojo.User" alias="User"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <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>

<!--    每一个Mappers.xml都需要在Mybatis核心文件中注册-->
    <mappers>
        <mapper resource="com/tyrion/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

方法二：package

在没有注解的情况下，会使用Bean 的首字母小写的非限定类名来作为它的别名。 比如 com.tyrion.pojo.User 的别名为user。

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

<!--    引入外部配置文件-->
    <properties resource="db.properties"/>

<!--    可以给实体类起别名-->
    <typeAliases>
        <package name="com.tyrion.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <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>

<!--    每一个Mappers.xml都需要在Mybatis核心文件中注册-->
    <mappers>
        <mapper resource="com/tyrion/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

若有注解，则别名为其注解值。

@Alias("author")
public class Author {
    ...
}

4.5设置

常用的设置：

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true|false	True
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true|false	False
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true|false	False
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J /LOG4J / LOG4J2 / JDK_LOGGING / COMMONS_LOGGING / STDOUT_LOGGING / NO_LOGGING	未设置

4.6映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件，以下是几种常用的注册方法

方式一：使用相对于类路径的资源引用 【推荐】

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

方式二：使用映射器接口实现类的完全限定类名

    <mappers>
        <mapper class="com.tyrion.dao.UserMapper"/>
    </mappers>

方法三：将包内的映射器接口实现全部注册为映射器

    <mappers>
        <package name="com.tyrion.dao"/>
    </mappers>

方法二和三注意点：

• 接口和Mapper文件必须同名！
• 接口和配置文件必须在同一个包下！

4.7其他配置

• typeHandler
• objectFactory
• plugins
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

4.8生命周期和作用域

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

• 一旦创建了 SqlSessionFactory，就不再需要它了。
• 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

SqlSessionFactory

• 可以理解为数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• 因此SqlSessionFactory 的最佳作用域是应用作用域（最简单的就是使用单例模式或者静态单例模式）

SqlSession

• 可以理解为连接到连接池的一个请求
• SqlSession的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 请求之后需要关闭，否则资源被占用

5. 解决属性名和字段名不一致的问题

数据库中的字段：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yAkR4K6Q-1597736758573)(C:\Users\Tyrion\AppData\Roaming\Typora\typora-user-images\image-20200815155941069.png)]

5.1问题产生

新建项目，测试实体类和数据库中的字段不一致的情况

package com.tyrion.pojo;

public class User {
    private int id;
    private String name;
    private String password;

    public User() {
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int 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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

使用getUserById查询的结果：

User{id=1, name='张三', password='null'}

解决方法：

1.起别名

<select id="getUserById" parameterType="int" resultType="com.tyrion.pojo.User">
        select id,name,pwd as password from mybatis.user where id=#{id}
</select>

5.2 resultMap

结果集映射

数据库	id	name	pwd
实体类	id	name	password

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

<mapper namespace="com.tyrion.dao.UserMapper">

<!--    结果集映射-->
    <resultMap id="UserMap" type="user">
<!--        column是数据库中的字段，property是实体类的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>

    <select id="getUserById" resultMap="UserMap">
        select * from mybatis.user where id=#{id}
    </select>


</mapper>

PS:id和name可以省略，因为实体类中和数据库中的名字一样，写出来只是为了格式规范

• resultMap 元素是 MyBatis 中最重要最强大的元素
• ResultMap的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了

6.日志

6.1日志工厂

如果一个数据库操作出现异常，我们需要排错，日志是最好的助手

曾经：debug sout

现在：日志工厂

• SLF4J
• LOG4J【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING【掌握】
• NO_LOGGING

在Mybatis中，具体使用在设置中设定

STDOUT_LOGGING标准日志输出

在核心配置文件中进行配置：

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

<!--    引入外部配置文件-->
    <properties resource="db.properties"/>

    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <typeAliases>
        <package name="com.tyrion.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <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>

<!--    每一个Mappers.xml都需要在Mybatis核心文件中注册-->
    <mappers>
        <mapper resource="com/tyrion/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

输出结果：

Reader entry: ����   1 <
Checking to see if class com.tyrion.pojo.User matches criteria [is assignable to Object]
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
Opening JDBC Connection
Created connection 1958680465.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@74bf1791]
==>  Preparing: select * from mybatis.user where id=?
==> Parameters: 1(Integer)
<==    Columns: id, name, pwd
<==        Row: 1, 张三, 123456
<==      Total: 1
User{id=1, name='张三', password='123456'}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@74bf1791]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@74bf1791]
Returned connection 1958680465 to pool.

Process finished with exit code 0

6.2 Log4j

什么是Log4j

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
• 我们也可以控制每一条日志的输出格式
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
• 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1.先导入log4j的包

        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

2.log4j.properties文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3.核心文件中配置log4j的实现

    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

4.Log4j的使用（使用和之前相同的测试）

"C:\Program Files (x86)\Java\jdk-14.0.1\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 -Didea.launcher.port=50473 "-Didea.launcher.bin.path=D:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\bin" -Dfile.encoding=UTF-8 -classpath "D:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\lib\idea_rt.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\plugins\junit\lib\junit-rt.jar;D:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\plugins\junit\lib\junit5-rt.jar;F:\workspace\Mybatis-study\mybatis-04\target\test-classes;F:\workspace\Mybatis-study\mybatis-04\target\classes;C:\Users\Tyrion\.m2\repository\log4j\log4j\1.2.12\log4j-1.2.12.jar;C:\Users\Tyrion\.m2\repository\mysql\mysql-connector-java\8.0.21\mysql-connector-java-8.0.21.jar;C:\Users\Tyrion\.m2\repository\com\google\protobuf\protobuf-java\3.11.4\protobuf-java-3.11.4.jar;C:\Users\Tyrion\.m2\repository\org\mybatis\mybatis\3.5.5\mybatis-3.5.5.jar;C:\Users\Tyrion\.m2\repository\junit\junit\4.13\junit-4.13.jar;C:\Users\Tyrion\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar" com.intellij.rt.execution.application.AppMainV2 com.intellij.rt.execution.junit.JUnitStarter -ideVersion5 -junit4 com.tyrion.dao.UserMapperTest,test
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.io.VFS]-Class not found: org.jboss.vfs.VFS
[org.apache.ibatis.io.JBoss6VFS]-JBoss 6 VFS API is not available in this environment.
[org.apache.ibatis.io.VFS]-Class not found: org.jboss.vfs.VirtualFile
[org.apache.ibatis.io.VFS]-VFS implementation org.apache.ibatis.io.JBoss6VFS is not valid in this environment.
[org.apache.ibatis.io.VFS]-Using VFS adapter org.apache.ibatis.io.DefaultVFS
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/F:/workspace/Mybatis-study/mybatis-04/target/classes/com/tyrion/pojo
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/F:/workspace/Mybatis-study/mybatis-04/target/classes/com/tyrion/pojo
[org.apache.ibatis.io.DefaultVFS]-Reader entry: User.class
[org.apache.ibatis.io.DefaultVFS]-Listing file:/F:/workspace/Mybatis-study/mybatis-04/target/classes/com/tyrion/pojo
[org.apache.ibatis.io.DefaultVFS]-Find JAR URL: file:/F:/workspace/Mybatis-study/mybatis-04/target/classes/com/tyrion/pojo/User.class
[org.apache.ibatis.io.DefaultVFS]-Not a JAR: file:/F:/workspace/Mybatis-study/mybatis-04/target/classes/com/tyrion/pojo/User.class
[org.apache.ibatis.io.DefaultVFS]-Reader entry: ����   1 <
[org.apache.ibatis.io.ResolverUtil]-Checking to see if class com.tyrion.pojo.User matches criteria [is assignable to Object]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1025001676.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3d1848cc]
[com.tyrion.dao.UserMapper.getUserById]-==>  Preparing: select * from mybatis.user where id=?
[com.tyrion.dao.UserMapper.getUserById]-==> Parameters: 1(Integer)
[com.tyrion.dao.UserMapper.getUserById]-<==      Total: 1
User{id=1, name='张三', password='123456'}
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3d1848cc]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3d1848cc]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 1025001676 to pool.

Process finished with exit code 0

简单使用

1.在使用Log4j的类中导入包

import org.apache.log4j.Logger;

2.日志对象，参数为当前类的class

static Logger logger=Logger.getLogger(UserMapperTest.class);

3.日志级别

logger.info("info:进入了testlog4j");
logger.debug("debug:进入了testlog4j");
logger.error("error:进入了testlog4j");

7. 分页

为什么要分页：

减少数据的处理量

7.1 使用limit分页

语法：SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 3; #查询符合条件的前三个

使用Mybatis实现分页，核心SQL

1.接口

 //分页
    List<User> getUserByLimit(Map<String,Integer> map);

2.Mapper.xml

<!--    分页-->
    <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from mybatis.user limit #{startIndex},#{pageSize}
    </select>

3.测试

    @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList = mapper.getUserByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7.2 RowBounds分页

不再使用SQL实现

1.接口

//分页2
List<User> getUserByRowBounds();

2.Mapper.xml

<!--    分页2-->
<select id="getUserByRowBounds" resultMap="UserMap">
    select * from mybatis.user
</select>

3.测试

@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //RowBounds实现
    RowBounds rowBounds = new RowBounds(1, 2);

    //通过java代码实现分页
    List<User> userList=sqlSession.selectList("com.tyrion.dao.UserMapper.getUserByRowBounds",null,rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.3 分页插件

Mybatis分页插件：PageHelper

8. 使用注解开发

8.1面向接口编程

• 在真正的开发中，很多时候我们会选择面向接口编程
• 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好
• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同的对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了
• 而各个对象之间的协作关系则成为系统设计的关键，小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。

关于接口的理解

• 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离
• 接口的本身反映了系统设计人员对系统的抽象理解
• 接口应有两类：
  • 第一类是对一个个体的抽象，可对应为一个抽象体（abstract class）
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
• 一个个体可能有多个抽象面，抽象体和抽象面是有区别的

三个面向的区别

• 面向对象：考虑问题时，以对象为单位，考虑它的属性和方法
• 面向过程：考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
• 面向设计与非接口是针对复用技术而言的，与面向对象不是一个问题，更多的体现的是对系统整体的架构

8.2使用注解开发

1.注解在接口上实现

public interface UserMapper {

    @Select("select * from user")
    List<User> getUsers();
}

2.需要在核心配置文件中绑定接口

<!--    绑定接口-->
    <mappers>
        <mapper class="com.tyrion.dao.UserMapper"/>
    </mappers>

3.测试

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //底层主要用反射实现
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.getUsers();
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

本质：反射机制实现

底层：动态代理

Mybatis详细的执行流程

https://www.bilibili.com/video/BV1NE411Q7Nx?p=16

8.2使用注解完成CRUD

我们可以在工具类创建的时候实现自动提交事务

public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }

1.select：

@Select("select * from user where id=#{id}")
    User getUserById(@Param("id") int id);

测试

@Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //底层主要用反射实现
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }

2.Insert

@Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
int addUser(User user);

测试

@Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.addUser((new User(10,"注解增加用户","123123")));

        sqlSession.close();
    }

3.update

@Update("update user set name=#{name},pwd=#{password} where id=#{id}")
int updateUser(User user);

测试

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(10,"注解修改用户","123345"));

    sqlSession.close();
}

4.delete

@Delete("delete from user where id =#{id}")
int deleteUser(@Param("id") int id);

测试

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(10);

    sqlSession.close();
}

关于@Param()注解

• 基本类型的参数或者String类型的参数，都需要加上
• 引用类型的参数不需要加
• 如果只有一个基本类型，可以忽略，但建议都加
• 在SQL中，引用的就是这里在Param中设定的属性名

#{} ￥{}的区别

**#{}：**预编译处理，JDBC预编译（prepared statement）语句的参数标记符,先被解析为？参数占位符，之后再通过预编译的set进行赋值。解析之后会将String类型的数据自动加上引号，其他数据类型不会。流程：数据库驱动在发送 sql 语句和参数给 DBMS 之前对 sql 语句进行编译，这样 DBMS 执行 sql 时，就不需要重新编译。

${}: 字符串替换,纯粹的string替换，在动态SQL解析阶段将会进行变量替换，直接替换成变量的值。解析之后是什么就是什么。发生在动态解析过程。

预防SQL注入：sql注入就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令，在编写sql时永远不要信任用户的输入，必须认定用户的输入是不安全的，提前在sql中进行数据预防处理，#{}就是其中的一种方式，PreparedStatement不允许在插入参数时改变SQL语句的逻辑结构，其次是SQL语句在程序运行前进行了预编译，在操作数据库之前sql语句已经被数据库分析，编译和优化对应的执行方式也会被缓存下来而后对数据库进行查询，之后说即使有敏感字符的参数也不会作为一个SQL指令来执行了，简短的说就是SQL注入发生在编译的过程，预编译提前对SQL语句进行预编译，而其后注入的参数将不会进行SQL编译。

SELECT * FROM user WHERE password=${password}
输入密码 123or1=1

${}传递的数据当成sql语句中的一部分
最后的语句解析为SELECT *FROM user WHERE password=123 or 1=1
相当于SELECT *FROM user，后果可想而知


#{}
#{}传递的数据都会被当成一个字符串，自动的加上一个双引号
最后的语句解析为SELECT *FROM user WHERE “password=123 or 1=1”
避免了恶意行为的产生


特殊情况：order by #{type}/${type}
#{type}解析为order by "type"，显然是有问题的
${type}解析为order by type正确语句

9.Lombok

一个较为常用的插件，使用后，只需要写一些注解，就可以免去写很多代码，注解会帮助实现

使用：

1.在idea的plugin中下载Lombok插件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aeQmV4z5-1597736758577)(C:\Users\Tyrion\AppData\Roaming\Typora\typora-user-images\image-20200818150444055.png)]

PS：若遇到Idea的plugins打不开的问题，可以在下面两处进行修改：

​ 1.Auto-detect proxy settings修改地址：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jFVUJdld-1597736758579)(C:\Users\Tyrion\AppData\Roaming\Typora\typora-user-images\image-20200818150654510.png)]

​ 2.取消勾选 Use secure connection

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MNRiI76r-1597736758583)(C:\Users\Tyrion\AppData\Roaming\Typora\typora-user-images\image-20200818150708844.png)]

2.在项目中导入lombok的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

3.在实体类上加注解即可

@Data：无参构造，get，set，toString，hashCode，equals，
@AllArgsConstructor：有参构造
@NoArgsConstructor：无参构造
@ToString：toString方法
@EqualsAndHashCode：equals和hashCode方法
@Getter and @Setter：生成get和set方法，根据所在位置，生成单个属性或所有属性

优缺点

优点：

1.通过注解的形式自动生成方法，提高开发效率

2.让代码变得简洁，不用过多关注相应方法

3.属性做修改时，简化了维护相应方法

缺点：

1.不支持多重参数器构造的重载

2.省去了手动创建方法的麻烦，但大大降低了源码的可读性和完整性

析之后是什么就是什么。发生在动态解析过程。

预防SQL注入：sql注入就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令，在编写sql时永远不要信任用户的输入，必须认定用户的输入是不安全的，提前在sql中进行数据预防处理，#{}就是其中的一种方式，PreparedStatement不允许在插入参数时改变SQL语句的逻辑结构，其次是SQL语句在程序运行前进行了预编译，在操作数据库之前sql语句已经被数据库分析，编译和优化对应的执行方式也会被缓存下来而后对数据库进行查询，之后说即使有敏感字符的参数也不会作为一个SQL指令来执行了，简短的说就是SQL注入发生在编译的过程，预编译提前对SQL语句进行预编译，而其后注入的参数将不会进行SQL编译。

SELECT * FROM user WHERE password=${password}
输入密码 123or1=1

${}传递的数据当成sql语句中的一部分
最后的语句解析为SELECT *FROM user WHERE password=123 or 1=1
相当于SELECT *FROM user，后果可想而知


#{}
#{}传递的数据都会被当成一个字符串，自动的加上一个双引号
最后的语句解析为SELECT *FROM user WHERE “password=123 or 1=1”
避免了恶意行为的产生


特殊情况：order by #{type}/${type}
#{type}解析为order by "type"，显然是有问题的
${type}解析为order by type正确语句

9.Lombok

一个较为常用的插件，使用后，只需要写一些注解，就可以免去写很多代码，注解会帮助实现

使用

1.在idea的plugin中下载Lombok插件

[外链图片转存中…(img-aeQmV4z5-1597736758577)]

PS：若遇到Idea的plugins打不开的问题，可以在下面两处进行修改：

​ 1.Auto-detect proxy settings修改地址：

[外链图片转存中…(img-jFVUJdld-1597736758579)]

​ 2.取消勾选 Use secure connection

[外链图片转存中…(img-MNRiI76r-1597736758583)]

2.在项目中导入lombok的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

3.在实体类上加注解即可

@Data：无参构造，get，set，toString，hashCode，equals，
@AllArgsConstructor：有参构造
@NoArgsConstructor：无参构造
@ToString：toString方法
@EqualsAndHashCode：equals和hashCode方法
@Getter and @Setter：生成get和set方法，根据所在位置，生成单个属性或所有属性

优缺点

优点：

1.通过注解的形式自动生成方法，提高开发效率

2.让代码变得简洁，不用过多关注相应方法

3.属性做修改时，简化了维护相应方法

缺点：

1.不支持多重参数器构造的重载

2.省去了手动创建方法的麻烦，但大大降低了源码的可读性和完整性