MyBatis框架

小胡学Java

于 2021-08-10 13:41:23 发布

阅读量169

点赞数

本文链接：https://blog.csdn.net/m0_56412042/article/details/119568009

版权

MyBatis-9.28

环境：

JDK1.8
MySQL5.7
maven 3.8.1
IDEA

回顾：

JDBC
MySQL
Java基础
Maven
Junit

框架：配置文件。最好的方式：看官网文档

mybatis – MyBatis 3 | 简介

1.简介

1.1什么是mybatis

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FIKFSri9-1628574055963)(C:\Users\ASUS\Desktop\mybatis-logo.png)]

MyBatis 是一款优秀的持久层框架，
它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
MyBatis 本是apache的一个开源项目iBatis,
2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，
并且改名为MyBatis 。2013年11月迁移到Github。

获取：

maven仓库：

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

Github：Release mybatis-3.5.2 · mybatis/mybatis-3 (github.com)
中文文档：mybatis – MyBatis 3 | 简介

1.2持久化

数据持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（JDBC），IO文件持久化
生活：冷藏罐头

为什么需要持久化？

有一些对象，不能丢弃
内存太贵了

1.3持久层

Dao层，Service层，Controller层

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

1.4为什么需要Mybatis？

方便
传统的JDBC代码太复杂。简化框架自动化
帮助程序员将数据存入到数据库中
不用Mybatis也可以。更容易上手。技术没有高低之分
优点
- 简单易学
- 灵活
- sql和代码分离，提高了可维护性
- 提供映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql

最重要的一点：使用的人多

2.第一个Mybatis程序

2.1搭建环境

思路：搭建环境—>导入Mybatis–>编写代码—>测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTF7Idik-1628574055965)(MyBatis-9.28.assets/image-20210620172316172.png)]

数据库搭建

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')

新建项目

1.创建一个普通的maven项目

2.删除src目录

3.导入maven依赖

<!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
<!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
<!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

2.2创建一个子模块

编写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>
    <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?userSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

编写mybatis工具类

//SqlSessionFactory --->sqlSession
public class MybatisUtils {
    private  static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用mybatis的第一步
            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编写代码

实体类

package com.hu.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 + '\'' +
                '}';
    }
}

Dao接口

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

接口实现类由原来的UserDaoIpml转变为一个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">
<!--namespace:绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.hu.dao.UserDao">
    <select id="getUserList" resultType="com.hu.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

2.4测试

报错：

org.apache.ibatis.binding.BindingException: Type interface com.hu.dao.UserDao is not known to the MapperRegistry.

原因：没有配置相映的Mapper

解决方法：

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

报错：

java.lang.ExceptionInInitializerError
### Error building SqlSession.
### The error may exist in com/hu/dao/UserMapper.xml

原因:文件没有在target文件夹下生成（约定大于配置）

解决方法

<!--  在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>

MapperRegistry是什么？

核心配置文件中注册 mappers

junit测试

   public void Test(){

        //获取session对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //方式一
        //执行sql
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user.toString());
        }
        //关闭sqlsession
        sqlSession.close();
    }

命名空间的作用：

一个是利用更长的全限定名来将不同的语句隔离开来，同时也实现了你上面见到的接口绑定。就算你觉得暂时用不到接口绑定，你也应该遵循这里的规定，以防哪天你改变了主意。

只要将命名空间置于合适的 Java 包命名空间之中，你的代码会变得更加整洁，也有利于你更方便地使用 MyBatis。

3.编写CRUD

1.namespace

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

2.select

选择，查询语句；

id：就是对应的namespace中的方法名
resultType：Sql语句执行的返回值
parameterType：参数类型

1.编写接口

 //查询全部用户
    List<User>  getUserList();

2.编写对应的Mapper中的sql语句

<select id="getUserList" resultType="com.hu.pojo.User">
    select * from mybatis.user
</select>

3.测试

public void Test(){
    //获取session对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    //方式一
    //执行sql
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.getUserList();
    for (User user : userList) {
        System.out.println(user.toString());
    }
    //关闭sqlsession
    sqlSession.close();
}

3.insert

//添加用户
int addUser(User user);

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

public void test1(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

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

    User user = new User(4,"安慕希","123456");

    int i = userMapper.addUser(user);

    if (i>0){
        System.out.println("插入成功");
    }
    sqlSession.commit();
    sqlSession.close();
}

4.update

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

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

public void updateUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

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

    userMapper.updateUser(new User(4,"安慕希","000000"));

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

}

5.delete

//删除用户
int deleteUser(int id);

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

public void deleteUser(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

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

    int i = userMapper.deleteUser(3);

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

注意点：增删改需要提交事务

6.错误分析

1.标签不要匹配错误

2.resource绑定mapper，需要使用路径

3.程序配置文件必须符合规范

7.万能的Map

假设我们的实体类，或者数据库中的表，字段，或者参数过多，我们就应当考虑使用Map

优点：所插入的值可以被设定

缺点：不容易维护

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

<insert id="addUser2" parameterType="com.hu.pojo.User">
    insert into mybatis.user(id,`name`) value (#{userid},#{username})
</insert>

@Test
public void addUser2(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("userid",3);
    map.put("username","小胡健");
    mapper.addUser2(map);
    sqlSession.commit();
    sqlSession.close();
}

Map传递参数，直接在sql中取出即可！ parameterType=“map”

对象传递参数，直接在sql中取出对象的属性即可！parameterType=“Object”

只有一个基本类型参数的情况下，可以直接在sql中取到！

多个参数用Map 或者注解！

8.思考题

模糊查询

1.Java代码执行的时候，传递通配符%%

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

4.配置解析

1.核心配置文件

mybatis-config.xml

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d589WU6p-1628574055967)(MyBatis-9.28.assets/image-20210620180429590.png)]

2.环境配置（environments）

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

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uJvWhy1Q-1628574055969)(MyBatis-9.28.assets/image-20210621091916386.png)]

default默认环境。我们在配置多个环境时，配一个sqlSessionFactory实例只能选择一个。所以在我们使用了多个环境的时候，我们要注意给Builder传递的参数。Builder有多个重载方法。

注意一些关键点:

默认使用的环境 ID（比如：default=“development”）。
每个 environment 元素定义的环境 ID（比如：id=“development”）。
事务管理器的配置（比如：type=“JDBC”）。
数据源的配置（比如：type=“POOLED”）。

事务管理器（transactionManager）（了解：知道有JDBC和MANAGED就行）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。

数据源（dataSource） 连接数据库： dbcp c3p0 druid

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

大多数 MyBatis 应用程序会按示例中的例子来配置数据源。虽然数据源配置是可选的，但如果要启用延迟加载特性，就必须配置数据源。

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：

学会配置多套运行环境

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

3.属性（properties）

我们可以通过preperties属性来实现应用配置文件

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Epac09y4-1628574055970)(MyBatis-9.28.assets/image-20210621094241773.png)]

编写一个配置文件

db.properties

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

在核心配置文件中引入

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

</properties>

可以直接引入外部文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件的！！！

4.类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。
它仅用于 XML 配置，意在降低冗余的全限定类名书写

<!--实体类别名-->
<typeAliases>
    <typeAlias type="com.hu.pojo.User" alias="user"/>
</typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean
在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。

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

实体类少使用第一种，多使用第二种

第一种可以diy。但是第二种不行（非要改的话可以在实体类中增加注解）

5.设置

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。下表描述了设置中各项设置的含义、默认值等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eeNGBDXa-1628574055971)(MyBatis-9.28.assets/image-20210621101842226.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m22wLAAm-1628574055971)(MyBatis-9.28.assets/image-20210621101855508.png)]

6.其他配置

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
- MyBatis Generator Core
- MyBatis Plus
- 通用Mapper

了解即可。

7.映射器（mappers）

MapperRegistry：注册绑定我们所需要的Mapper文件

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

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册!!!!!!-->
    <mappers>
        <mapper resource="com/hu/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

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

注意点：

接口和他的Mapper配置文件必须同名
接口可他的Mapper配置文件在同一个包下

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

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

注意点：

接口和他的Mapper配置文件必须同名
接口可他的Mapper配置文件在同一个包下

8.作用域（Scope）和生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0dQxRGWe-1628574055972)(MyBatis-9.28.assets/image-20210621110255402.png)]

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

SqlSessionFactoryBuilder

一旦创建了SqlSessionFactory，就不再需要它了
局部变量

SqlSessionFactory：

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

SqlSession

连接刀连接池的一个请求！
用完就释放关闭
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t916a5HK-1628574055972)(MyBatis-9.28.assets/image-20210622085641374.png)]

这里的每一个Mapper代表一个具体的业务！

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

1.问题

数据库中的字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yu2hb3f8-1628574055973)(MyBatis-9.28.assets/image-20210622085803704.png)]

新建一个项目，拷贝之前，测试实体类字段不一致的情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPdWLz5o-1628574055973)(MyBatis-9.28.assets/image-20210622090934272.png)]

// select * from mybatis.user where id=#{id}
//类型处理器
// select id,name,pwd from mybatis.user where id=#{id}

解决方法：

起别名

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

2.resultMap

结果集映射

column(数据库中的字段):  id name pwd
property(实体类的属性):  id name password

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

可以仅仅添加其中不一致的字段和实体类属性

resultMap 元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。

6.日志

6.1日志工厂

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

之前：sout 。debug

现在：日志工厂！！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QULuxjrU-1628574055974)(MyBatis-9.28.assets/image-20210622101102446.png)]

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

在Mybatis中具体使用哪一个日志实现，在设置中心设置

STDOUT_LOGGING标准日志输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kj1bnuRF-1628574055974)(MyBatis-9.28.assets/image-20210622102051273.png)]

6.2 LOG4J

什么是log4j？

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

1.导包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

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

简单使用

1.在要使用Log4j的类中，导入

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

2.通过logger的方法就可以打印出消息相当于sout的作用

7.分页

思考：为什么要分页？

减少数据的处理量

使用Limit分页

select * from user limit startIndex,pageSize
SELECT * from user limit 3 ;#[0,n)

使用Mybatis实现分页，核心SQL

1.接口

//分页查询
List<User> limit(Map<String,Object> map);

2.Mapper.xml

<select id="limit" parameterType="map" resultMap="UserMap">
    select * from user limit #{start},#{pagesize}
</select>

3.测试

@Test
public void testLimit(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map<String, Object> map = new HashMap<String,Object>();
    map.put("start",0);
    map.put("pagesize",2);
    List<User> userList = mapper.limit(map);
    for (User user : userList) {
        logger.info(user);
    }
    sqlSession.close();
}

8.使用注解开发

8.1面向接口编程

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

关于接口的理解：
接口从更深层次的理解，应是定义与实现的分离。

接口的本身反映了系统设计人员对系统的抽象理解接口有两类：

第一类是对一个个体的抽象，它可对应为一个抽象体 (abstract class)
第二类是对一个个体某方面的抽象，即形成一个抽象面 (interface)

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

8.2使用直接开发

1.注解在接口上实现

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

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

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

3.测试

本质：反射机制实现

底层：动态代理

Mybatis详细执行流程！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dXIAtH6q-1628574055975)(MyBatis-9.28.assets/1.jpg)]

8.3CRUD

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

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

编写接口

public interface UserMapper {

@Select("select id,name,pwd as password from user")
List<User> getUsers();

@Select("select id,name,pwd as password from user where id=#{id}")
User getUserById(@Param("id")int id);

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

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

@Update("update from user ")
int modify(User user);
}

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

测试类

**注意：**记住每创建一个实体类编写接口后要去xml中进行Mapper的配置

关于@Param（）注解

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

9.Lombok使用

Lombok是一个Java库，能自动插入编辑器并构建工具，简化Java开发。通过添加注解的方式，不需要为类编写getter或eques方法，同时可以自动化日志变量。

使用步骤：

在IDEA中安装Lombok插件

在项目中添加Lombok的jar包

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.10</version>
	<scope>provided</scope>
</dependency>

@Getter and @Setter 
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data  
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows



```JAVA
@Data：无参构造，get，set，tostring，hashcode，equals
@AllArgsConstructor   有参构造
@NoArgsConstructor    无参构造

10.多对一处理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i6I27L1e-1628574055976)(MyBatis-9.28.assets/image-20210623154106713.png)]

多个学生，对应一个老师
对于学生这边而言，关联…多个学生，关联一个老师【多对一】
对于老师而言，集合，一个老师有很多学生【一对多】

SQL

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

测试环境搭建

1.导入lombok

2.新建实体类

3.建立Mapper接口

4.建立Mapper.xml文件

5.在核心配置文件中注册Mapper接口或者Mapper.xml文件

6.测试检查

按照查询嵌套处理

<!--
思路：
1.查询所有学生信息
2.根据查询出来的学生的tid   寻找相应的老师！！！   子查询
-->

<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
<!--复杂的属性，我们需要单独处理
对象:association
集合：collection
-->
</resultMap>
<select id="getStudent" resultMap="StudentTeacher">
    select * from student;
</select>

<select id="getTeacher" resultType="Teacher">
    select * from teacher;
</select>

按照结果嵌套处理

<!--方法一:按照结果进行嵌套处理-->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname from teacher t ,student s
        where s.tid=t.id
    </select>
<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" column="tname">
        <result property="name" column="tname"/>
    </association>
</resultMap>

回顾MySQL 多对一查询方式：

子查询（按照查询结果嵌套）
联表查询（按照结果嵌套）

11.一多对处理

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系

搭建环境

实体类

@Data
public class Teacher {
    private int id;
    private String name;
    //一个老师需要包含多个学生
    private List<Student> student;
}

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

按照结果嵌套处理

<!--方法一：按照结果嵌套查询-->
    <select id="getTeacher" resultMap="Teacher1">
        select t.id tid,t.name tname,s.id sid,s.name
        sname from teacher t ,student s
        where t.id=s.tid and t.id=#{tid}
    </select>
    <resultMap id="Teacher1" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="student" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

按照查询嵌套处理

<select id="getTeacher2" resultMap="Teacher2">
select * from teacher t2 where id=#{id}
</select>
<select id="getStudent" resultType="Student">
    select * from student where tid=#{id}
</select>
<resultMap id="Teacher2" type="Teacher">
    <result property="id" column="id"/>
    <collection property="student" column="id"  javaType="ArrayList" ofType="Student" select="getStudent"/>
</resultMap>

小结：

关联 association 【多对一】
集合 collection 【一对多】
JavaType & ofType
1. JavaType用来指定实体类中属性的类型
2. ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束

注意点：

保证SQL的可读性，尽量保证通俗易懂
注意一对多和多对一中，属性名和字段的问题
如果问题不好排查错误，可以使用日志，建议使用Log4J

面试高频：

mysql引擎
InnoDB底层原理
索引
索引优化

12.动态SQL

什么是动态SQL：根据不同的条件生成不同的SQL语句

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

if
choose (when, otherwise)
trim (where, set)
foreach

搭建环境

CREATE TABLE `blog`(
`id` VARCHAR(50) NOT NULL COMMENT '博客id',
`title` VARCHAR(100) NOT NULL COMMENT '博客标题',
`author` VARCHAR(30) NOT NULL COMMENT '博客作者',
`create_time` DATETIME NOT NULL COMMENT '创建时间',
`views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

导包
编写配置文件

编写实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Blog {
    private int id;
    private String title;
    private String author;
    private Date create_time;
    private int views;
}

编写实体类对应Mapper接口和Mapper.xml配置文件

IF

<select id="queryBlogIf" parameterType="map" resultType="com.hu.pojo.Blog">
    select * from blog where 1=1
    <if test="title != null">
        and title=#{title}
    </if>
    <if test="author != null">
        and author=#{author}
    </if>
</select>

choose、when、otherwise

<select id="queryBlogChoose" parameterType="map" resultType="com.hu.pojo.Blog">
    select * from blog
    <where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <otherwise>
                and views = 9999
            </otherwise>
        </choose>
    </where>
</select>

相当于switch…case 只会进入其中一个结果。没有传参则走默认值otherwise

trim (where, set)

where

<select id="queryBlogIf" parameterType="map" resultType="com.hu.pojo.Blog">
    select * from blog 
    <where>
    <if test="title != null">
         title like #{title}
    </if>
    <if test="author != null">
        and author  like #{author}
    </if>
    </where>
</select>

解决查询时字符串拼接问题

set

<update id="UpdateBlog" parameterType="map">
    update blog
    <set>
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            author = #{author}
        </if>
    </set>
    where id = #{id}
</update>

所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面去执行一个逻辑代码！！！

SQL片段

将一些重复使用的SQL代码提取出来。相当于java中的工具类

使用SQL标签抽取公共部分

<sql id="if-title-author">
    <if test="title != null">
        and title like #{title}
    </if>
    <if test="author != null">
        and author  like #{author}
    </if>
</sql>

在需要使用的地方使用include标签引用即可

<select id="queryBlogIf" parameterType="map" resultType="com.hu.pojo.Blog">
    select * from blog where true
   <include refid="if-title-author"></include>
</select>
<!--sql标签做个id标记
使用的时候使用<include>标签进行取出来使用
-->
<sql id="if-title-author">
    <if test="title != null">
        and title like #{title}
    </if>
    <if test="author != null">
        and author  like #{author}
    </if>
</sql>

注意事项：

最好基于单表来定义SQL片段！！
不要存在where标签

foreach

官方文档例子

<select id="方法名" resultType="返回值类型">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="进行迭代的值" index="index" collection="集合名称"
      open="起始值" separator="连接符" close="末尾值">
        #{item}
  </foreach>
</select>

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！

提示：

你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给 foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者 Map.Entry 对象的集合）时，index 是键，item 是值。

<select id="queryByForeach" parameterType="map" resultType="com.hu.pojo.Blog">
    select * from blog
    <where>
        <foreach collection="ids" item="id" open="(" close=")" separator="or">
            id = #{id}
        </foreach>
    </where>
</select>

测试：

@Test
public void queryByForeach(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Map map = new HashMap();
    List ids = new ArrayList();
    ids.add(1);
    map.put("ids",ids);
    mapper.queryByForeach(map);
    sqlSession.close();
}

动态SQL本质就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就行了

建议：

先在MySQL中写出标准的sql语句，再到对应的去修改成为我们的动态SQL语句

13.缓存

13.1简介

查询：连接数据库，耗资源！

一次查询的结果，给他暂存在一个可以直接取到的地方！——>内存：缓存

我们再次查询相同的数据的时候，直接走缓存，就不走数据库了。

什么是缓存[Cache]？
- 存在内存中的临时数据
- 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题
为什么要使用缓存？
- 减少和数据库的交互次数，减少系统开销，提高系统效率
什么样的数据能使用缓存？
- 经常查询并且不经常改变的数据

清除策略：

LRU – 最近最少使用：移除最长时间不被使用的对象。
FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

13.2Mybatis缓存

MyBatis 中的缓存就是说 MyBatis 在执行一次SQL查询或者SQL更新之后，这条SQL语句并不会消失，而是被MyBatis 缓存起来，当再次执行相同SQL语句的时候，就会直接从缓存中进行提取，而不是再次执行SQL命令。
Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，已有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
- 二级缓存需要手动开启和配置，他是基于namespace级别的缓存
- 为了提高扩展性，Mybatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

13.3一级缓存

一级缓存：也称为本地缓存
- 用于保存用户在一次会话过程中查询的结果，用户一次会话中只能使用一个sqlSession，
- 一级缓存是自动开启的，不允许关闭。

测试步骤：

配置日志

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GowzBnbp-1628574055976)(MyBatis-9.28.assets/image-20210624194520949.png)]

缓存失效的情况：

查询不同的东西
增删改操作，可能会改变原来的数据，所以必定会刷新缓存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kPQgryH7-1628574055977)(MyBatis-9.28.assets/image-20210624201613779.png)]
查询不同的Mapper.xml
手动清理缓存
```
 sqlSession.clearCache();
```

小结：一级缓存默认是开启的，关闭不了。只在一次SqlSession中有效。也就是拿到连接到关闭这个连接的这段时间有效果

基本上就是这样。这个简单语句的效果如下:

映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

13.4二级缓存

二级缓存：也称为全局缓存。
- 是mapper级别的缓存，是针对一个表的查结果的存储，可以共享给所有针对这张表的查询的用户。
- 也就是说对于mapper级别的缓存不同的sqlsession是可以共享的。
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
- 如果当前会话关闭了，这个会话的一级缓存就没了，但是我们想要的是，会话关闭了，一级缓存中的数据会被保存到二级缓存中
- 新的会话查询信息，就可以从二级缓存中获取内容。
- 不同的Mapper查出的数据会放在自己对应的缓存（map）中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DVHxdyyI-1628574055977)(MyBatis-9.28.assets/image-20210625084752937.png)]

步骤：

1.开启全局缓存

<!--开启全局二级缓存-->
<setting name="cacheEnabled" value="true"/>

2.在Mapper中使用二级缓存

<cache/>

也可以自定义参数

<cache eviction="FIFO"
            flushInterval="60000"
            size="512"
            readOnly="true"/>

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。

3.测试

问题：我们需要将实体类序列化！否则就会报错！
```
Cause: java.io.NotSerializableException: com.hu.pojo.User
```

小结：

只要开启了二级缓存，在同一个Mapper下就有效
所有的数据都会先放在一级缓存中；
只有当会话提交，挥着关闭的时候，才会提交到二级缓存中

13.5缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cC08YRDL-1628574055978)(MyBatis-9.28.assets/image-20210625095744901.png)]

查询顺序：二级——一级——数据库

13.6自定义缓存-ehcache

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

要在程序中使用ehcache，先要导包；

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

手动清理缓存
```
 sqlSession.clearCache();
```

小结：一级缓存默认是开启的，关闭不了。只在一次SqlSession中有效。也就是拿到连接到关闭这个连接的这段时间有效果

基本上就是这样。这个简单语句的效果如下:

映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

13.4二级缓存

二级缓存：也称为全局缓存。
- 是mapper级别的缓存，是针对一个表的查结果的存储，可以共享给所有针对这张表的查询的用户。
- 也就是说对于mapper级别的缓存不同的sqlsession是可以共享的。
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
- 如果当前会话关闭了，这个会话的一级缓存就没了，但是我们想要的是，会话关闭了，一级缓存中的数据会被保存到二级缓存中
- 新的会话查询信息，就可以从二级缓存中获取内容。
- 不同的Mapper查出的数据会放在自己对应的缓存（map）中

[外链图片转存中…(img-DVHxdyyI-1628574055977)]

步骤：

1.开启全局缓存

<!--开启全局二级缓存-->
<setting name="cacheEnabled" value="true"/>

2.在Mapper中使用二级缓存

<cache/>

也可以自定义参数

<cache eviction="FIFO"
            flushInterval="60000"
            size="512"
            readOnly="true"/>

3.测试

问题：我们需要将实体类序列化！否则就会报错！
```
Cause: java.io.NotSerializableException: com.hu.pojo.User
```

小结：

只要开启了二级缓存，在同一个Mapper下就有效
所有的数据都会先放在一级缓存中；
只有当会话提交，挥着关闭的时候，才会提交到二级缓存中

13.5缓存原理

[外链图片转存中…(img-cC08YRDL-1628574055978)]

查询顺序：二级——一级——数据库

13.6自定义缓存-ehcache

EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

要在程序中使用ehcache，先要导包；

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

小胡学Java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis框架

MyBatis-9.28环境：JDK1.8MySQL5.7maven 3.8.1IDEA回顾：JDBCMySQLJava基础MavenJunit框架：配置文件。最好的方式：看官网文档mybatis – MyBatis 3 | 简介1.简介1.1什么是mybatis[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FIKFSri9-1628574055963)(C:\Users\ASUS\Desktop\mybatis-logo.png)]
复制链接

扫一扫