2021-08-20

4、配置解析

4、类型别名（typeAliases）

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

<!--可以给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.feng.pojo.User" alias="User"></typeAlias>
    </typeAliases>

也可以指定一个包名，Mybatis会在包名下面搜索需要的Java Bean，比如：

扫描实体类的包，它默认别名就为这个类的 类名，首字母小写！

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

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

如果实体类十分多，建议使用第二种。

第一种可以自定义别名，第二种则不行，

如果使用扫描包的方式，还非要改名字，则需要在实体类上增加注解

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

5、设置（settings）

• 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

6、其它配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）

7、映射器（mappers）

​ MapperRegistry：注册绑定我们的Mapper文件；

方式一：【推荐使用】

<!-- 每一个Mapper.xml文件都要在Mybatis核心配置文件中注册   -->
    <mappers>
        <mapper resource="com/feng/dao/UserMapper.xml"/>
    </mappers>

方式二：使用class文件绑定注册

 <!-- 每一个Mapper.xml文件都要在Mybatis核心配置文件中注册   -->
    <mappers>
<!--        <mapper resource="com/feng/dao/UserMapper.xml"/>-->
        <mapper class="com.feng.dao.UserMapper"/>
    </mappers>

注意点：

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

方式三：使用扫描包进行注入绑定

<!-- 每一个Mapper.xml文件都要在Mybatis核心配置文件中注册   -->
    <mappers>
    <!--<mapper resource="com/feng/dao/UserMapper.xml"/>-->
    <!--<mapper class="com.feng.dao.UserMapper"></mapper>-->
        <package name="com.feng.dao"/>
    </mappers>

• 将数据库配置文件外部引入
• 实体类别名
• 保证UserMapper接口和 UserMapper.xml改为一致！并且放在同一个包下！

8、生命周期和作用域

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

SqlSessionFactoryBuilder:

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

SqlSessionFactory:

• 说白了就是可以想象为：数据库连接池（用完了就回收）
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域（全局变量）程序开始它开始，程序结束它结束。被创建后直到程序结束，它才会被关闭！
• 最简单的就是使用单例模式或者静态单例模式，让他保证全局只有一份变量

SqlSession：

• 连接到连接池的一个请求！

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

• 用完之后需要赶紧关闭，让资源回收到连接池中，否则资源被占用！

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

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

1、问题

数据库中的字段

新建一个项目，拷贝之前的，测试实体类字段不一致的情况

public class User {
    private int id;
    private String name;
    private String password;//密码名不一致
}

测试出现的问题：

​ 原因：是因为查询的到结果的表格中没有 password 这一列，只有 id name pwd 这三列。

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

解决方法：

1. 起别名：

   //  select id,name,pwd as password from user where id = #{id}
   

   这样查询到的结果中pwd这一列就会变为password这一列。

2、resultMap

结果集映射

id   name   pwd
id   name   password

注意这里我们去掉了 resultType 属性

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

6、日志

6.1、日志工厂

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

之前我们用：sout、debug

现在我们用：日志工厂！ logImpl

• SLF4J

• LOG4J 【掌握】

• LOG4J2

• JDK_LOGGING

• COMMONS_LOGGING

• STDOUT_LOGGING 【掌握】

• NO_LOGGING

在Mybatis中具体使用哪一个日志实现，在设置中设定！

STDOUT_LOGGING 标准日志输出

在Mybatis核心配置文件中，配置我们的日志！

<!--配置日志-->
    <settings>
        <!--标准的日志工厂实现-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

6.2、Log4j

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

1. 先导入Log4j的包

<!--导入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/shun.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>
   

4. log4j的使用，直接测试

   

这里直接测试的时候我的Log4j的配置文件无法找到，于是我手写了一个初始化Log4j的程序，需要在测试文件中加入初始化语句：initLogRecord.initLog();

package com.feng.utils;

import org.apache.log4j.PropertyConfigurator;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

//手动引入Log4j的配置文件
public class initLogRecord {
    public static void initLog() {
        FileInputStream fileInputStream = null;
        try {
            Properties properties = new Properties();
            //放到包xml下面也是可以运行的
            //src/main/java/com/feng/xml/log4j.properties
            //放到resources资源文件目录下也是可以运行的
            fileInputStream = new FileInputStream("src/main/resources/log4j.properties");//总之要从src开始写
            properties.load(fileInputStream);
            PropertyConfigurator.configure(properties);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

简单使用

1. 在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;

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

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

3. 日志级别

    @Test
       public void testLog4j(){
           initLogRecord.initLog();//引入Log4j的配置文件
           logger.info("info:进入了testLog4j");
           logger.debug("debug:进入了testLog4j");
           logger.error("error:进入了testLog4j");
       }
   

7、分页

7.1、使用Limit分页

select * from user limit startIndex,pageSize
select * from user limit 0,2
select * from user limit 3; 表示显示从0到3 

使用Mybatis实现分页，核心SQL

1. 接口

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

2. Mapper.xml

       <!--分页-->
       <select id="getUserLimit" resultMap="UserMap" parameterType="map">
           select * from user limit #{startIndex},#{page}
       </select>
   

3. 测试

   //分页
       @Test
       public void getUserLimit(){
           initLogRecord.initLog();
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           HashMap<String, Integer> map = new HashMap<>();
           map.put("startIndex",1);//从一开始
           map.put("page",2);//查询两个人
   
           List<User> userLimit = mapper.getUserLimit(map);
           for (User user : userLimit) {
               System.out.println(user.toString());
           }
   
           sqlSession.close();
   
       }
   

7.2、RowBounds分页（了解）

不再使用SQL实现分页

1. 接口

       //分页2
       List<User> getUser();
   

2. mapper.xml

       <!--分页二-->
       <select id="getUser" resultMap="UserMap">
           select * from user
       </select>
   

3. 测试

       //分页2
       @Test
       public void getUser(){
           initLogRecord.initLog();
           SqlSession sqlSession = MybatisUtils.getSqlSession();
   
           //用Java代码来进行分页
           RowBounds rowBounds = new RowBounds(1,2);//从1开始显示，每页显示2条数据
   
           List<Object> list = sqlSession.selectList("com.feng.dao.UserMapper.getUser", null, rowBounds);
           for (Object o : list) {
               System.out.println(o.toString());
           }
           sqlSession.close();
       }
   

7.3、分页插件

使用分页插件文档：如何使用分页插件 (pagehelper.github.io)

了解即可，万一以后要使用你需要知道它是什么东西

8、使用注解开发

8.1、面向接口编程

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

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

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

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

关于接口的理解

• 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
• 接口的本身反映了系统设计人员对系统的抽象理解。
• 接口应有两类：
  • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）;
  • 第二类是对一个个体某个方面的抽象，即形成一个抽象面（interface）;
  • 一个个体可能有多个抽象面，抽象体与抽象面是有区别的。

三个面向区别

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

8.2、使用注解开发

1. 注解在接口上实现

   public interface UserMapper {
   
       @Select("select * from user")
       List<User> getUserList();
   }
   

2. 在核心配置文件中绑定接口

    <mappers>
           <mapper class="com.feng.dao.UserMapper"></mapper>
       </mappers>
   

3. 测试

本质：反射机制实现

底层：动态代理

Mybatis详细的执行流程：

8.3、CRUD

我们可以在工具类创建的时候实现自动提交事务！

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

编写接口，增加注解

public interface UserMapper {

    @Select("select * from user")
    List<User> getUserList();

    //方法存在多个参数就要用@Param：（@Param("id") int id ,@Param("name") String name）
    @Select("select * from user where id = #{id}")
    User getUserByid(@Param("id") int id);

    //增加
    @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")
    int addUser(User user);

    //修改
    @Update("update user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);

    //删除
    @Delete("delete from user where id=#{id}")
    int delete(int id);
}

测试类

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

关于@Param()注解

• 基本类型的参数或者Srting类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
• 我们在Sql中引用的就是@Param(“id”)注解中设定的属性名！