2021-06-23-------------03mybatis

1、简介

是一个持久层框架，能够简单实现对数据层的访问

2、什么是持久化？

数据持久化

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

內存：断电即失

数据库（JDBC），io文件持久化

1.2为什么需要持久化？

持久化是动作

有一些东西不能丢掉

內存很贵

1.3持久层

Dao层、service层、Controller层

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

1.4、为什么需要mybatis?

• 将数据存入到数据库中

• JDBC太复杂了

• 框架：自动化

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

常见的数据层访问方式

• JDBC
  java原生的关系型数据库访问方式
  每次操作数据库都需要获取连接关闭连接，在大量访问数据库时，频繁的开关连接消耗性能。
  需要手动编写sql，有学习成本
  需要手动赋值sql参数/查询出的结果需要手动进行封装到bean
  sql语句写死在程序中，需要修改sql必须修改源文件

• Hibernate
  基于面向对象理念设计的DAO层框架，基本理念就是维护对象到表的映射关系，通过操作对象操作表中的数据，从而可以减少甚至杜绝sql的使用
  相对比较沉重，效率不好
  当涉及到比较复杂的查询时Hibernate的操作对象的方式用起来非常麻烦，甚至无法实现，只能用sql操作
  底层需要频繁的拼接sql，产生大量冗余的sql

• mybatis
  是一种半自动对象-表映射关系的DAO层框架，可以自动的进行对象的封装，但是sql仍然需要自己来写。
  结合了JDBC和Hibernate的优点，可以手写sql灵活实现数据访问，自动封装数据，减少繁杂代码。

2、第二个Mybatis程序:接口开发模式

接口的全路径名应为映射文件中声明的名称空间
接口中应该声明和映射文件中sql对应的id相同名称的方法
方法接收的参数应该和sql中接收的参数一致
方法的返回值应该和sql中声明的返回值类型一致

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

2.2、创建一个模块

编写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kuangshen</groupId>
    <artifactId>mybatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
    </modules>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
    </dependencies>

</project>

创建一个工具类

package com.kuangshen.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;

/**
 * @author pcy
 * @date 2021/2/10 - 12:40
 */
public class MybatisUtil {
    private static InputStream inputStream;
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "mybatis-config.xml";
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //我们可以通过sqlSessionFactory来获取sqlSession
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
    
}

创建实体类

package com.kuangshen.pojo;

/**
 * @author pcy
 * @date 2021/2/10 - 12:51
 */
public class User {
    private int id;
    private String name;
    private String pwd;
    public User() {
    }
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

创建接口dao

package com.kuangshen.dao;

import com.kuangshen.pojo.User;

import java.util.List;

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

创建一个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">
<!--绑定一个对应的dao/Mapper接口-->
<mapper namespace="com.kuangshen.dao.UserDao">
    <select id="getUserList" resultType="com.kuangshen.pojo.User">
    select * from user where id = #{id}
    </select>
</mapper>

测试

package com.kuangshen.dao;

import com.kuangshen.pojo.User;
import com.kuangshen.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;
public class UserDaoTest {
    @Test
    public void Test(){
        //获得sqlSession对象
        SqlSession session = MybatisUtil.getSqlSession();
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> list = mapper.getUserList();
        for (User users:list){
            System.out.println(users);
        }
    }
}

出现错误：
org.apache.ibatis.binding.BindingException: Type interface com.kuangshen.dao.UserDao is not known to the MapperRegistry.

原因：未注册

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

The error may exist in com/kuangshen/dao/UserMapper.xml

maven中的配置文件未配置或者导出

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

1、namespace

中的包名要和接口的名字要一致

2、select

选择、查询语句

• id：就是对应的接口中的方法名
• resultType：sql语句的返回值
• parameterType：sql传入的参数名

package com.kuangshen.dao;

import com.kuangshen.pojo.User;

import java.util.List;

public interface UserDao {
    //获取全部用户
    List<User> getUserList();
    //根据id传入参数
    User getId(int id);
    //插入一个用户
    int addUser(User user);
    //修改数据
    int updateUser(User user);
    //删除一个用户
    int deleteUser(int id);

}

<?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">
<!--绑定一个对应的dao/Mapper接口-->
<mapper namespace="com.kuangshen.dao.UserDao">
	   <select id="getUserList" resultType="com.kuangshen.pojo.User">
	    select * from user
	    </select>
	    <select id="getId" parameterType="int" resultType="com.kuangshen.pojo.User">
	        select * from user where id=#{id}
	    </select>
	    <insert id="addUser" parameterType="com.kuangshen.pojo.User">
	        insert into user(id,name,pwd) values(#{id},#{name},#{pwd})
	    </insert>
	    <update id="updateUser" parameterType="com.kuangshen.pojo.User">
	        update user set name=#{name},pwd=#{pwd} where id=#{id}
	    </update>
	    <delete id="deleteUser" parameterType="int">
	        delete from user where id=#{id}
	    </delete>
</mapper>

package com.kuangshen.dao;

import com.kuangshen.pojo.User;
import com.kuangshen.util.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void Test(){
        //获得sqlSession对象
        SqlSession session = MybatisUtil.getSqlSession();
        UserDao mapper = session.getMapper(UserDao.class);

        //方式二：
        //List<User> list1 = session.selectList("com.kuangshen.dao.UserDao.getUserList");
        List<User> list = mapper.getUserList();
        for (User users:list){
            System.out.println(users);
        }
        session.close();
    }
    @Test
    public void Test1(){
        SqlSession session = MybatisUtil.getSqlSession();
        UserDao mapper = session.getMapper(UserDao.class);
        User id = mapper.getId(1);
        System.out.println(id);
        session.close();
    }
    @Test
    public void Test2(){
        SqlSession session = MybatisUtil.getSqlSession();
        UserDao mapper = session.getMapper(UserDao.class);
        User user=new User();
        user.setId(3);
        user.setName("ww");
        user.setPwd("1234");
        int i = mapper.addUser(user);
        System.out.println(i);
        //必须提交事务，否则会添加不进数据库
        session.commit();
        session.close();
    }
    @Test
    public void test3(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        User user=new User(1,"li","1234");
        int i = mapper.updateUser(user);
        if (i>0){
            System.out.println("则修改数据");
        }
        System.out.println(i);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void test4(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        int i = mapper.deleteUser(1);
        if (i>0){
            System.out.println("删除了数据");
        }
        sqlSession.commit();
        sqlSession.close();

    }
}

3、分析错误

需要斜杠

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

4.值的传递

1、Map的传递值

可以通过对象 获取 Map传递值，在配置文件中 通过 #{} 或 ${}进行应用

2.对象传值

可以通过对象 获取 Map传递值，在配置文件中 通过 #{} 或 ${}进行应用在UserMapper.xml中配置：

3.单值传值

如果程序中只有一个参数需要传递给sql，则不需要封装到bean或map中，可以直接传
入。在sql中可以使用任意名称获取到这个参数，虽然名称可以任意，但通常仍然使用该
属性的名称，以便于阅读。

#{} 和 ${}区别

#{}会作为sql参数使用，替代sql中的？
有预编译机制，防止sql注入，效率高
字符串类型会自动两边拼单引号

insert into user values (null,#{name},55); --> insert into user values (null,'fff',55);
insert into user values (null,${name},55); --> insert into user values (null,fff,55);//sql语句错误

${}会原样直接拼接到sql上
没有预编译机制，不能防止sql注入，效率低
字符串类型会两边不会自动拼单引号

select * from user order by #{cname}; --> select * from user order by 'age';//sql语义错误
select * from user order by ${cname}; --> select * from user order by age;

总结
1.通常都使用#{},有预编译机制，可以防止sql注入，效率高
2.但如果传递的是 表名 列名 关键字 等必须直接拼接到sql中的内容时，使用${}，防止自动拼接单引号改变sql语义。

update的修改

update修改也可以使用之前的机制在配置文件中直接编写sql
但是update语句 的 set字句中 拼接哪些字段 是根据传入的值决定，此时可以通过
MyBatis提供的标签 实现判断 动态拼接update语句：

select的查询

insert操作

插入也可以使用之前的机制在配置文件中直接编写sql
但是insert语句 的参数和值的列表 拼接哪些字段 是根据传入的值决定，此时可以通过
MyBatis提供的标签 实现判断 动态拼接insert语句：

delete删除

delete删除也可以使用之前的机制在配置文件中直接编写sql
但是delete语句 的删除条件 拼接哪些字段 是根据传入的值决定，此时可以通过MyBatis
提供的标签 实现判断 动态拼接delete语句：

思考？

模糊查询怎么写？

java代码执行的时候，传递通配符

List<User> list = mapper.getUserLike("%l%");

在sql中拼接的时候使用通配符

<select id="getUserLike" resultType="com.kuangshen.pojo.User">
select * from user where name like"%"#{name}"%"
</select>

5、配置解析

在xml中标签必须遵循顺序

1、核心配置文件

mybatis-config.xml

2、我们可以通过properties来配置文件

编写一个properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mall
username=root
password=123456

在核心配置中引入

<properties resource="db.properties"/>

可以直接引入配置文件

可以在其中增加一些属性

外部配置文件优先级大于内部配置文件

3、配置环境

<?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">
<!--如果想用该环境就把default里面改掉-->
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mall"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </dataSource>
    
    </environment>
    <environment id="test">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mall"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </dataSource>
    </environment>
</environments>
</web-app>

4、类型别名

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

<typeAliases>
    <!--会使用实体类的小写作为别名-->
    <package name="com.kuangshen.pojo"/>
</typeAliases>

在实体类比较少的时候使用第一种

第一种可以DIY（自定义），第二种不可以，如果非要改需要在实体类中加注解

@Alias("User")
public class User {

5、settings

6、其他配置

7、映射器

第一种：

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

方式二：

<mapper class="com.kuangshen.dao.UserMapper"/>

接口和他的Mapper配置文件必须同名

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

方式三：

<package name="com.kuangshen.dao"/>

接口和他的Mapper配置文件必须同名

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

8、生命周期和作用域

至关重要，因为会导致并发问题

SqlSessionFactoryBuilder：

• 一旦创建就不需要了
• 局部变量

SqlSessionFactory：

• 数据库连接池
• 一旦创建就必须一直存在

SqlSession：

• 数据库连接了一个请求
• 连接池的一个请求
• 线程关闭
• 不是线程安全的

6、ResultMap

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

结果集映射

id	name	pwd
id	name	password    

<resultMap id="UserMap" type="User">
    <!--<result column="id" property="id"/>
    <result column="name" property="name"/>-->
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserList" resultMap="UserMap">
select * from user
</select>

7、日志

1、日志工厂

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

曾经：sout、debug

现在：日志工厂

在mybatis中具体实现那个日志输出，用setting实现

标准的日志实现：

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

2、log4j

什么是Log4j

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等

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

• 通过定义每一条日志信息的级别

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

• 先导入包

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

配置log4j.properties

# DEBUG < INFO < WARN < ERROR < FATAL
# Global logging configuration
log4j.rootLogger=DEBUG, console,file
# My logging configuration...
#log4j.logger.com.tocersoft.school=DEBUG
#log4j.logger.net.sf.hibernate.cache=debug
## Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=../logs/iask.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}  %l  %m%n

log4j.logger.org.apache.activemq.spring=WARN
#see cache info
log4j.logger.org.hibernate.cache=info

配置log4j的实现

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

3.简单使用

要使用log4j的类中导入包

日志对象，参数为当前类的class

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

日志级别

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

8、分页

为什么要分页？
减少数据的处理量

使用limit分页

SELECT * from user LIMIT 0,2;

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

@Test
public void Test1(){
    //获得sqlSession对象
    SqlSession session = MybatisUtil.getSqlSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    //方式二：
    //List<User> list1 = session.selectList("com.kuangshen.dao.UserMapper.getUserList");
    List<User> list = mapper.getUserLimit(map);
    for (User users:list){
        System.out.println(users);
    }
    session.close();
}

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

9.使用注解开发

什么是面向接口编程？

定义与实现的分离

接口反映了系统设计人员对系统的抽象理解

9.2使用注解开发

public interface UserMapper {

    @Select("select * from user")
    //获取全部用户
    List<User> getUserList();

}

<mappers>
    <!--<mapper resource="com/kuangshen/dao/UserMapper.xml"/>-->
    <mapper class="com.kuangshen.dao.UserMapper"/>
</mappers>

public class UserDaoTest {
    @Test
    public void Test(){
        //获得sqlSession对象
        SqlSession session = MybatisUtil.getSqlSession();
        UserMapper mapper = session.getMapper(UserMapper.class);

        //方式二：
        //List<User> list1 = session.selectList("com.kuangshen.dao.UserMapper.getUserList");
        List<User> list = mapper.getUserList();
        for (User users:list){
            System.out.println(users);
        }
        session.close();
    }

}

核心：使用反射实现

底层也是使用反射，动态代理
1、注解在接口上实现

2、再在核心文件上绑定接口

3、测试

我们必须将接口注册绑定到我们的核心配置文件

关于@Param()注解

基本类型的参数或者String类型，需要加上

引用类型不需要加

如果只有一个基本类型的话，可以忽略

在sql中引用的就是我们这里的@Param（）中设定的属性名

10、LomBok

java library

plugs

build tools

使用步骤：

• 在idea中安装插件
• 在项目中导入jar包
• 在实体类上加注解

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

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

Lombok config system

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

无参，有参

@AllArgsConstructor
@NoArgsConstructor

11、一对一

<resultMap type="cn.tedu.domain.Grade" id="rm01">
	<id column="gid" property="id"/>
	<result column="gname" property="name"/>
	<association property="room" javaType="com.pcy.domain.Room">
		<id column="rid" property="id"/>
		<result column="rname" property="name"/>
	</association>
</resultMap>
<select id="o2o1" resultMap="rm01" >
	select grade.id as gid,grade.name as gname,room.id as rid,room.name as rname from grade 
	inner join room on grade.rid = room.id;
</select>

12、多对一

多个学生对应一个老师？

对于学生而言关联，多个学生关联一个老师，多对一

对于老师而言，集合，一个老师有很多学生，一对多

<?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.kuangshen.dao.StudentMapper">
	   
	   <resultMap type="com.pcy.domain.Dept" id="rm01">
			<id column="did" property="id"/>
			<result column="dname" property="name"/>
			<collection property="list" ofType="cn.tedu.domain.Emp">
					<id column="eid" property="id"/>
					<result column="ename" property="name"/>
			</collection>
		</resultMap>

多对一查询：

13、多对多查询

<resultMap type="cn.tedu.domain.Teacher" id="rm01">
	<id column="tid" property="id"/>
	<result column="tname" property="name"/>
	<collection property="stuList" ofType="cn.tedu.domain.Stu">
		<id column="sid" property="id"/>
		<result column="sname" property="name"/>
	</collection>
</resultMap>

sql复用

如果某段sql语句的片段在映射文件中重复出现，可以将其单独配置为一个引用，从
而在需要时直接引用，减少配置量

缓存机制

缓存机制可以减轻数据库的压力，原理是在第一查询时，将查询结果缓存起来，之后再查询同样的sql，不是真的去查询数据库，而是直接返回缓存中的结果。缓存可以降低数据库的压力，但同时可能无法得到最新的结果数据。

数据库缓存的实现

1. 通过第三方工具实现缓存
   Redis内存数据库 - 可以实现缓存
2. 通过MyBatis提供的缓存机制来实现缓存：
   • 一级缓存：（默认开启）
     缓存只在一个事务中有效，即同一个事务中先后执行多次同一个查询，只在第一次真正去查库，并将结果缓存，之后的查询都直接获取缓存中的数据。如果是不同的事务，则缓存是隔离的。
   • 二级缓存：
     缓存在全局有效，一个事务查询一个sql得到结果，会被缓存起来，之后只要缓存未被清除，则其他事务如果查询同一个sql，得到的将会是之前缓存的结果。二级缓存作用范围大，作用时间长，可能造成的危害也更大，所以在开发中一般很少启用Mybatis的二级缓存。
     
     如何配置二级缓存？
     在sqlMapConfig.xml配置：
     
     在映射文件中配置：
     

想要被二级缓存缓存的bean必须实现序列化接口