mybatis框架

MyBatis 是一款优秀的持久层Dao框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Java实体类)映射成数据库中的记录.

3.为什么使用mybatis框架

可以简化jdbc的操作以及占位符赋值以及查询结果集的封装。

二.如何使用mybatis框架

1.引入mybatis和mysql的jar包（在pom.xml页面）

<!--    导入mybatis框架的包-->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>

<!--导入连接数据库的包-->
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

2.创建mybatis的配置文件

在resources目录下创建mybatis.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" />
            <!--数据源的配置:name的值固定  value的值要根据客户自己修改-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver" />
                <property name="url"    value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>

     <!--注册映射文件-->
    <mappers>
        <!--resource:引用资源文中的映射文件 url:网络上的映射文件-->
         <mapper resource="mapper/UserMapper.xml" />
    </mappers>
</configuration>

3.创建指定的数据库和表

DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user`  (
  `userid` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  `realname` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
  PRIMARY KEY (`userid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES (1, 'admin', '管理员');
INSERT INTO `tb_user` VALUES (2, 'lm', '黎明');
INSERT INTO `tb_user` VALUES (3, 'ldh', '刘德华');
INSERT INTO `tb_user` VALUES (4, 'zxy', '张学友');
INSERT INTO `tb_user` VALUES (5, 'gfc', '郭富城');

4.创建实体类

public class User {
    private int userid;
    private String username;
    private String realname;
    //get和set方法及构造函数、toString请自行创建
}

5.创建mybatis和数据库的映射文件

在resources目录下新建mapper目录,在mapper目录下新建UserMapper.xml文件,导入以下代码(在该页面中操作增删改查)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace:命名空间
       可以随便起名，但是后期我们要求命名空间的值必须和所对应的dao相同
-->
<mapper namespace="mjl.user">
    <!--查询 根据id查询用户信息
          select标签用于查询的标签
             id:标签的唯一标识
             resultType: 定义返回的类型 把sql查询的结果封装到哪个实体类钟
         #{id}===表示占位符等价于?  这是mybatis框架的语法
    -->
    <select id="findById" resultType="commjlentity.User">
        select * from tb_user where userid=#{id}
    </select>

     <select id="findAll" resultType="u">
        select * from tb_user
    </select>

    <insert id="insert" parameterType="u">
        insert into tb_user values (null,#{username},#{password})
    </insert>

    <update id="update" parameterType="u">
        update tb_user set username=#{username},password=#{password} where id=#{id}
    </update>

    <delete id="delete" parameterType="u">
        delete from tb_user where id=#{id}
    </delete>
</mapper>

ps:配置好映射文件后记得把映射文件注册到配置文件上（在mybatis.xml页面，上方代码已配置）

 <!--注册映射文件-->
    <mappers>
        <!--resource:引用资源文中的映射文件 url:网络上的映射文件-->
         <mapper resource="mapper/UserMapper.xml" />
    </mappers>

6. 测试mybatis

package com.wt.test;


import com.wt.entity.User;
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 org.junit.Test;

import java.io.Reader;
import java.util.List;

public class Text01 {
    //查询单个
    @Test
    public void test01() throws Exception{
         //1.读取mybatis配置文件的内容----未来不需要写tomcat 解析配置文件
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
         //2. 获取SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
         //3. 获取SqlSession对象----封装了对数据库操作的各种方法
        SqlSession session = factory.openSession();
        User user = new User();
        user.setId(2);
        Object o = session.selectOne("wt.user.findById", user);
        System.out.println(o);
        session.close();
    }
    //查询所有
    @Test
    public void test02() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        List<User> user = session.selectList("wt.user.findAll");
        System.out.println(user);
        session.close();
    }
    //增加
    @Test
    public void test03() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        User user = new User();
        user.setUsername("白云");
        user.setPassword("黑土");
        int row = session.insert("wt.user.insert", user);
        System.out.println(row);
        session.commit();
        session.close();
    }
    //修改
    @Test
    public void test04() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        User user = new User(9,"黑土地","黄土地");
        int row = session.update("wt.user.update", user);
        System.out.println(row);
        session.commit();
        session.close();
    }
    //删除
    @Test
    public void test05() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        User user = new User();
        user.setId(9);
        int row = session.delete("wt.user.delete", user);
        System.out.println(row);
        session.commit();
        session.close();
    }
}

三.优化mybatis.xml

1.lombok插件

它可以帮你生成实体类的get和set方法而且可以帮你生成构造方法。重写toString方法

(1) idea安装lombok插件

(2) pom.xml工程中引入lombok依赖

  <!--lombok的依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>

@Data //set和get方法以及toString方法
@NoArgsConstructor //无参构造方法
@AllArgsConstructor //所有参数的构造方法
public class User {
    private int userid;
    private String username;
    private String realname;
}

2.起别名

(1)mybatis.xml配置文件

    <typeAliases>
        <!--单独为某个实体类起别名 -->
         <typeAlias type="com.wt.entity.User" alias="u"/>
        <!--为指定包下的实体类起别名该别名就是实体类名-->
         <package name="com.wt.entity"/>
    </typeAliases>

3.添加sql日志

(1) 在pom.xml页面添加日志的jar

	<!--log4f-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

(2) 添加日志的文件配置--log4j.properties(必须添加)

在resources目录下创建log4j.properties页面

//简写版
log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

//详细版
#将等级为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=D:/mjl/log/mjl.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

4.解决数据库列名和实体类的属性名不一致问题

问题:当我们实体类中定义的属性名和数据库列名有所不同时，查询该列时全部返回一个null,或者某个列没有值

可以有两种解决办法:

（1）为查询的列起别名，而别名和属性名一致。

 <!--根据id查询学生信息-->
    <select id="findOne" resultType="com.wt.entity.User">
        select user_id id,user_name name,user_age age from tb_user where user_id=#{id}
    </select>

(2) 使用resultMap完成列和属性之间的映射关系

 <resultMap id="StuMapper" type="com.ykq.entity.Student">
         <!--主键的映射关系 column:列名 property:属性名-->
         <id column="stu_id" property="id"/>
         <!--普通列的映射关系-->
         <result column="stu_name" property="name"/>
         <result column="stu_age" property="age"/>
    </resultMap>

 <!--resultType和ResultMap二者只能用一个-->
    <select id="findOne" resultMap="StuMapper">
        select * from tb_stu where stu_id=#{id}
    </select>

ps:如果列名和属性名有些一致的，可以在resultMap中不写映射关系

四.通过dao和映射文件的关联来完成操作---企业开发模式

思考: 我们之前使用SqlSession封装的一些方法可以完成crud操作，但是SqlSession封装的方法，传递的参数statement, 传递占位符的参数只能传递一个。而且它的方法名称都是固定。而真实在开发环境下我们不使用SqlSession封装的方法，而是习惯自己定义方法，自己调用自己的方法。

1.创建一个dao接口并定义自己需要的方法

package com.wt.dao;

import com.wt.entity.Student;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface StudentDao {

    /**
     * 查询所有
     * @return
     */
    public List<Student> findAll(@Param("name")String name,@Param("age")int age);

    /**
     * 增加
     * @return
     */
    public int insert(Student student);
    /**
     * 修改
     * @return
     */
    public int update(Student student);
       /**
     * 删除
     * @return
     */
    public int delete(int id);
}

2.创建映射文件

<?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 namespace="com.ykq.dao.UserDao">
    <select id="findAll" resultType="com.ykq.entity.User">
        select * from tb_user
    </select>
</mapper>

ps:注意: namespace必须和dao接口一样，而且标签的id必须和你接口的方法名一样

3.测试（连接dao接口进行增删改查）

package com.wt.test;

import com.wt.dao.UserDao;
import com.wt.entity.User;
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 org.junit.Test;

import java.io.Reader;
import java.util.List;

public class Text01 {
    //查询所有
    @Test
    public void test01() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        UserDao userDao = session.getMapper(UserDao.class);
        List<User> list = userDao.findAll();
        System.out.println(list);

        session.close();
    }
    //增加
    @Test
    public void test02() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        UserDao u = session.getMapper(UserDao.class);
        User user = new User();
        user.setName("李华");
        user.setEmail("31646545@qq.com");
        System.out.println("前"+user);
        int row = u.insert(user);
        System.out.println("后"+user);
        System.out.println(row);
        session.commit();
        session.close();
    }
    //删除
    @Test
    public void test03() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        User user = new User(3,"张飞","45451325@qq.com");
        int ro = session.update("wt.user.update", user);
        System.out.println(ro);
        session.commit();
        session.close();
    }
    //修改
    @Test
    public void test04() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session =factory.openSession();
        User user = new User();
        user.setId(5);
        int row = session.delete("wt.user.delete", user);
        System.out.println(row);
        session.commit();
        session.close();
    }
    //查询单个
    @Test
    public void test05() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        UserDao userDao = session.getMapper(UserDao.class);
        User row = userDao.findById(3);
        System.out.println(row);
        session.close();
    }
}

4.常见bug

(1) namespace和接口名不对应。 xml文件没有注册到mybatis配置文件中

(2）映射文件中的标签id和接口中方法名不对应

5.传递多个参数

我们在dao接口中某些方法可能需要传递多个参数，譬如: 登录（username,password),我们需要在参数处使用@Param()为参数起名。

6.添加时如何返回递增的主键值

在映射文件的添加中加入:

useGeneratedKeys:设置使用生成的主键(true 或 false)
keyProperty: 赋值给哪个属性

 <!--添加用户
          useGeneratedKeys:设置使用生成的主键
          keyProperty: 赋值给哪个属性
    -->
    <insert id="addUser" parameterType="com.ykq.entity.User"
            useGeneratedKeys="true" keyProperty="id">
          insert into tb_user values(null,#{username},#{realname})
    </insert>

五.动态sql

1.什么是动态sql

根据参数的值，判断sql条件

name!=null address
select * from 表名 where name=#{name} and address=#{address}
name==null
select * from 表名.

2.为什么要使用动态sql

当中实际应用中，用户通过搜索框输入几个参数，使用传入的参数进行特定查询，如果不输入参数，则查询所有

3.mybatis中的动态标签有哪些

4.条件判断

(1) if标签--单条件判断

//写在接口类中
 //如果name不为null则按照name查询 如果为null则查询所有
    public List<Account> findByCondition(@Param("name")String name,@Param("money") Double money);

(2) choose标签多条件分支判断

<select id="findByCondition02" resultType="com.ykq.entity.Account">
        select * from account where 1=1
        <choose>
             <when test="name!=null and name!=''">
                 and  name=#{name}
             </when>
            <when test="money!=null">
                and  money=#{money}
            </when>
            <otherwise>
                and isdeleted=0
            </otherwise>
        </choose>
    </select>

(3) where 标签

我们观察到上面的sql都加了 where 1=1 ，如果不使用where 1=1 那么你的动态sql可能会出错。我们能不能不加where 1=1呢! 可以那么我们就可以使用where标签，作用:可以自动为你添加where关键字，并且可以帮你去除第一个and |or

 <select id="findByCondition" resultType="com.ykq.entity.Account">
        select * from account
        <where>
            <if test="name!=null and name!=''">
                 and  name=#{name}
            </if>
            <if test="money!=null">
                 and  money=#{money}
            </if>
        </where>
    </select>

(4) set 标签（修改）

set:可以帮我们生成关键字，并且可以去除最后一个逗号

<update id="update">
        update tb_user
        <set>
            <if test="name!=null and name!=''">
                username=#{name},
            </if>
            <if test="password!=null and password!=''">
                password=#{password}
            </if>
        </set>
        where id =#{id}
</update>

(5) foreach标签

循环标签，多用于批量添加、删除、查询

a.查询：

<!--    xml文件中-->
<select id="findByIds" resultMap="UserMap">
        select * from tb_user where id in

        <foreach collection="array" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>


</select>

b.添加

<insert id="inserts">
        insert into tb_user(username,password) values
        <foreach collection="list" item="acc" separator=",">
            (#{acc.name},#{acc.password})
        </foreach>
    </insert>

c.删除

<delete id="deletes">
        delete from tb_user
        <foreach collection="array" item="id" open="where id in (" close=")" separator=",">
            #{id}
        </foreach>
    </delete>

5. sql片段

在执行查询语句时不建议大家使用select *, 建议大家把查询的列写出。

<!--    定义sql片段,指定要查询的列名-->
<sql id="baseColumn">
        id,username,password
</sql>



 <select id="tjcx" resultMap="UserMap">
       select 
        <include refid="baseColumn" />
        from tb_user where id in

        <foreach collection="array" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>

</select>

6.mybatis映射文件处理特殊字符

当我们在进行范围查询时，会运用一些特殊符号，那些符号需要经过转义字符才能使用，解决此类问题有两种方法:

         第一种：转义标签   <
         第二种: <![CDATA[sql]]>

ps:在第二种情况下无法使用自定义的sql片段

<!--    条件查询-->

    方法一
    <select id="tjcx" resultMap="UserMap">
    select
    <include refid="baseColumn" />
    from tb_user where id>#{min} and id &lt; #{max}
    </select>

    方法二
    <select id="tjcx" resultMap="UserMap">
        <![CDATA[select * from tb_user where id>#{min} and id< #{max}]]>
    </select>

7. mybatis完成模糊查询

如 select * from 表名 where 列名 like '%a%'

a. 使用字符串函数完成拼接 concat

<!--    模糊查询-->
    <select id="mhcx" resultMap="UserMap">
        select * from tb_user where username like concat('%',#{name},'%')
    </select>

b. 使用${}

<select id="findByLike" resultMap="UserMap">
        select * from account where name like '%${name}%'
    </select>

通过观察: 发现使用${}实际上是字符串拼接，它不能防止sql注入，而#{}它是预编译，它可以防止sql注入问题，#{}实际使用的PreparedStatement

六. 查询

1.联表查询

(1) 多对一

多对一：从多的一方来查询少的一方。

学生表

班级表

通过该语句查询:select * from tb_stu t join tb_class s on t.stu_id=s.cid where stu_id=1;

实体类:

a.班级表实体类

package com.wt.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Claszz {
    private int cid;
    private String cname;
}

b.学生表实体类

package com.wt.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private int age;
    private String sex;
    private int classId;

    //学生所属的班级
    private Claszz claszz;

}

c.xml代码

方法一：

association: 表示一的一方
property: 它表示属性名
javaType: 该属性名对应的数据类型

 <resultMap id="BaseMap" type="com.wt.entity.Student">
        <id column="stu_id" property="id" />
        <result column="stu_name" property="name" />
        <result column="stu_age" property="age" />
        <result column="sex" property="sex" />
        <result column="class_id" property="classId" />

        <association property="claszz" javaType="com.wt.entity.Claszz">
            <id column="cid" property="cid" />
            <result column="cname" property="cname" />
        </association>

    </resultMap>

    <sql id="BaseSql" >
        stu_id,stu_name,stu_age,sex,class_id
    </sql>


    <select id="findById" resultMap="BaseMap">
        select *
        from tb_stu t join tb_class c on t.class_id=c.cid where t.stu_id=#{id};
    </select>

方法二：


    <select id="findById" resultType="java.util.Map">
        select <include refid="aa"/> from tb_stu t join tb_class c on t.class_id=c.id where t.stu_id=#{id}
    </select>

2.分页查询

select * from tb_stu limit 0,5

select * from 表名 [where 条件] limit (page-1) * pageSize, pageSize;

page: 当前页码
pageSize: 每页显示的条数。

(1)在pom.xml文件中引入pageHelper的jar包

<!--引入pageHelper-->
<dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.3.0</version>
        </dependency>

<select id="selcAll" resultMap="BaseResultMap">
  select * from tb_stu
</select>

(2) 在mybatis.xml文件中设置pageHelper 拦截器

在执行sql之前，要经过拦截器，该拦截器就会在sql后面拼接上limit (page-1) * pageSize, pageSize，然后再执行查询操作

(3) 使用pageHelper

public void test02() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        StudentMapper studentMapper = session.getMapper(StudentMapper.class);

        PageHelper.startPage(1,5);
        List<Student> list = studentMapper.selcAll();
        PageInfo<Student> stringPageInfo = new PageInfo<Student>(list);
        System.out.println(stringPageInfo);
        System.out.println("总条数:"+stringPageInfo.getTotal());
        System.out.println("总页数:"+stringPageInfo.getPages());
        System.out.println("当前页数据:"+stringPageInfo.getList());
        session.close();
    }

七. mybatis代码生成器----generator

作用: 根据表自动生成实体类，和dao和xml映射文件。及简单的删改查代码。

http://mybatis.org/generator/

该网址内有详细教程

1.在pom.xml引入mybaits-generator的依赖jar包

<!--       引入 mybatis-generator-core-->
<dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.4.0</version>
        </dependency>

2.创建generator.xml配置文件并修改配置

targePackage:包名
targetProject:包的存储路径
schema:数据库名
tableName:表名
domainObjectName:对应的实体类

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<!--    将location改为本地mysql.jar包所在路径-->
<generatorConfiguration>
    <classPathEntry location="D:\qy151\repMaven\mysql\mysql-connector-java\8.0.28\mysql-connector-java-8.0.28.jar" />


    <context id="DB2Tables" targetRuntime="MyBatis3">
<!--        若不添加commentSenerator则会自动生成注释-->
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
<!--数据库的配置信息-->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai"
                        userId="root"
                        password="root">
        </jdbcConnection>

        <javaTypeResolver >
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

<!--        实体类-->
<!--        targePackage:包名-->
<!--        targetProject:包的存储路径-->
        <javaModelGenerator targetPackage="com.wt.entity" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

<!--        创建mapper包-->
        <sqlMapGenerator targetPackage="mapper"  targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
<!--        创建dao包-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.wt.dao"  targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>

<!--        schema:数据库名-->
<!--        tableName:表名-->
<!--        domainObjectName:对应的实体类-->
        <table schema="mybatis" tableName="tb_stu" domainObjectName="Student"
               enableSelectByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableCountByExample="false">

        </table>


    </context>
</generatorConfiguration>

3.运行配置文件进行自动生成

File configFile = new File("generator.xml ");该行代码中的路径要与自行创建的配置文件名字相同

@Test
    public void test01() throws Exception{
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("generator.xml ");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
    }

八.mybatis的缓存问题

1.什么是缓存

缓存是存在于==内存中==的临时数据。

mysql数据库中的数据存在----表--->磁盘上。查询---程序IO读取磁盘的数据---添加--io向磁盘添加数据。

2.使用缓存的好处

使用缓存减少和数据库的交互次数，提高执行效率。

3.什么样的数据适合放入缓存

经常查询并且不经常改变的；数据的正确与否对最终结果影响不大的；

4. 什么样的数据不适合放入缓存

经常改变的数据；数据的正确与否对最终结果影响很大的；---数据安全性要求不高。例如：商品的库存，银行的汇率，股市的牌价；

5. mybatis它也支持缓存

mybatis支持两种缓存

（1）一级缓存----基于SqlSession级别的缓存。默认一级缓存是开启的，不能关闭。

（2）二级缓存--基于SqlSessionFactory级别的缓存，它可以做到多个SqlSession共享数据。默认它是关闭。需要手动开启。

(1) 一级缓存

一级缓存默认存储在session中，session不关闭则再次查询则只会在缓存内查询，不会再前往数据库查询

@Test
    public void test03() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        StudentMapper studentMapper = session.getMapper(StudentMapper.class);
        Student student = studentMapper.selectByPrimaryKey(2);
        System.out.println(student);

        Student student2 = studentMapper.selectByPrimaryKey(2);
        System.out.println(student2);

    }

session关闭时会清空缓存，需要再次前往数据库查询

(2) 二级缓存

a.开启二级缓存

<settings>

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

b.在映射文件中使用二级缓存

<cache/>

c.实体类一定要实现序列化接口

不给实体类添加序列化接口则会报此错误：

添加后则会正常运行：

 @Test
    public void test03() throws Exception{
        Reader reader = Resources.getResourceAsReader("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession session = factory.openSession();
        StudentMapper studentMapper = session.getMapper(StudentMapper.class);
        Student student = studentMapper.selectByPrimaryKey(2);
        System.out.println(student);
        session.close();

        SqlSession session1 = factory.openSession();
        StudentMapper mapper = session1.getMapper(StudentMapper.class);
        Student student1 = mapper.selectByPrimaryKey(2);
        System.out.println(student1);

    }