mybatis入门探究

基础知识：

• JDBC
• Mysql
• Java基础
• Maven
• Junit

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

1、简介

1.1、什么是 MyBatis？

• MyBatis 是一款优秀的持久层框架
• 它支持定制化 SQL、存储过程以及高级映射。
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
• MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

如何获得MyBatis？

• Maven仓库

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

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

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

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库(JDBC),io文件持久化。
• 生活：冷藏、罐头。

为什么需要持久化？

• 有一些对象，不能让他丢掉。

1.3、持久层

Dao层、Service层、Controller层…

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

1.4、为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中。

• 方便

• 传统的JDBC代码太复杂了。简化、框架、自动化。

• 不用Mybatis也可以。更容易上手。技术没有高低之分

• 优点：

  • 简单易学
  • 灵活
  • sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。

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

  Spring SpringMVC SpringBoot

2、第一个mybatis程序

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

2.1搭建环境

数据库创建

CREATE DATABASE mybatis;

CREATE table `user`(
`id` INT(10) not NULL,
`name` VARCHAR(30) DEFAULT NULL,
`pass` VARCHAR(30) DEFAULT NULL,
PRIMARY key(id)

) ENGINE=INNODB DEFAULT CHARSET=utf8; 

INSERT INTO user (id,name,pass) VALUES(1,"小哥","admin")
INSERT INTO user (id,name,pass) VALUES(2,"大哥","admin1")
INSERT INTO user (id,name,pass) VALUES(3,"二哥","admin2")
INSERT INTO user (id,name,pass) VALUES(4,"三哥","admin2")

pom依赖导入

<dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

2.2、创建一个子模块

编写mybatis核心配置文件

mybatis-config.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核心配置文件-->
<configuration>
     <!--environments配置环境组-->
    <!--default默认环境-->
    <environments default="development">
        <!--environment单个环境-->
        <environment id="development">
            <!--transactionManager配置事务管理器-->
            <transactionManager type="JDBC"/>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <!--jdbc驱动-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
               <!--数据库地址-->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true"/>
                <!--账号-->
                <property name="username" value="root"/>
                <!--密码-->
                <property name="password" value="toor"/>
            </dataSource>
        </environment>
    </environments>

    
    <!--映射文件注册-->
    <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
    
</configuration>

编写mybatis工具类

package com.x1a0g.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtil {
   private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //这个是mybatis的配置文件的路劲
            String source = "mybatis-config.xml";
            //Resources.getResourceAsStream(source) 是mmybatis自带的io，拿到输入流
            InputStream resourceAsStream = Resources.getResourceAsStream(source);
            //最后拿到sqlSessionFactory这个工厂
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //从sqlSessionFactory这个工厂创建一个SqlSession返回回去
    //既然有了 SqlSessionFactory，顾名思义，我们就可以从中获得 SqlSession 的实例了。
    // SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。
    // 你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
    public static SqlSession getSqlsession(){
        return sqlSessionFactory.openSession();
    }

}

编写代码

编写mapper

package com.x1a0g.mapper;

import com.x1a0g.entity.User;

import java.util.List;

public interface UserMapper {
    List<User> getAllUser();
}

编写mapper的是实现类（接口实现类由原来的UserImpl转变为一个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是命名空间，就是我映射的usermapper   必须是全限定名-->
<mapper namespace="com.x1a0g.mapper.UserMapper">
<!--id对应usermapper的方法名    resultType去写集合中的泛型  -->
  <select id="getAllUser" resultType="com.x1a0g.entity.User">
    select * from user;
  </select>
</mapper>

编写测试单元

注意在maven项目中test测试单元一定要和开发一一对应 这是一种规范

package com.x1a0g.mapper;

import com.x1a0g.entity.User;
import com.x1a0g.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {
    @Test
    public void test(){
        //第一步：获得SqlSession对象
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        //执行SQL
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        List<User> allUser = mapper.getAllUser();
        for (User user : allUser) {
            System.out.println(user);
        }
    }
}

然后运行时候出现的操蛋问题两个问题

org.apache.ibatis.binding.BindingException   这个异常一定是没有在mybatis-config文件中注册


MapperRegistry是什么?

核心配置文件中注册mappers

java.lang.ExceptionInInitializerError:初始化异常 
这种情况是由于在maven中的资源过滤 问题所导致的  解决办法

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

步骤总结

1. 首先编写工具类
2. 编写工具类时候发现需要配置文件，去resources中去写mybatis-config.xml 配置文件
3. 定义实体类
4. 定义mapper接口（相当于jdbc时候的userdao接口）
5. 使用xml去写mapper接口的实现（相当于userdaoimpl）
6. 写测试单元
7. 在pom中需要添加资源过滤

3、增删查改(CRUD)

usermapper接口

package com.x1a0g.mapper;

import com.x1a0g.entity.User;

import java.util.List;

/**
 * 原来的userdao
 */
public interface UserMapper {
    //获取所有用户
    List<User> getUserAll();
    //根据id查用户
    User queryById(int i);
    //增加一个用户
    int insertUser(User user);
    //修改一个用户的信息
    int updateUser(User user);
    //根据id删除一个用户
    int deleteUser(Integer uid);

}

usermapper的实现

<?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   id   resultType  parameterType-->
<mapper namespace="com.x1a0g.mapper.UserMapper">
    <select id="getUserAll" resultType="com.x1a0g.entity.User">
        select * from user;
    </select>

    <select id="queryById" resultType="com.x1a0g.entity.User" parameterType="int">
        select * from user where id=#{id};
    </select>

    <insert id="insertUser" parameterType="com.x1a0g.entity.User">
        insert into user values (#{id},#{name},#{pass});
    </insert>

    <update id="updateUser" parameterType="com.x1a0g.entity.User" >
        update user set name=#{name},pass=#{pass} where id=#{id}
    </update>

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

测试单元编写

package com.x1a0g.mapper;

import com.x1a0g.entity.User;
import com.x1a0g.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {

    @Test
    public void test01(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        //这句就好比  我的多态  父类的UserMapper调用子类
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        List<User> userAll = mapper.getUserAll();
        for (User user : userAll) {
            System.out.println(user);
        }
        sqlsession.close();
    }

    @Test
    public void queryById(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        User user = mapper.queryById(2);
        System.out.println(user);
        sqlsession.close();
    }
    //增删改必须提交事务
    @Test
    public void insertUserTest(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        mapper.insertUser(new User(5,"啊啊啊啊","123456"));
        sqlsession.commit();
        sqlsession.close();
    }

    @Test
    public void updateUserTest(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        mapper.updateUser(new User(5,"heheheheh","00000"));
        sqlsession.commit();
        sqlsession.close();
    }
    @Test
    public void deleteUserTest(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
        sqlsession.commit();
        sqlsession.close();
    }
}

参数说明：

• namespace:就是要实现接口的全限定名 这的话就是com.x1a0g.mapper.UserMapper
• id参数 ：就是接口中的方法名 比如 id=“deleteUser” 表示实现的接口中的方法名
• resultType：方法的返回值类型
• parameterType：方法的参数类型
• 当参数为int型的时候可以默认忽略

update user set name=#{name},pass=#{pass} where id=#{id}

在mybatis中 #{} 代表取值 对象中的属性可以直接拿到

注意：增删改 必须提交事务

万能的map参数

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

当接口中的方法出现多个参数的时候 可以考虑使用map，具体看下面的例子

    //登陆的方法
    User login(Map<String,Object> map);

usermapper实现

<select id="login" parameterType="map" resultType="com.x1a0g.entity.User">
    select * from mybatis.user where name=#{name} and pass= #{pass};
</select>

测试单元的写法

 //用登陆来测试map集合
    @Test
    public void loginTest(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        Map<String,Object> map = new HashMap<String, Object>();
        map.put("name","小哥");
        map.put("pass","admin");
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        User login = mapper.login(map);
        System.out.println(login);
        sqlsession.close();
    }

​ 我在查询时候的参数#{name} #{pass}都是map的key值

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

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

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

4. 多个参数用Map，或者注解！

模糊查询

有两种实现方式,第一种就是在前面去传%%

    //模糊查询
    List<User> queryByName(String name);

    <select id="queryByName" resultType="com.x1a0g.entity.User">
        select * from user where name like #{name};
    </select>

    //模糊查询
    @Test
    public void queryByName(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        List<User> userList = mapper.queryByName("%哥%");
        userList.forEach(user -> {System.out.println(user);});
        sqlsession.close();
    }

第二种是在SQL语句写死

select * from mybatis.user where name like "%"#{name}"%"

4、配置解析

核心配置文件

• mybatis-config.xml
• MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息

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

环境配置(environments)

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

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

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

<environments default="development">   <!--这个default="development"  表示默认选中development这套环境  我们可以改成test就是下面的-->
    
    //这是一套环境 名字是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"/>
                <property name="username" value="root"/>
                <property name="password" value="toor"/>
            </dataSource>
        </environment>
        //这是一套环境 名字是test
        <environment id="test">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/xzsc3"/>
                <property name="username" value="root"/>
                <property name="password" value="toor"/>
            </dataSource>
        </environment>
    </environments>

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

属性properties

注意在xml中各个标签之间是可以定义先后关系的

所以properties一定是在configuration中一定是在最前面

db.properties定义如下

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis
user=root
pass=toor

在mybaties-config.xml中的使用方式如下

<properties resource="db.properties" />
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${user}"/>
            <property name="password" value="${pass}"/>
        </dataSource>
    </environment>

当这个标签这么使用的时候 文件中定义的优先级一定是高于外面标签中的 比如 外面的密码写错，文件中是对的，那么依旧可以使用，反过来就不行了

类型别名（typeAliases）

• 类型别名是为 Java 类型设置一个短的名字。
• 存在的意义仅在于用来减少类完全限定名的冗余。

两种实现方式 （typeAliases在配置文件中的位置是在第三位，为之一定放对，没有setting的话直接放在前面就ok ）

1. 使用typeAliass来完成 ，好处是可以自己定义名字

   给com.x1a0g.entity.User 起别名

2. 第二种时使用包名来进行搜索，会把搜到的类的名字默认设置为类名且首字 母小写

   <typeAliases>
   	<package name="com.x1a0g.entity"/>
   </typeAliases>
   

   加入这时候我的entity包下有个User类 他的别名就是user

   加入这时候我非要用我自己的名字，可以加注解：

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

设置（setting）

settting相当重要，应该写在配置文件的第二位

日志这个必须记住

<!-- 开启驼峰映射 ，为自定义的SQL语句服务-->
<!--设置启用数据库字段下划线映射到java对象的驼峰式命名属性，默认为false-->  
<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

映射器（mappers）

官网有四种实现方式

方式一 【推荐使用】

<!-- 使用相对于类路径的资源引用 -->
    <mappers>
        <mapper resource="com/x1a0g/dao/UserMapper.xml"/>
    </mappers>

方式二

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

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

方式三

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

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

生命周期和作用域

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

SqlSessionFactoryBuilder

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

SqlSessionFactory：

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

SqlSession

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

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

5、解决实体类的属性名和字段名不一样的问题

简单的测试下问题

之前在写userMapper.xml的时候，通常是这么写的

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.x1a0g.dao.UserMapper">
    <select id="queryById" resultType="user">
        select * from user where id=#{id};
    </select>
</mapper>

假如说我们有一个场景，当我定义的实体类，并不是和数据库中的字段所对应的的，就会出现这种问题

public class User {
    private Integer id;
    private String username;
    private String password;
}  
/*
数据库的字段是   id   user   pass
输出结果：
User{id=1, username='null', password='null'}
*/

有个类型处理器是这么工作的

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

第一个解决办法 起别名

select id,name as username ,pwd as password from mybatis.user where id = #{id}

这么办是可以的 但是不太行

第二个解决办法 resultMap

专业名词 ：结果集映射

我们可以把数据库的字段和我们实体类的属性构建映射关系 例如  
id======》id
user===》username
pass====>password
左边是数据库的，右边是实体类的  那么就解决了这个问题  

代码如下

<mapper namespace="com.x1a0g.dao.UserMapper">
    <resultMap id="userMap" type="user" >
        <!--column数据库中的字段，property实体类中的属性-->
        <result column="id" property="id" />
        <result column="name" property="username" />
        <result column="pass" property="password" />
    </resultMap>

    <select id="queryById" resultMap="userMap">
        select * from user where id=#{id};
    </select>
</mapper>

• 其实原本对应的可以省略不写 ，只需要给不一样的建立映射关系即可

• resultMap 元素是 MyBatis 中最重要最强大的元素

• ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

• ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

• 如果世界总是这么简单就好了。（官网名言）

6、日志

日志工厂

STDOUT_LOGGING

这个东西是自带的标准日志输出形式 配置在mybatis的配置文件中方式如下

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

但是这种方式并不是经常用到的，常用的是log4j

log4j

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

使用步骤

1. 先导入依赖

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

2. 编辑配置文件

#将等级为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/x1a0g.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

简单使用

import org.apache.log4j.Logger;   //包千万别搞错

private static Logger logger = Logger.getLogger(UserMapperTes.class); //这在哪类用就写哪个

//日志级别
    logger.info("aaaaaaaaa");
    logger.error("bbbbbbbbbbbb");
    logger.debug("dddddddddddd");

7、分页

limit进行分页

limit本质其实是使用了sql语句实现了分页

1. 编写接口

    //limit分页,多练习map的用法
    List<User> getAllUserByLimit(Map<String,Integer> map);

2. 编写mapper.xml

    <resultMap id="userMap" type="user">

    </resultMap>    
    <select id="getAllUserByLimit" parameterType="map" resultMap="userMap">
        select * from user limit #{startIndex},#{pageSize}
    </select>

3. 测试

@Test
    public void limtTset(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList = mapper.getAllUserByLimit(map);
        userList.forEach(System.out::println);
        sqlsession.close();
    }

rowbounds进行分页

rowbounds本质是使用java代码的面向对象思想进行了分页

1. 编写接口

    //rowbounds进行分页
    List<User> getAllUserRows();  //拿到全部数据

2. 编写mapper.xml配置文件

<select id="getAllUserRows" resultMap="userMap">
    select * from user;
</select>

3. 测试

@Test
    public void rowBonds(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
//        UserMapper mapper = sqlsession.getMapper(UserMapper.class);
        RowBounds rowBounds = new RowBounds(0,2);//0是起始位置，2是页面大小
        List<User> allUserRows = sqlsession.selectList("com.x1a0g.dao.UserMapper.getAllUserRows",null,rowBounds);
        allUserRows.forEach(System.out::println);
        sqlsession.close();
    }

8、使用注解开发

面向接口编程

面向接口编程的根本原因：解耦，可拓展，提高复用，分层开发中、上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性好

使用注解进行开发

1. 编写接口，不用去写配置文件了

    //获取所有员工
    @Select("select * from user")
    List<User> getAllUser();

这种方式就是注解的方式来进行开发

这种方式的弊端就是必须严格按照数据库表的字段来设计实体类 ，如果有不一样的会出现这种情况

Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
==>  Preparing: select * from user 
==> Parameters: 
<==    Columns: id, name, pass
<==        Row: 1, 小哥, admin
<==        Row: 2, 大哥, admin1
<==        Row: 3, 二哥, admin2
<==        Row: 4, 三哥, admin2
<==      Total: 4
User{id=1, name='小哥', password='null'}   //和数据库对应不上的字段为null
User{id=2, name='大哥', password='null'}
User{id=3, name='二哥', password='null'}
User{id=4, name='三哥', password='null'}
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@23529fee]
Returned connection 592617454 to pool.

Process finished with exit code 0

使用注解的增删查改

1. 接口的配置

//根据id查询员工
    @Select("select * from user where id=#{uid}")
    User getUserById(@Param("uid") int id);

    //增加一个用户
    @Insert("inset into user(id,user,pass) values(#{id},#{user},#{password})")
    int addUser(User user);

    //修改一个用户
    @Update("update user set user=#{user},pass=#{password} where id=#{id}")
    int updateUser(User user);
    //删除一个用户
    @Delete("delete from user where id=#{uid}")
    int deleteUser(@Param("uid") int id);

2. 测试

public interface UserMapper {
    //获取所有员工
    @Select("select * from user")
    List<User> getAllUser();

    //根据id查询员工
    @Select("select * from user where id=#{uid}")
    User getUserById(@Param("uid") int id);

    //增加一个用户
    @Insert("insert into user(id,name,pass) values(#{id},#{name},#{password})")
    int addUser(User user);

    //修改一个用户
    @Update("update user set name=#{name},pass=#{password} where id=#{id}")
    int updateUser(User user);
    //删除一个用户
    @Delete("delete from user where id=#{uid}")
    int deleteUser(@Param("uid") int id);
}

【注意：我们必须要将接口注册绑定到我们的核心配置文件中！】

对于注解 @Param()注解

• 基本类型和string类型必须加上

• 引用用类型不需要加

• 多个参数时候使用 ：

  @Select("select * from user where id=#{uid} and name=#{uname}")
  User getUserById(@Param("uid") int id,@Param("uname")string name);
  

• 如果只有一个基本类型的话，可以忽略，但是建议都加上

• 在SQL中引用的就是这里的@Param()中设定的属性名

#{} ${}区别

#{} 是安全的 参数与编译的 就是 priperedstatment

${} 是不安全的，不会预编译的 就是 statment

9、lombock常用注解

使用前需要导入依赖

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

常用注解

@Data     //无参构造，get、set、toSring、hashcode、equals
@AllArgsConstructor   //有参
@NoArgsConstructor   //无参 
@ToString        //tostring
@EqualsAndHashCode   //hashcode

加入想实现方法重载 自己去实体类里头写就ok

10、复杂查询

多对一

拿欣知三期的来举例子

package com.xzsc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.io.Serializable;

/**
 * (Shop)实体类
 *
 * @author x1a0g
 * @since 2020-03-24 21:09:00
 */
@Data
public class Shop {
    private Integer shopId;
    private String shopName;
    private Double shopPrice;
    private Double shopVipPrice;
    private Integer shopFlag;
    private Integer adminId;
    private Integer shopNum;
    private Shoptype shoptype;
}

package com.xzsc.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * (Shoptype)实体类
 *
 * @author x1a0g
 * @since 2020-03-24 21:10:10
 */
@Data
public class Shoptype implements Serializable {
    private Integer shoptypeId;
    private String shopTypename;
    private List<Shop> shopList;
}

多个商品对应一个商品类型，所以把商品类型封装到了商品中

然后编写对应的mapper

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xzsc.dao.ShopMapper">
			<!-- 正常的给shop去映射结果集
			但是shop中封装的shoptype，就去在把shoptype封装一下
			关键字association
			
			-->
       <resultMap id="shopMap" type="shop">
       //id表示主键   其他用result
              <id column="shop_id" property="shopId" />
              <result column="shop_name" property="shopName" />
              <result column="shop_price" property="shopPrice" />
              <result column="shop_vip_price" property="shopVipPrice" />
              <result column="shop_flag" property="shopFlag" />
              <result column="admin_id" property="adminId" />
              <result column="shop_num" property="shopNum" />
    //这的property  是 shop中的对象名  javaType是shoptype这个对象的类型
<association property="shoptype" javaType="com.xzsc.entity.Shoptype">
     <id column="shopType_id" property="shoptypeId" />
     <result column="shop_typeName" property="shopTypename" />
</association>
       </resultMap>
<select id="queryById" resultMap="shopMap">
select
       s.shop_id,
       s.shop_name,
       s.shop_price,
       s.shop_vip_price,
       s.shop_flag,
       s.admin_id,
       s.shop_num ,
       st.shopType_id,
       st.shop_typeName
    from shop s , shoptype st
    where s.shop_shopType = st.shopType_id and shop_id=#{id}
</select>
</mapper>

一对多

就是一个商品类型包含多个商品 之国把他们这种关系映射出来

• 实体类还是上头的那俩

• xml配置如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xzsc.dao.ShoptypeMapper">
    <resultMap id="typeMap" type="shoptype">
        <id  column="shoptype_id" property="shoptypeId" />
        <result column="shop_typename" property="shopTypename" />
        <!--
		集合的关键字 collection
		ofType  和 javatype 
   		JavaType和ofType都是用来指定对象类型的
		但是JavaType是用来指定实体类中属性的类型，而ofType指定的是映射到list集合属性中		实体类的类型。
		-->
        <collection property="shopList" ofType="com.xzsc.entity.Shop" >
            <id column="shop_id" property="shopId" />
            <result column="shop_name" property="shopName" />
            <result column="shop_price" property="shopPrice" />
            <result column="shop_vip_price" property="shopVipPrice" />
            <result column="shop_flag" property="shopFlag" />
            <result column="admin_id" property="adminId" />
            <result column="shop_num" property="shopNum" />
        </collection>
    </resultMap>
    <select id="queryById" resultMap="typeMap">
            select
                s.shop_id,
                s.shop_name,
                s.shop_price,
                s.shop_vip_price,
                s.shop_flag,
                s.admin_id,
                s.shop_num ,
                st.shopType_id,
                st.shop_typeName
            from shoptype st , shop s
            where s.shop_shopType = st.shopType_id and shopType_id=#{tid}
    </select>
</mapper>

11、动态sql

就是可以进行拼接的语句 例子：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xin.dao.ShopMapper">
    <resultMap id="shopMap" type="com.xin.entity.Shop">
        <id column="shop_id" property="shopId" />
        <result column="shop_name" property="shopName" />
        <result column="shop_price" property="shopPrice" />
    </resultMap>
    
    <!--可以通过不同的参数来拼接语句,比如我要通过名字来查，通过flag来查-->
    <select id="queryShop" resultMap="shopMap" parameterType="map">
        select * from xzsc3.shop where 1=1
    <if test="name != null">
        and shop_name=#{name}
    </if>
        <if test="flag != null">
            and shop_flag=#{flag}
        </if>
        <if test="id != null">
            and admin_id=#{id}
        </if>
    </select>

</mapper>

public interface ShopMapper {
    //动态查询
    List<Shop> queryShop(Map map);
}

import com.xin.dao.ShopMapper;
import com.xin.entity.Shop;
import com.xin.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

public class ShopTest {

    @Test
    public void test(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
        HashMap hashMap = new HashMap();
//        hashMap.put("name","大料");
//        hashMap.put("id",1);
        hashMap.put("flag",0);
        List<Shop> shops = mapper.queryShop(hashMap);
        System.out.println(shops);
        sqlsession.close();
    }
}

动态sql拼接（choose (when, otherwise)）

拼接where条件

<select id="queryShop" resultMap="shopMap" parameterType="map">
select * from xzsc3.shop  
        <where>
            <choose>
                <when test="name != null">
                    shop_name=#{name}
                </when>
                <when test="flag != null">
                    and shop_flag=#{flag}
                </when>
                <otherwise>
                    and admin_id=#{id}
                </otherwise>
            </choose>
        </where>
</select>

其实where的作用就是当我choose的条件满足了，就会自动拼接一个where 条件到sql语句中

然后这边可以这么理解 choose 就是swicth when就是case otherwise就是default

和switch一样 当一种条件满足就不会再去进行下一个 然后where可以很智能的去匹配是否需要and

关于set的拼接（trim, (where, set)）

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

好比 sql注入时候的那些函数 sub if when 都用过

例子：

<update id="updateShop" parameterType="map">
    update shop
    <set>
        <if test="name != null">
            shop_name = #{name},
        </if>
        <if test="flag!=null">
            shop_flag=#{flag},
        </if>
    </set>
    where xzsc3.shop.shop_id=#{id}
</update>

set 会识别是否需要加逗号

下头的例子会移除所有 prefixOverrides 属性中指定的内容，并且插入 prefix 属性中指定的内容。

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

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

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

注意，我们覆盖了后缀值设置，并且自定义了前缀值

sql片段

<sql id="id-name">
        <if test="shopid!=null">
            shop_id=#{shopid}
        </if>
        <if test="name!= null">
            and shop_name = #{name}
        </if>
    </sql>

    <select id="queryByShop" resultMap="shopMap" parameterType="map">
        select * from xzsc3.shop
        <where>
            <include refid="id-name" />
        </where>
    </select>

这个就是sql片段，在mybatis中允许我们去定义这种公共代码块儿，我们只需要include引用即可，就好比我们的php中 include的文件包含一样，可以把它理解为sql包含

• 注意sql片段中不能出现where 标签
• 尽量一张表的信息来抽取sql片段，多表的就没有很大的意义

foreach循环

拿上星期循环删除购物车商品的例子来说，我要实现前端传过来的要删除的商品id产生拼接sql的情况：当时的sql是这么写的

select * from shopingcar where shopingCar_id in (46,47,48);

这个时候如果要执行的话，只能是使用循环来拼接，(46,47,48);这一段东西，那么这个时候foreach的出现解决了这个问题

<select id="getShopId" resultMap="shopMap" parameterType="map">
        select * from xzsc3.shopingcar
        <where>
            shopingCar_id in
            <foreach collection="sclist" item="sc"
                     open="(" close=")" separator=",">
                #{sc}
            </foreach>
        </where>
    </select>

• collection 传入的集合名字，这边由于穿的map 所以这里写的是map的key
• item 遍历的迭代项 就和 迭代userlist 的user一个道理
• open="(" 括号开始
• close=")" 括号结束
• separator="," 分割符为 ， 这个分割符也可以写 and or 这些个关键字
• #{sc} 最后集合中的内容

12 、mybatis缓存

什么是缓存

缓存的重要性是不言而喻的。 使用缓存， 我们可以避免频繁的与数据库进行交互， 尤其是在查询越多、缓存命中率越高的情况下， 使用缓存对性能的提高更明显

一级缓存（本地缓存）

mybatis是默认开启一级缓存的：一级缓存是对于sqlsession而言

• 同一个sqlsession对象，在参数和sql完全相同的情况下只执行一次sql语句（缓存不过期的情况）

例子：

@Test
    public void test01(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
        //同一个sqlsession的第一次查询
        Shop shop = mapper.queryById(1);
        System.out.println(shop);
        //同一个sqlsession的第二次查询
        Shop shop1 = mapper.queryById(1);
        System.out.println(shop1);
        System.out.println(shop==shop1);
        sqlsession.close();
    }
结果

/*

Created connection 1007880005.
==>  Preparing: select * from xzsc3.shop WHERE shop_id=? 
==> Parameters: 1(Integer)
<==    Columns: shop_id, shop_name, shop_shopType, shop_price, shop_vip_price, shop_flag, admin_id, shop_num
<==        Row: 1, 面包, 1, 20.00, 16.00, 1, 1, 0
<==      Total: 1
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
true
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@3c130745]
Returned connection 1007880005 to pool.


*/

• 可以看到sql只是执行了一次，第二次就不需要查询了，其实这东西和redis属实像啊
• 在同一个sqlsession中，mybatis会通过特定算法把执行的方法和参数生成为一个键，然后结果存为值，放在map中

这就是本地缓存 也叫一级缓存

一级缓存失效的情况

1. 查询不同的东西
2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存！
3. 查询不同的Mapper.xml
4. 手动清理缓存 sqlsession.clearCache();

二级缓存

• 二级缓存又叫全局缓存
• 基于namespace级别的，一个名称空间，对应一个二级缓存

使用方式

显示配置二级缓存

<!--显式的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>

再要使用二级缓存的mapper.xml中开启

<!--在当前Mapper.xml中使用二级缓存-->
<cache/>
也可以自定义参数
<cache eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>

例子

	 @Test
    public void test02(){
        SqlSession sqlsession = MybatisUtil.getSqlsession();
        ShopMapper mapper = sqlsession.getMapper(ShopMapper.class);
        Shop shop = mapper.queryById(1);
        System.out.println(shop);
        sqlsession.clearCache();
        sqlsession.close();
        System.out.println("==============开启第二个sqlsession的查询================");
        SqlSession sqlsession1 = MybatisUtil.getSqlsession();
        ShopMapper mapper1 = sqlsession1.getMapper(ShopMapper.class);
        Shop shop1 = mapper1.queryById(1);
        System.out.println(shop1);
        sqlsession1.close();
    }
    }

/*
结果：

Created connection 644345897.
==>  Preparing: select * from xzsc3.shop WHERE shop_id=? 
==> Parameters: 1(Integer)
<==    Columns: shop_id, shop_name, shop_shopType, shop_price, shop_vip_price, shop_flag, admin_id, shop_num
<==        Row: 1, 面包, 1, 20.00, 16.00, 1, 1, 0
<==      Total: 1
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@2667f029]
Returned connection 644345897 to pool.
==============开启第二个sqlsession的查询================
Cache Hit Ratio [com.cahce.dao.ShopMapper]: 0.5   //Cache中有了
Shop(shopId=1, shopName=面包, shopShoptype=1, shopPrice=20.0, shopVipPrice=16.0, shopFlag=1, adminId=1, shopNum=0)


*/

• 在一个mapper.xml中 当一级缓存关闭时候会提交添加到二级缓存中

缓存的执行流程

    <select id="queryById" resultType="shop" useCache="false">
    select * from xzsc3.shop
    <where>
    shop_id=#{sid}
    </where>
    </select>

useCache=“false” 关闭提交缓存

自定义缓存

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>

然后在mapper中指定使用ehcache缓存实现

<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

必须导入配置文件

13、mybatis逆向工程

mybatis框架需要 ： 实体类，自定义mapper接口，mapper.xml

逆向工程可以自动帮我们生成