Mybatis

面试高频

• Mysql引擎
• InnoDB底层原理
• 索引
• 索引优化

简介:

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

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

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

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

持久化

数据持久化

1.持久化就是将程序的数据在持久状态和瞬间状态的转化过程

2.jdbc(数据库),io文件持久化

3.生活例子:冰箱冷藏,鲱鱼罐头.......

为什么要持久化

内存:断电及失,有些对象不能丢掉,如money.....内存也太贵了.

持久层

dao.service.controller.filterl.pojo.util==> javaweb的基础层

1.完成持久化工作的代码块

2.层界限十分清楚

第一个mybatis程序

思路：搭建环境-->导入mybatis-->编写代码-->测试

目录要规范哦

1.先创一个简单的maven夫工程（删除src，没用的就删了）

2.导入相应的maven依赖

（资源导出失败问题，记得在子工程里也加上，以防万一）

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
<!--    mysql的驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.24</version>
    </dependency>
<!--    测试代码的工具-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<!--在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>

3在resources里配置mybatis-config.xml==>configuration核心配置文件

具体的mysql配置根据自己电脑上的来配，mappers也是根据自己相应的mapper.xml来配（注意要“/”隔开啊==>对应的是路径哦）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/user?userUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/zhang/Dao/getUserMapper.xml"/>
    </mappers>
</configuration>

搭建mybatisUtil==>SqlSessionFactory-->SqlSession

package com.zhang.util;

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-->SqlSession
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 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

mybatis简单查询

1.pojo

package com.zhang.pojo;

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

    public User() {
    }

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

    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 getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.Dao接口

package com.zhang.Dao;

import com.zhang.pojo.User;

import java.util.List;

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

3.接口类的实现.由DaoImpl转化为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.zhang.Dao.UserDao">
<!--    id对应相应的方法,resultType返回方法的结果集-->
    <select id="getUserList" resultType="com.zhang.pojo.User">
        select * from user.userinformation
    </select>
</mapper>

4.test

mappers也是根据自己相应的mapper.xml来配==》没有注册的后果

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

MapperRegistry是什么？

核心配置文件中注册的mappers

package com.zhang.UserDaoTest;

import com.zhang.Dao.UserDao;
import com.zhang.pojo.User;
import com.zhang.util.MybatisUtil;
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 = MybatisUtil.getSqlSession();

        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user.getId());
        }
        //关闭SqlSession
        sqlSession.close();
    }
}

mybatis实现简单的增删改查(CRUD)

CRUD（增删改查）

C=Create

R=Read

U=Update

D=Delete

  对与接口的方法

package com.zhang.Dao;

import com.zhang.pojo.User;

import java.util.List;

public interface UserMapper {
    //查询所有用户
    List<User> getUserList();
    //添加用户
    int addUser(User user);
    //改用户信息
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);
}

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中的包名要和dao/mapper接口的包名一致
<mapper namespace="com.zhang.Dao.UserMapper">
//id:就是对应的namespace中的方法名
//resultType:sql语句执行的返回值
//paramType:参数类型!可对象,可变量
//#{value}==>value对应的是你方法的参数名
    <select id="getUserList" resultType="com.zhang.pojo.User">
        select * from user.userinformation
    </select>
    <insert id="addUser" parameterType="com.zhang.pojo.User">
        insert into user.userinformation (id, username, password) values (#{id},#{username},#{password})
    </insert>
    <update id="updateUser" parameterType="com.zhang.pojo.User">
        update user.userinformation
        set username =#{username},password=#{password}
        where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="int" >
        delete
        from user.userinformation
                 where id=#{id};
    </delete>
</mapper>

在测试类里的测试

package com.zhang.UserDaoTest;


import com.zhang.Dao.UserMapper;
import com.zhang.pojo.User;
import com.zhang.util.MybatisUtil;
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 = MybatisUtil.getSqlSession();

        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int user = mapper.addUser(new User(5, "wang", "123667"));
        sqlSession.commit();
         sqlSession.close();

    }
//    增删改一定要记得提交事务
    @Test
    public  void updateUser(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.updateUser(new User(2,"王亚","123456"));
        if (i>0){
            System.out.println("修改成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUser(5);
        sqlSession.commit();
        sqlSession.close();
    }
}

Map在参数的应用

如果,我们的实体类或者数据库的表,字段或参数太多,我们却只要其中的一些值,这个时候可以考虑用Map

List<User> getUser(Map<String,Object> map);

 <select id="getUser" parameterType="map" resultType="com.zhang.pojo.User">
        select * from user.userinformation where id=#{something} and password=#{password}
    </select>

  @Test
    public void UserList(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map = new HashMap<>();
        map.put("something",1);
        map.put("password","123456");
        List<User> user = mapper.getUser(map);
        for (User user1 : user) {
            System.out.println(user1);
        }
        sqlSession.close();
    }

Map传递参数,直接在sql中取出key即可 = parameterType="map" =

对象传递参数,直接在sql中取对象的属性即可= parameterType="Object"  =

只有一个基本类型参数时,可以直接在sql中取到,就不用写parameterType=".."了

多个参数用Map,或者注解

关于模糊查询 like

1.方法一=>ava代码执行的时候,传递通配符% %

map.put("name","%张%");

 2.方法二=>在sql拼接中使用通配符(注意%一定要和#{name}空格隔开哦)

select * from user.userinformation where id=#{something} and username like '%' #{name} '%'

map.put("name","张");

分页的实现

方法一:limit(推荐使用)

接口:

 //分页的实现
    List<User> userList(Map<String,Integer> map);

Mapper.xml:

<!--    结果集映射:数据库字段名password.pojo对应的为pwd-->
<resultMap id="userMap" type="User">
    <id property="pwd" column="password"></id>
</resultMap>
<select id="userList" parameterType="map" resultMap="userMap">
        select *
        from user.userinformation
         limit #{startIndex},#{pageSize};
    </select>

测试:

 //limit分页
    @Test
    public void limitList(){
        SqlSession sqlSession = MybatisUtil.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.userList(map);
        for (User user : userList) {
            System.out.println(user);
            sqlSession.close();
        }
    }

方法二:ROWBounds分页

方法三:分页插件https://pagehelper.github.io/(方法二,三了解知道有就可以了,具体可以百度)

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

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

2.环境配置

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

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

mybatis默认的事务管理器:JDBC.  连接池:POOLED

(注意:不是唯一的配置 type="[JDBC|MANAGED]".数据源type="[UNPOOLED|POOLED|JNDI]")

3.属性(properties)

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

这些属性可以在外部进行配置，并可以进行动态替换.这些属性可以在外部进行配置，并可以进行动态替换[db.properties]

(注意:xml中的properties一定要放在最上面哦)

db.properties(放在resources目录下)

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

在核心配置文件中引入

    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="111111111"/>
    </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>

1.可以直接引入外部文件

2.可以在其中增加一些属性配置

3.如果两个文件有同一字段,优先使用外部配置文件

4.类型别名（typeAliases）

>类型别名可为 Java 类型设置一个缩写名字。

>它仅用于 XML 配置，意在降低冗余的全限定类名书写。

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

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean,比如:填写实体类的包,它的默认别名就是这个类的类名,首字母要小写

(注意:大写也没问题的不容易区分是否为别名在使用resultType时)

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

在实体类比较少的时候,使用第一种方式.

如果实体类十分多的时候,建议用第二种.

第一种可以自己造别名,第二种<不可以>如果非要改,需要在实体类上加注解

@Alias("user")
public class User {

5.设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。(理解一些即可,如要知晓其他https://mybatis.org/mybatis-3/zh/configuration.html#settings)

6.映射器（mappers）

MapperRegistry:注册绑定我们的Mapper文件

方法一:[推荐使用]

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

方法二:使用class文件绑定注册

 <mappers>
        <mapper class="com.zhang.Dao.UserMapper"/>
    </mappers>

方法三:使用扫描包进行绑定注册

 <mappers>
        <package name="com.zhang.Dao"/>
    </mappers>

注意:

1.接口和它的Mapper配置文件必须同名(方法二,三)

2.接口和它的Mapper配置文件必须在同一包下(方法二,三)

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

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

SqlSessionFactoryBuilder

1.一旦创建了 SqlSessionFactory，就不再需要它了。

2.局部变量

SqlSessionFactory

1.可以想象成:数据库连接池

2.SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 

3. SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

1.连接到连接池的一个请求

2.SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。

3.用完之后要赶紧关闭,否则资源被占用

在里面的每一个mapper都代表一个具体的业务

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

数据库的字段和pojo里的属性

结果:(出现这个结果一定要有无参构造器,否则走有参构造器那个会pwd还是会出来{'123456'})

解决办法:

1.在sql语句里加上别名

select id,username,password as pwd
        from user.userinformation
         where id=#{id};

2.结果映射(ResultMap)

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhang.Dao.UserMapper">
<resultMap id="userMap" type="User">
    <id property="pwd" column="password"></id>
</resultMap>
    <select id="getUser" parameterType="int" resultMap="userMap">
        select *
        from user.userinformation
         where id=#{id};
    </select>
</mapper>

 ResultMap元素是 MyBatis 中最重要最强大的元素。

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。 

你会发现上面的例子没有一个需要显式配置ResultMap，这就是ResultMap 的优秀之处——你完全可以不用显式地配置它们。 虽然上面的例子不用显式配置ResultMap。

如果这个世界总是这么简单就好了

使用注解开发

• 面向接口编程

选择原因:

解耦,可拓展,提高复用,分层开发中,上层不用管具体的实现,大家都遵守共同的标准,使得开发变容易,规范性更好

什么叫面向接口编程

在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解。

1.接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。

2.接口的本身反映了系统设计人员对系统的抽象理解。

3.接口应有两类：第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；

4.第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；

5.一个体有可能有多个抽象面。

6.抽象体与抽象面是有区别的。

三个面向区别

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

注解开发的简单实现

1.注解在接口上实现

//查询用户
    @Select("Select * from user.userinformation")
    List<User> getUser();

2.核心配置文件应该绑定接口

    <mappers>
        <mapper class="com.zhang.Dao.UserMapper"></mapper>
    </mappers>

3.测试

 @Test
   public void userList(){
        //1.获取sqlSession对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> user = userMapper.getUser();
        for (User user1 : user) {
            System.out.println(user1);
        }
        //关闭SqlSession
        sqlSession.close();
    }

本质:反射机制实现

底层:动态代理!

Mybatis执行原理

注解实现->CRUD

我们可以在工具类创建的时候实现自动提交事务(最好不要开启,不易排错..新手)

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

源代码:

 public SqlSession openSession(boolean autoCommit) {
        return this.sqlSessionFactory.openSession(autoCommit);
    }

编写接口,增加注解

  //查询用户
    @Select("Select * from user.userinformation")
    List<User> getUser();
    //添加用户
//方法存在多个参数,所有的参数前面必须加上@Param()注解
    @Insert("INSERT INTO userinformation (ID, USERNAME, PASSWORD) VALUES (#{id},#{username},#{password})")
    int addUser(User user);
    //改用户信息
 @Update("update userinformation set password = '222222' where id=#{uid};")
    int updateUser(@Param("uid") int id);
    //删除用户
 @Delete("delete from userinformation where id=#{id} and username=#{username}")
    int deleteUser(@Param("id") int id,@Param("username") String username);

测试类(注意:我们必须要将注册绑定到我们的核心配置文件中)

public class UserDaoTest {
    @Test
   public void userList(){
        //1.获取sqlSession对象,查
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        int i=0;
        List<User> user = userMapper.getUser();
        for (User user1 : user) {
            System.out.println(user1);
        }
        //增
         i = userMapper.addUser(new User(6, "王五", "12345"));
        //删
          i= userMapper.deleteUser(2, "王亚");
          //改
        i= userMapper.updateUser(1);
        if (i>0){
            System.out.println("ok");
        }
        //关闭SqlSession
        sqlSession.close();
    }

关于@Param()注解

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

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。 

复杂查询

多对一与一对多

• association – 一个复杂类型的关联；许多结果将包装成这种类型
  • 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
• collection – 一个复杂类型的集合
  • 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用

环境搭建

1.数据库的准备

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

 2.其他class的准备工作

TeacherMapper.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.zhang.Dao.TeacherMapper">

</mapper>

1.导入lombok

2.新建实体类Teacher,Student

3.建立mapper接口

4.建立mapper.xml

5.在核心配置文件中绑定注册我们的mapper接口或者文件

6.测试查询是否可行

复杂的属性,我们需要单独处理 对象:association 集合:collection

多对一的简单应用=>查询学生及其对应的老师

实体类及接口

@Data
@ToString
public class Teacher {
    private int id;
    private String name;
}

@Data
@ToString
public class Student {
    private int id;
    private String name;
    private Teacher teacher;
}

public interface StudentMapper {
//     查询所有学生及其对应的老师
     List<Student> studentList();
}

按照结果嵌套处理 StudentMapper.xml

<select id="studentList" resultMap="TeacherStudent">
        select t.name tname,s.id sid,s.name sname from user.student s,user.teacher t where s.tid=t.id
    </select>
    <resultMap id="TeacherStudent" type="com.zhang.pojo.Student">
        <result column="sid" property="id"/>
        <result column="sname" property="name"/>
        <association property="teacher" javaType="com.zhang.pojo.Teacher">
            <result column="tname" property="name"/>
        </association>
    </resultMap>

 结果:

按照查询嵌套处理 StudentMapper.xml 

思路:

1.查询所有的学生信息

2.根据查询出来的学生的tid,寻找对应的老师/  子查询

<select id="studentList" resultMap="TeacherStudent2">
        select * from user.student
    </select>
    <select id="getTeacher" resultType="com.zhang.pojo.Teacher">
        select * from user.teacher
    </select>
    <resultMap id="TeacherStudent2" type="com.zhang.pojo.Student">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <association property="teacher" column="tid" javaType="com.zhang.pojo.Teacher" select="getTeacher"/>
    </resultMap>

结果 :

mysql多对一的查询方式

1.联表查询

2.子查询

 一对多的简单应用

比如:一个老师对多个学生

对于老师而言就是一对多

实体类和接口

@Data
@ToString
public class Teacher {
    private int id;
    private String name;
    private List<Student> students;
}

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

public interface TeacherMapper {
    //一个老师查询多个学生
    List<Teacher> teacherList(@Param("tid") int tid);
}

 按照结果嵌套处理

    <resultMap id="TeacherStudent" type="com.zhang.pojo.Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="com.zhang.pojo.Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
<select id="teacherList"  resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.id tid,t.name tname
    from user.teacher t,user.student s where s.tid=t.id and t.id=#{tid}
</select>

结果:

Teacher(id=1, name=张老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)]) 

按照查询嵌套处理 

   <select id="teacherList" resultMap="TeacherStudent">
        select * from user.teacher where id=#{tid}
    </select>
    <select id="studentList" resultType="com.zhang.pojo.Student">
        select * from user.student where tid=#{id}
    </select>
    <resultMap id="TeacherStudent" type="com.zhang.pojo.Teacher">
        <collection property="students" javaType="ArrayList" ofType="com.zhang.pojo.Student" select="studentList" column="id" />
    </resultMap>

 Teacher(id=0, name=张老师, students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])

小结:

1.关联:association

2.集合:collection

3.javaType & ofType

• javaType 用来指定实体类中的属性类型
• ofType 用来指定映射到List或者集合中的pojo类型,泛型中的约束类型

注意点:

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

动态SQL

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

本质还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码

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

• 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

创建一个基础工程

导包 

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

编写配置文件

mapUnderscoreToCamelCase

是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties">
        <property name="username" value="root"/>
    </properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <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>
    <mapper class="com.zhang.Dao.BlogMapper"/>
</mappers>


</configuration>

编写实体类

@Data
@ToString
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}

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

public interface BlogMapper {
    int addBlog(Blog blog);
}

<?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.zhang.Dao.BlogMapper">
<insert id="addBlog" parameterType="com.zhang.pojo.Blog">
    insert into user.blog (id, title, author, create_time, views) values (#{id}, #{title},#{author}, #{createTime}, #{views})
</insert>
</mapper>

对于随机id的处理

public class IdUtil {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

测试类 

public class MyTest {
    @Test
        public void addBlogTest(){
            SqlSession sqlSession = MybatisUtil.getSqlSession();
            BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
            Blog blog = new Blog();
            blog.setId(IdUtil.getId());
            blog.setTitle("Mybatis is easy");
            blog.setAuthor("张三");
            blog.setCreateTime(new Date());
            blog.setViews(9999);
             int i=mapper.addBlog(blog);
            blog.setId(IdUtil.getId());
            blog.setTitle("Java is easy");
            i=mapper.addBlog(blog);

            blog.setId(IdUtil.getId());
            blog.setTitle("Spring is easy");
            i=mapper.addBlog(blog);

            blog.setId(IdUtil.getId());
            blog.setTitle("微服务 is easy");
            i=mapper.addBlog(blog);

            sqlSession.close();
    }
}

文件结构

IF 

接口 

//根据文章或者作者查询相应记录
    List<Blog> queryBlogByIf(Map map);

xml

where 1=1(不正规)可以换成<where></where>标签哦

<resultMap id="Blog" type="com.zhang.pojo.Blog"/>
    <select id="queryBlogByIf" parameterType="map" resultMap="Blog">
        select *
        from user.blog where 1=1
<if test="title != null">
   and title like  '%' #{title} '%'
</if>
<if test="author != null">
   and author like '%' #{author} '%'
</if>
    </select>

测试类 

 @Test
    public void queryBlogByIf(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        map.put("title","java");
        map.put("author","张三");
        List<Blog> blogs = mapper.queryBlogByIf(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }

choose、when、otherwise

MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句 

它满足一个条件就直接结束,不会再走下去了

xml配置文件:

<select id="queryBlogByChoose" parameterType="map" resultMap="Blog">
        select *
        from user.blog
        <where>
          <choose>
           <when test="title != null">
               title like  '%' #{title} '%'
            </when>
           <when test="author != null">
               and author like '%' #{author} '%'
           </when>

          <otherwise>
              and views>=#{}
          </otherwise>
          </choose>
        </where>
    </select>

测试类:

  @Test
    public void queryBlogByChoose(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        map.put("title","java");
        map.put("author","张三");
        map.put("views",999);
        List<Blog> blogs = mapper.queryBlogByChoose(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }

结果: 

trim、where、set

if中xml的改进方法

where :

元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

    <resultMap id="Blog" type="com.zhang.pojo.Blog"/>
    <select id="queryBlogByIf" parameterType="map" resultMap="Blog">
        select *
        from user.blog
        <where>
            <if test="title != null">
             title like  '%' #{title} '%'
        </if>
            <if test="author != null">
                and author like '%' #{author} '%'
            </if>
        </where>
    </select>

set: 

元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

接口:

//更新博客信息
    int updateBlog(Map map);

xml配置文件:

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

测试类及结果:

        SqlSession sqlSession = MybatisUtil.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        map.put("title","java");
        map.put("author","李四");
        map.put("id","7a544fffbb3a45bd8da95ffe17cfb6b5");
         mapper.updateBlog(map);

trim: 

trim就是自定义一些元素(要想知道更多,百度上详细去了解)

和 where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

prefixOverrides 属性会忽略通过管道符分隔的文本序列（注意此例中的空格是必要的）。上述例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

与 set 元素等价的自定义 trim 元素吧：

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

SQL片段

有的时候,我们可能会将一些公共的部分抽取出来,方便复用

1.使用SQL标签抽取公共的部分

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

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

  <select id="queryBlogByIf" parameterType="map" resultMap="Blog">
        select *
        from user.blog
        <where>
           <include refid="queryBlogByIf-title-author"></include>
        </where>
    </select>
 

注意事项:

• 最好基于单表来定义SQL片段
• 不要存在where标签(这样用的范围会变小的哦)

foreach

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

  WHERE ID in (1,2,3)  ==> where (id=1 or id=2 or id=3)

 简单实现:

接口

List<Blog> queryBlogByForEach(Map map);

 xml配置文件

<resultMap id="Blog" type="com.zhang.pojo.Blog"/>   
<select id="queryBlogByForEach" parameterType="map" resultMap="Blog">
        select * from user.blog
            <where>
            <foreach collection="ids" item="id" open="("  close=")" separator="or">
                id= #{id}
            </foreach>
            </where>
    </select>

测试类及结果

 @Test
    public void queryByForEach(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        ArrayList<String> ids = new ArrayList<>();
        ids.add("1");
        ids.add("2");
        ids.add("5");
        map.put("ids",ids);
        List<Blog> blogs = mapper.queryBlogByForEach(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }

缓存

简介

1.什么是缓存(cache)

• 存在内存中的临时数据
• 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决高并发系统的性能问题

2.为什么使用缓存?

• 减少和数据库的交互次数,减少系统开销,提高系统效率

3.怎么样的数据能使用缓存?

• 经常查询并且不经常改变的数据

Mybatis缓存

• Mybatis 包含一个非常强大的查询缓存特性,它可以非常方便地制定和配置缓存,缓存可以极大的提升查询效率
• Mybaatis系统中默认定义了两级缓存:一级缓存和二级缓存

• 默认情况下，只启用了本地的会话缓存(SqlSession级别的缓存),它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存(基于namespace级别的缓存)

• 为了提高扩展性,Mybatis定义了缓存接口Cache,我们可以通过实现Cache接口来自定义二级缓存

一级缓存

一级缓存也叫本地缓存:

• 与数据库同一次会话期间查询到的数据会放在本地缓存中
• 以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库

测试步骤:

1.开启日志!

2.测试在一个Sesion中查询两次相同记录

3.查看日志输出

缓存失效的情况:

1.查询不同的东西

2.增删改操作,可能会改变原来的数据,所以必定会刷新缓存!

3.查询不同的Mapper.xml

4.手动清理缓存

小结:

一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段

一级缓存相当于一个Map

二级缓存

• 二级缓存也叫全局缓存,一级缓存作用域太低了,所有诞生了二级缓存
• 基于namespace级别的缓存,一个名称空间,对应一个二级缓存
• 工作机制

1. 一个会话查询一条数据,这个数据就会被放在当前会话的一级缓存中
2. 如果当前会话关闭了,这个会话对应的一级缓存就没了;但是我们想要的时候,会话闭关了,一级缓存中的数据被保存到了二级缓存中;
3. 新的会话查询信息,就可以从二级缓存中获取内容
4. 不同的mapper查出的数据会放在自己对应的缓存(map)中

步骤:

1.开启全局缓存==>mybatis-config.xml

cacheEnabled

全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。

true | false

true

默认开启了,但还要手动开启,方便别人知道

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

2.在当前的Mapper.xml中使用二级缓存(cache还有些配置可以自己搞,但没必要哦,useCache默认true)

<mapper namespace="com.zhang.Dao.UserMapper">
    <cache/>
    <select id="userList" resultType="User" useCache="true">
        select * from user.userinformation where id=#{id}
    </select>

3.测试

问题:我们需要将实体类序列化,否则会报错.

Error serializing object.  Cause: java.io.NotSerializableException: com.zhang.pojo.User

小结:

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

缓存原理:

  Mybatis-日志

SLF4J | LOG4J(掌握) | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING(掌握) | NO_LOGGING

日志工厂

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

曾经:sout,debug

现在:日志工厂

1.STDOUT_LOGGING

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

标准的日志工厂实现,在设置里设定( STDOUT_LOGGING标准日志输出)

(name和value的值一定要注意了,一模一样哦)

2.Log4j

什么是Log4j?

1.通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件

2.我们也可以控制每一条日志的输出格式

3.通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程

4.通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

1.先导入log4j的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</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/zhang.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>

直接测试运行刚才的查询

简单的使用

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

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

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

3.日志级别

 @Test
     public void log4j(){
         logger.debug("debug进入了log4jTest");
         logger.error("error进入了log4jTest");
         logger.info("info进入了log4jTest");
     }

[DEBUG][21-06-01][UserDaoTest]debug进入了log4jTest
[ERROR][21-06-01][UserDaoTest]error进入了log4jTest
[INFO][21-06-01][UserDaoTest]info进入了log4jTest

Lombok的使用 

 简介:

Project Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.
Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

使用

(公司用你们就用,公司不用你们就别用)

setting中下载Lombok的插件

导入lombok的jar包

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

说明:

@Data:无参构造,get,set,tostring,hashcode,equals 

@ToString
@AllArgsConstructor
@NoArgsConstructor
@Getter

ps:根据狂神视频+自己所理解(min)笔记