mybatis从头到尾

桥边大爷

已于 2022-11-16 01:20:14 修改

阅读量153

点赞数

分类专栏： mysql相关文章标签： mybatis java mysql

于 2022-08-02 00:04:01 首次发布

本文链接：https://blog.csdn.net/newsun87/article/details/126112593

版权

mysql相关专栏收录该内容

2 篇文章 0 订阅

订阅专栏

引擎？

2第一个mybatis

2.1搭建环境

搭建数据库

CREATE DATABASE mybatis;
USE mybatis;


CREATE TABLE user(
id INT(20) NOT NULL PRIMARY key,
username VARCHAR(20) NOT NULL,
pwd VARCHAR(20) DEFAULT null

)ENGINE=INNODB DEFAULT CHARSET=UTF8;

1.新建一个maven项目

2.删除src文件夹

3.导入maven依赖

   <!--导入依赖-->

<dependencies>
    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.25</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>
    </dependency>
</dependencies>

2.2创建一个模块(根据mybatis开发文档)

a.编写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">
<!--mybatis 核心配置文件-->
<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="987cde@"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

b.编写mybatis核心工具类

//sqlSessionFactory
public class mybatisUtil {
    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 命令所需的所有方法

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

}

2.3编写代码

.实体类

//实体类
public class User {
    private int id;
    private String username;
    private String pwd;

    public User() {
    }

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

    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 getPwd() {
        return pwd;
    }

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

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

.Dao接口

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

.接口实现类,有原来的UserDaoImpl,转变成现在的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="com.kuang.dao.UserDao">
    <select id="getUsers" resultType="com.kuang.pojo.User">
        select * from User;
    </select>
</mapper>

2.4测试

注意点：

Type interface com.kuang.dao.UserDao is not known to the MapperRegistry.

    <!--每一个mapper.xml都需要在mybatis核心配置文件中配置-->
    <mappers>
        <mapper resource="com/kuang/dao/UserDaoMapper.xml"/>
    </mappers>

找不到某个的配置文件，默认配置文件是放在resources文件夹下面的，如果我们没有将某个配饰配置文件放到该文件夹下，这样maven编译的时候则不会编译该文件，在.class文件夹下找不到该文件，这个时候需要在pom文件下配置以下引用，将某个路径下的.xml,.properties文件都进行编译

<!--    在Build中配置resources 来防止除了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>

异常：

Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException: 1 字节的 UTF-8 序列的字节 1 无效。

在读取xml配置文件时，会出现已上报错，解决方式，将当前配置文件中的编码格式utf-8，修改成utf8

<?xml version="1.0" encoding="UTF8" ?>

我们可能遇到的问题

1.配置文件没有注册

2.绑定接口错误

3.方法名不对

4.返回类型不对

5.Maven到处资源问题

3CRUD 增删改查

1.nameSpace

mapper.xml nameSpace命名空间中的名称和接口名一样。

2.select

选择，查询语句

1.id:就是对应的namespace中的方法名

2.resultType：sql语句执行的返回值

3.parameterType:参数类型！

<?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.kuang.dao.UserDao">
    <select id="getUsers" resultType="com.kuang.pojo.User" parameterType="">
        select * from User;
    </select>
</mapper>

 1.select
<select id="selectUserById" resultType="com.kuang.pojo.User" parameterType="int">
        select * from User where id = #{id};
    </select>
2.insert
<insert id="addUser" parameterType="com.kuang.pojo.User">
        insert into mybatis.user (id,username ,pwd) values(#{id},#{username},#{pwd});
    </insert>
3.update
    <update id="updateUser" parameterType="com.kuang.pojo.User">
        update mybatis.user set username=#{username}, pwd=#{pwd} where id =#{id};
    </update>
4.delete
    <delete id="deleteUserById" parameterType="int">
        delete  from mybatis.user where id=#{id};
    </delete>

//增删改代码中需要添加事务，sqlSession.commit();否则不能持久化
 @Test
    public  void insertUser(){
      SqlSession sqlSession =   mybatisUtil.getSqlSession();
      UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
      userMapper.addUser(new User(5,"心中","343"));
      sqlSession.commit();
      sqlSession.close();
    }

注意点：

增删改代码中需要添加事务，sqlSession.commit();否则不能持久化

2.分析错误

1.标签匹配错误：sql和对应的标签不匹配

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

   config.xml

<mappers>
        <mapper resource="com/kuang/dao/UserDaoMapper.xml"/>
    </mappers>

3.配置文件不符合规范

4.NullPonterException,没有注册资源！（没拿到sqlseeion）

5.输出xml文件中存在乱码（没解决）

6.maven资源没能导出，pom文件中正确引用。

3.万能的Map

假设，我们的实体类，或者数据库表，字段或者参数过多时，我们应当，或在说可以使用map！

User getById(Map<String,Object> map);

<select id="getById" resultType="com.kuang.pojo.User" parameterType="map">
    select  * from user where id = #{getId};
</select>

   public  void getUser(){
        SqlSession sqlSession =   mybatisUtil.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map =new HashMap<String,Object>();
        map.put("getId",3);
        User user = userMapper.getById(map);
        System.out.println(user.toString());
    }

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

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

只有一个基本类型的参数，可以直接在sql中取，可以不设parameterType

多个参数用Map,或者注解！

4.模糊查询，注意sql注入

1.在java代码中加入通配符%%

mapper.getUser("%明显%")；

2.在写sql中加入通配符%%

select * from user where name like %#{value}%

4配置解析

1.核心配置

1.mybatis-config.xml

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

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

2.环境配置（environments）

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

在配置文件中，environment 标签配置一套环境，default对应的id连接对应的环境。

<environments default="two">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <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>
    
    
    <environment id="two">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <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>

注意一些关键点:

默认使用的环境 ID（比如：default=“development”）。
每个 environment 元素定义的环境 ID（比如：id=“development”）。
事务管理器的配置（比如：type=“JDBC”）。默认JDBC，有JDBC和MANAGED两套可以使用
数据源的配置（比如：type=“POOLED”）。默认POOLED，有三种内建的数据源类型（也就是 type=“[UNPOOLED|POOLED|JNDI]”）

3.属性（properties）

默认使用的环境 ID（比如：default=“development”）。
每个 environment 元素定义的环境 ID（比如：id=“development”）。

编写一个properties文件，引用properties文件必须在配置文件的最上面，以下时引用顺序，否则就会报错！！

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

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatisuseSSl=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=987cde@

在配置文件中引用，需要写配置文件的全路径！

<1--resourse引入外部配置文件-->
<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="root"/>
  <property name="password" value="987cde@"/>
</properties>

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

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

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。先读取的内容被覆盖！

4类型别名(typeAliases)

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

1.给某一个类设置一个别名,核心配置文件

 <typeAliases>
        <typeAlias type="com.kuang.pojo.User" alias="User"/>
 </typeAliases>

2.也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：


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

每一个在包 com.kuang.pojo中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如com.kuang.pojo.USer的别名为user`；若有注解，则别名为其注解值。见下面的例子：


@Alias("User")
public class User {}

下面是一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的，注意，为了应对原始类型的命名重复，采取了特殊的命名风格。

**注意基本类型和保证类型的区别表达

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

5.设置（settings）

可以设置的内容有很多，完整的设置入下，主要关注，缓存的开启，懒加载，日志的设置

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true \| false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。	true \| false	false

logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J(deprecated since 3.5.9) \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未设置

mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true \| false	False

6.其他

[typeHandlers（类型处理器）
[objectFactory（对象工厂）
[plugins（插件）

1.mybatis-plus 作为mybatis的一个补充

7.映射器（mappers）

方式一：推荐使用，通过资源路径来注册

    <mappers>
        <mapper resource="com/kuang/dao/UserDaoMapper.xml"/>
    </mappers>

方式二：1.接口类名和配置文件的xml必须同名 2.接口类名和配置文件必须在同一个包下

<!-- 使用映射器接口实现类的完全限定类名 -->
    <mappers>
        <mapper class="com.kuang.dao.UserMapper"/>
    </mappers>

方式三：

 <!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
        <!--<mapper class="com.kuang.dao.UserMapper"/>-->
        <!-- <mapper resource="com/kuang/dao/UserDaoMapper.xml"/>-->
        <package name="com.kuang.dao"/>
    </mappers>

8.生命周期和作用域

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

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

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
是一个局部变量

SqlSessionFactory

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

SqlSession

连接到连接池的一个请求
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
用完就要关闭，否则资源浪费。

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

这里的每一个Mapper,就代表要给具体的业务(可以执行不同的sql)。

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

数据库字段：

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

对象的属性存在不一致：

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

1.问题：

字段和属性不一致，导致查询结果无法正确映射所以结果为null

User{id=3, name='null', pwd='123'}

2.解决方式

方法一：简单粗暴，可以少量使用

给查询的不一致字段添加别名：

<select id="selectUserById" resultType="User" parameterType="int">
        select id,username as name ,pwd from User where id = #{id};
    </select>

方法二：官方推荐使用ResultMap 对原来的mapper文件进行优化

    
<resultMap id="resultMap" type="User">
        <result property="id" column="id"/>
        <result property="name" column="userName"/>
        <result property="pwd" column="pwd"/>
    </resultMap>

    <select id="selectUserById" resultMap="resultMap">
        select *from User where id = #{id};
    </select>

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

特别注意

在实际使用的时候，不需要将所有的字段都实现映射，只要将不同的字段进行映射就可以：

   <resultMap id="resultMap" type="User">
        <!--<result property="id" column="id"/>-->
        <result property="name" column="userName"/>
        <!--<result property="pwd" column="pwd"/>-->
    </resultMap>
    <select id="selectUserById" resultMap="resultMap">
        select *from User where id = #{id};
    </select>

resultMap元素时MyBatis中最重要最强大的元素
ResultMap的设计思想是，对于简单的语句根据不需要配置显示的结果映射，而对于复杂一点的语句只需要描述他们的关系就行了
ResultMap最优秀的地方在于，虽然你已经对他相当了解了，但是根本不需要显式地用到他们。

如果世界就是如此简单该多好

6.日志

6.1日志工厂

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

logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J(deprecated since 3.5.9) \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未设置

SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【标准配置：掌握】
NO_LOGGING

在mybatis中需要使用哪种日志实现，需要们的在配置文件的setings中设置

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

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

6.2 log4j

什么是log4j

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

1.导入依赖

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

2.添加配置文件网上随便搜索的一个

### set log levels ###
 log4j.rootLogger = DEBUG , C , D , E 

 ### console ###
 log4j.appender.C = org.apache.log4j.ConsoleAppender
 log4j.appender.C.Target = System.out
 log4j.appender.C.layout = org.apache.log4j.PatternLayout
 log4j.appender.C.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ### log file ###
 log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
 log4j.appender.D.File = ../logs/mybatis_study.log
 log4j.appender.D.Append = true
 log4j.appender.D.Threshold = INFO 
 log4j.appender.D.layout = org.apache.log4j.PatternLayout
 log4j.appender.D.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ### exception ###
 log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
 log4j.appender.E.File = ../logs/mybatis_study_error.log 
 log4j.appender.E.Append = true
 log4j.appender.E.Threshold = ERROR 
 log4j.appender.E.layout = org.apache.log4j.PatternLayout
 log4j.appender.E.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ###mybatis show sql###
 log4j.logger.com.ibatis=debug
 log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=debug
 log4j.logger.com.ibatis.common.jdbc.ScriptRunner=debug
 log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=debug

 log4j.logger.java.sql.Connection=debug
 log4j.logger.java.sql.Statement=debug
 log4j.logger.java.sql.PreparedStatement=debug

6.3配置logj为日志实现

### set log levels ###
 log4j.rootLogger = DEBUG , C , D , E 

 ### console ###
 log4j.appender.C = org.apache.log4j.ConsoleAppender
 log4j.appender.C.Target = System.out
 log4j.appender.C.layout = org.apache.log4j.PatternLayout
 log4j.appender.C.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ### log file ###
 log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
 log4j.appender.D.File = ../logs/mybatis_study.log
 log4j.appender.D.Append = true
 log4j.appender.D.Threshold = INFO 
 log4j.appender.D.layout = org.apache.log4j.PatternLayout
 log4j.appender.D.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ### exception ###
 log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
 log4j.appender.E.File = ../logs/mybatis_study_error.log 
 log4j.appender.E.Append = true
 log4j.appender.E.Threshold = ERROR 
 log4j.appender.E.layout = org.apache.log4j.PatternLayout
 log4j.appender.E.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

 ###mybatis show sql###
 log4j.logger.com.ibatis=debug
 log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=debug
 log4j.logger.com.ibatis.common.jdbc.ScriptRunner=debug
 log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=debug

 log4j.logger.java.sql.Connection=debug
 log4j.logger.java.sql.Statement=debug
 log4j.logger.java.sql.PreparedStatement=debug

** 简单使用**

private static  Logger logger =   Logger.getLogger(UserDaoTest.class);
 logger.info("输出");
  logger.error("异常输出");
logger.debug("异常输出");

7.分页

1.通过sql实现分页

select * from user limit 3 3;
select * from user limit 3;

List<User> getUserLimit(Map<String,Integer> map);

  <select id="getUserLimit" parameterType="map" resultMap="resultMap">
        select  * from User limit #{startIndex},#{pageSize};
    </select>

  SqlSession sqlSession = mybatisUtil.getSqlSession();
      UserMapper userMapper =  sqlSession.getMapper(UserMapper.class);
      Map<String,Integer> map = new HashMap<String,Integer>();
      map.put("startIndex",0);
      map.put("pageSize",3);
      List<User> userList = userMapper.getUserLimit(map);
        for (User user:userList
             ) {
            System.out.println(user.toString());

        }

2.通过java代码实现分页

1.接口

  List<User> getUsersRow();

2.Mapper.xml

 <select id="getUsersRow" resultType="User">
        select  * from User ;
    </select>

3.测试

 @Test
    public  void  getUserRow(){
        SqlSession sqlSession= mybatisUtil.getSqlSession();
        RowBounds rowBounds = new RowBounds(1,2);

        List<User> users = sqlSession.selectList("com.kuang.dao.UserMapper.getUsersRow",null,rowBounds);
        for (User user:users
             ) {
            System.out.println(user.toString());
        }
        sqlSession.close();
    }

3.通过分页插件：MybatisPageHelper

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

8.使用注解开发

1.接口

public interface UserMapper {

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

2.mybatis-conf.xml注册

通过类注解

   <mappers>
        <mapper class="com.kuang.dao.UserMapper"/>
        <!-- <mapper resource="com/kuang/dao/UserDaoMapper.xml"/>-->
        <!--<package name="com.kuang.dao"/>-->
    </mappers>

3.测试

  @Test
    public void getUsers(){
       SqlSession sqlSession =  mybatisUtil.getSqlSession();

        //底层还是通过反射来实现
       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
       List<User> userList = userMapper.getUsers();
        for (User user : userList) {
            System.out.println(user.toString());
        }

       sqlSession.close();
    }

注解实现CRUD

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

 public  static SqlSession getSqlSession(){
      
     //存入参数  true,则设置提交事务参数为true，自动提交，不需要手动commit
        return   sqlSessionFactory.openSession(true);
    }

1.编写接口

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

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

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

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

2.测试: 前面设置了自动提交事务，所以这里都没有提交事务，结果也是可以实现

   @Test
    public void addUser(){
        SqlSession sqlSession =  mybatisUtil.getSqlSession();

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.insertUser(new User(7,"姓名","234"));
    }

    @Test
    public void upUser(){
        SqlSession sqlSession =  mybatisUtil.getSqlSession();

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.updateUser(new User(7,"修改","3333"));
    }

注意

在配置文件中，注册Mapper的时候，可以根据包注册，也可以根据路径用*.xml注册

 <mappers>
       <!-- <mapper class="com.kuang.dao.UserMapper"/>-->
        <mapper resource="com/kuang/dao/*Mapper.xml"/>
        <!--<package name="com.kuang.dao"/>-->
    </mappers>

9.LomBok的使用

1.安装Lombok插件

@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
@val
@var
experimental @var
@UtilityClass

2.导入jarBao

    <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.16</version>
        </dependency>

3.添加注解

@Data:get,set,toString,equals,hashCode
@NoArgsConstructor  无参
@AllArgsConstructor  有参
@Getter and @Setter
@ToString

10多对一处理

多个学生对应一个老师，类似于查询所有学生对应的老师

1.新建一个项目

2.写实体类，接口，工具类

3.mapper.xml和config.xml

按照查询嵌套处理

相当于sql中的子查询

    <select id="getStudents" resultMap="getStudentMap">
        select * from mybatis.student;
    </select>

<resultMap id="getStudentMap" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
    <!--对象用association  集合用collection -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>

    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{tid};
    </select>

按照结果嵌套处理

 <select id="getStudents2" resultMap="getStudentMap1">
        select s.id sid,s.name sname , t.name tname ,t.gender gender from
        student s ,teacher t where s.tid= t.id 
    </select>

    <resultMap id="getStudentMap1" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
            <result property="gender" column="gender"/>
        </association>
    </resultMap>

11一对多的处理：DEMO写的有问题，需要修改 MYBATIS-07

12动态SQL

高频面试：

mysql引擎，innoDB的底层实现，索引，索引的优化。

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

if

 <select id="getBlogIF" resultType="Blog">
        select * from blog where 1=1
    <if test="title != null">
        and title =#{title}
    </if>
<if test="views != null">
    and views > #{views}
</if>
    </select>

where choose when

where 标签会根据实际情况取舍

when标签注意and和","的取舍。

when标签从第一个开始。依次向下，有一个执行则其他都不执行，如果when标签都不执行，则一定执行

标签内容

<select id="getBlogChoose" resultType="blog">
        select  * from blog
<where>
    <choose>
        <when test="title != null">
             title =#{title}
        </when>
        <when test="author != null">
            and author = #{author}
        </when>
        <otherwise>
            views > #{views}
        </otherwise>
    </choose>
</where>
    </select>

 SqlSession sqlSession = mybatisUtil.getSqlSession();
        BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
         Map map = new HashMap<String,Object>();
         map.put("views",10000);
         map.put("title","mySql学习");
        map.put("author","不内卷");
       // List<Blog> blogs = blogMapper.getBlogIF(map);
        List<Blog> blogList =blogMapper.getBlogChoose(map);

执行sql： select * from blog WHERE title =?

trim、where、set

修改数据的sql,根据实际情况，生成更新数据sql

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>


    <update id="updateSet">
        update blog
<set>
    <if test="title != null">
        title = #{title},
    </if>
    <if test="author != null">
        author = #{author},
    </if>
    <if test="views != null">
        views = #{views}
    </if>
</set>
where id = #{id}
    </update>

SQL片段

在开发中，如果出现很多条sql,而且sql的条件有很多的相同部分，这个时候可以将共同部分的sql提取出来，在需要用的地方通过inclou标签引用。

1.最好通过单表定义sql

2.不要存在where标签

 通过sql标签，抽取共同的部分
<sql id="selectChoose">
        <choose>
            <when test="title != null">
                title =#{title}
            </when>
            <when test="author != null">
                and author = #{author}
            </when>
            <when test="createTime != null">
                and create_time > #{createTime}
            </when>
            <otherwise>
                views > #{views}
            </otherwise>
        </choose>
    </sql>

在需要用的地方，通过include标签引用。
<select id="getBlogChoose" resultType="blog">
        select  * from blog
<where>
 <include refid="selectChoose"></include>
</where>
    </select>

foreach

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

   
<select id="getBlogsEach" parameterType="map" resultType="blog">
        select * from blog
         <if test="ids != null"   >
            where id in
                 <foreach collection="ids" open="  (" close=")" item="id" separator=",">
                     #{id}
                 </foreach>
         </if>
    </select>

   <select id="getBlogsEach" parameterType="map" resultType="blog">
        select * from blog
         < where >
            
                 <foreach collection="ids" open="  id in (" close=")" item="id"               separator=",">
                     #{id}
                 </foreach>
         </where>
    </select>


    <select id="getBlogsEach2" parameterType="map" resultType="blog">
        select * from blog
<where>
    <foreach collection="ids" open=" and (" close=")" separator="or" item="id">
        id = #{id}
    </foreach>
</where>
    </select>

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

13缓存

默认情况下，只启用了本地的会话缓存（一级缓存），它仅仅对一个会话中的数据进行缓存。

要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行

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

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

一级缓存

 SqlSession sqlSession = myBatisUtil.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.getUserById(1);//第一次查询
        System.out.println(user.toString());
        User user1 = userMapper.getUserById(1);//第二次查询
        System.out.println(user1.toString());
        System.out.println(user==user1);//判断是否取的缓存
        userMapper.updateUser(new User(2,"修狗","mmmama"));//修改
        User user2 = userMapper.getUserById(1);//第三次查询
        System.out.println(user2.toString());
        System.out.println(user==user2);//判断是否相等

通过以上Java代码和日志情况，第一次查询读取数据库，第二次查询则从缓存里读取，对象引用地址相同。

进行一次数据库修改操作后，清理了缓存，

再次查询，用了sql读取数据库信息，和上面的引用地址不一样。

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

二级缓存

二级缓存又叫全局缓存，一级缓存的作用域太低了，所以诞生了一级缓存

基于namespace级别的缓存，一个命名空间，对应一个二级缓存

工作机制：

一个会话查询一条数据，这条数据就会被存放在当前会话的一级缓存中。

如果当前会话被关闭了，那么这个会话对应的一级缓存就没有了，而我们想要的是将当前一级缓存

中的数据内容缓存到二级缓存中。

新的会话查询信息就会从二级缓存查询数据

不同的mapper查询的数据会被换到到自己的对应的map中。

步骤：

1.在设置中显性的开始缓存

 <setting name="cacheEnabled" value="true"/>

2.在mapper中开始缓存

<mapper namespace="com.kuang.dao.UserMapper">
    <cache/>

3.测试

SqlSession sqlSession = myBatisUtil.getSqlSession();
        SqlSession sqlSession1 = myBatisUtil.getSqlSession();
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
        User user = userMapper.getUserById(1);
        System.out.println(user.toString());
        sqlSession.close();
        User user1 = userMapper1.getUserById(1);
        System.out.println(user1.toString());

在关闭了一个会话后，如果没有二级缓存，应该再次查询数据库，实际上是从缓存取值。

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

注意：添加二级缓存的实体类需要做序列化处理

java.io.NotSerializableException: com.kuang.pojo.User

缓存的执行流程原理

增删改会清理所有缓存信息。

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