mybatis-续中续

日志工厂

如果数据库操作，出现了异常，需要记性排错，日志就是最好的助手！
曾经：sout debug
现在：日志工厂

• SLF4J
• LOG4J（3.5.9 起废弃）【掌握】
• LOG4J2 【掌握】
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING
  具体使用哪一个，在mybatis中设置决定
  STDOUT_LOGGING标准日志输出

STDOUT_LOGGING标准日志输出

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <!--  引入属性  -->
    <properties resource="db.properties"/>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!--  给实体类取别名  -->
    <typeAliases>
        <typeAlias type="com.depressiom.pojo.BlogAdmin" alias="admin" />
    </typeAliases>
    <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>
        <package name="com.depressiom.dao"/>
    </mappers>
</configuration>

LOG4J 日志实现

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；
• 我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

导入包

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

编写log4j.properties 配置文件

# 将登记为DEBUG的日志信息输出到console和File这两个目的地，
log4j.rootLogger=DEBUG, console, file

#console的定义，控制台输出的相关设置
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

# file 的定义 文件输出的相关设置
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/my.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.MaxBackupIndex=10
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

配置日志实现

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

LOG4J 简单使用

在要使用的类中导入log4j的包 并

package com.depressiom.dao;

import com.depressiom.dao.BlogAdminMapper;
import com.depressiom.pojo.BlogAdmin;
import com.depressiom.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;

import java.util.*;

/**
 * @ClassName BlogAdminMapperTest
 * @Description 测试
 * @Date 2022/11/28
 * @Author depressiom
 */
public class BlogAdminMapperTest {
    static Logger logger = Logger.getLogger(BlogAdminMapperTest.class);
    @Test
    public void test(){
        // 1. 获取 SqlSession 对象
        SqlSession sqlSession = MybatisUtils.getsqlSession();
        logger.info("info:进入testblogAdmin");
        // 2. 执行SQL 方式一 getMapper
        // 2.1 通过类对象获取mappler
        BlogAdminMapper adminDao =  sqlSession.getMapper(BlogAdminMapper.class);
        BlogAdmin blogAdmin = adminDao.getAdminId(1);

        System.out.println(blogAdmin);

        // 3. 关闭SqlSession
        sqlSession.close();
    }

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



}

日志文件

分页

使用limit 分页

-- 语法 
select * from blog_admin limit startIndex,pageSize

select * from blog_admin limit 3; -- [0,n]

mybatis 进行分页

接口

    // limit 查询
    List<BlogAdmin> getAdminLimit(Map<String,Integer> map);

mapper.xml

 <select id="getAdminLimit" parameterType="map" resultType="admin">
    select * from blog_admin limit #{startIndex},#{pageSize};
    </select>

测试

 @Test
    public void testLimit(){

        SqlSession sqlSession = MybatisUtils.getsqlSession();

        BlogAdminMapper mapper =  sqlSession.getMapper(BlogAdminMapper.class);
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("startIndex",0);
        map.put("pageSize",3);
        List<BlogAdmin> blogAdmins= mapper.getAdminLimit(map);
        for (BlogAdmin blogAdmin : blogAdmins) {
            System.out.println(blogAdmin);
        }

        sqlSession.close();
    }

RowBounds 分页（了解）

接口

// RowBounds 查询
List<BlogAdmin> getAdminRowBounds();

xml

<select id="getAdminRowBounds"  resultMap="mapAdmin">
        select * from blog_admin
    </select>

测试

第一次查询

RowBounds分页查询

 @Test
    public void testRowBounds() {
        SqlSession sqlSession = MybatisUtils.getsqlSession();

        //通过RowBounds实现
        RowBounds rowBounds = new RowBounds(1,2);

        //通过java代码层面实现分页
        List<BlogAdmin> blogAdmins = sqlSession.selectList("com.depressiom.dao.BlogAdminMapper.getAdminRowBounds",null,rowBounds);
        for (BlogAdmin admin : blogAdmins) {
            System.out.println(admin);
        }

        sqlSession.close();
    }

分页插件

MyBatis 分页插件 PageHelper

使用注解开发

面象接口编程

• 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程

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

• 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；

• 而各个对象之前的协作关系则成为系统设计的关键，小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容，面向接口编程就是指按照这种思想来编程。关于接口的理解

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

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

• 接口应有两类：

  • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class);
  • 第二类是对一个个体某一方面的抽象，即形成一个抽象面(interface)；

• 一个体有可能有多个抽象面，抽象体与抽象面是有区别的

三个面向区别

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

注解开发

对于像 BlogMapper 这样的映射器类来说，还有另一种方法来完成语句映射。 它们映射的语句可以不用 XML 来配置，而可以使用 Java 注解来配置。

接口

import org.apache.ibatis.annotations.Select;
@Select("select * from blog_admin")
List<BlogAdmin> getBlogAdmin();

mapper.xml

<!-- 绑定接口  -->
 <mappers>
        <mapper class="com.depressiom.dao.BlogAdminMapper"/>
    </mappers>

测试

 @Test
    public void Test(){
       SqlSession sqlSession = MybatisUtils.getsqlSession();
        // 本质：反射机制实现
       //  底层实现 动态代理
       BlogAdminMapper mapper = sqlSession.getMapper(BlogAdminMapper.class);

        List<BlogAdmin> blogAdmins = mapper.getBlogAdmin();
        for (BlogAdmin blogAdmin : blogAdmins) {
            System.out.println(blogAdmin);
        }
       sqlSession.close();
    }

注意：因为数据库字段与实体类字段名不一致，导致为null

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

选择何种方式来配置映射，以及是否应该要统一映射语句定义的形式，完全取决于你和你的团队。 换句话说，永远不要拘泥于一种方式，你可以很轻松地在基于注解和 XML 的语句映射方式间自由移植和切换。

底层实现 动态代理