mybatis源码刨析总结

﹏ヽ暗。殇╰゛Y 2022-11-29 12:18 134阅读 0赞

# 拉勾 mybatis #

## 初始化 ##

### 1.创建git仓库 ###

1.新建一个目录 然后点击右键 git base here 创建git (会弹出一个窗口)  
2.初始化 再窗口输入 git init  
3.指定仓库 git clone 仓库地址  
4.上传文件 点击右键 git提交->master (选择提交并推送)

## 1. jdbc连接数据库的缺陷 ##

### 1.1 代码 ###

public static void main(String[] args) { 
            Connection connection = null;
            PreparedStatement preparedStatement = null;
            ResultSet resultSet = null;
            try { 
                //加载数据库驱动
                Class.forName("com.mysql.jdbc.Driver");
                //通过驱动管理类获取数据库连接
                connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lgstudy?characterEncoding=utf-8", "root", "root");
                //---有参数
    // //?占位符
    // String sql = "select * from user where username = ?";
    // //获取预处理statement
    // preparedStatement = connection.prepareStatement(sql);
    // // 设置参数
    // preparedStatement.setString(1, "占山");
                //---无参数
                String sql = "select * from user";
                preparedStatement = connection.prepareStatement(sql);
                // 执行sql查询结果集
                resultSet = preparedStatement.executeQuery();
                //遍历结果集
                while (resultSet.next()) { 
                    int id = resultSet.getInt("id");
                    String username = resultSet.getString("username");
                    User user = new User();
                    //封装user
                    user.setId(id);
                    user.setUsername(username);
                    System.out.println(user);
                }
    
            } catch (Exception e) { 
                e.printStackTrace();
            } finally
    
            { 
                // 释放资源
                if (resultSet != null) { 
                    try { 
                        resultSet.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
                if (preparedStatement != null) { 
                    try { 
                        preparedStatement.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
                if (connection != null) { 
                    try { 
                        connection.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
            }
    
        }

### 1.2 缺陷 ###

1.连接数据库的配置信息硬编码  ===》存到配置文件中
    2.数据库的频繁断开连接==》连接池
    3.sql语句，设置参数 硬编码 ==》存到配置文件中 设置参数 反射
    4.手动遍历封装结果集  ==》 内省

## 2. 自定义持久层框架 ##

### 2.1 思路 ###

#### 2.1.1使用端 ####

1.引入自定义持久层的包
    2.提供两部分配置信息：
        1.数据库的连接配置信息 sql配置信息
        2.mapper.xml 存放sql配置信息

#### 2.1.2自定义持久层框架（封装jdbc的操作） ####

1.加载配置文件；根据配置文件的路径，加载配置成字节输入流，存储在内存中
    2.创建两个javaBean(容器)
    	Configuration核心配置类：存放sql的配置信息
    	MappedStatement映射配置类 存放mapper.xml信息
    3.解析配置文件 dom4j
    	创建类sqlSessionFactoryBuilder
    		1.使用dom4j解析配置文件，将解析出来的文件存放到javabean（容器）中
    		2.创建sqlSessionFactory对象，生产session （工厂模式）
    4.创建sqlSessionFactory接口实现类
    	openSession
    5.创建sqlSession接口及DefaultSession
    	定义数据库的crud操作 selectlist()
    					  update()
    6.执行Exector接口及实现类SimpleExector
    	query()//执行jdbc代码

#### 2.1.3自定义持久层框架（缺陷） ####

1.dao层，存在代码重复，整个操作的过程模版重复（加载配置文件）
    2.statementId存在硬编码
    ========》jdk动态代理 
    Proxy.newProxyInstance  InvocationHandler

### 2.2 代码实现 ###

#### 2.2.1 使用端 ####

##### 1.创建项目 #####

1.创建lagou-mybatis项目（maven骨架项目）

##### 2.创建sqlMapConfig.xml(sql源配置文件) #####

\#\#\#\#\#2.创建UserMapper.xml(user类的sql)

<mapper namespace="com.test.dao.IUserDao">
    
        
        <select id="findAll" resultType="com.test.pojo.User" >
            select * from user
        </select>
    
        <select id="findOneById" resultType="com.test.pojo.User" paramterType="com.test.pojo.User">
            select * from user where id = #{id}
        </select>
    
    </mapper>

#### 2.2.2 框架端 ####

##### 1.创建项目 #####

1.创建lagou-mybatis项目（maven骨架项目）

##### 2.pojo类 #####

Configuration 用于存储 数据库源

public class Configuration { 
    
        private DataSource dataSource;
    
        /* * key: statementid value:封装好的mappedStatement对象 * */
        Map<String,MappedStatement> mappedStatementMap = new HashMap<>();
        }

MappedStatement 用于存储 sql文件的引用

//存储的SQL xml文件的映射对象
    public class MappedStatement { 
    
        //id标识
        private String id;
        //返回值类型
        private String resultType;
        //参数值类型
        private String paramterType;
        //sql语句
        private String sql;
        }

##### 3.io类 #####

Resources

public class Resources { 
        // 根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
        public static InputStream getResourceAsSteam(String path){ 
            InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
            return  resourceAsStream;
        }
    }

#### 4.扫描类 封装 UserMapper ####

public class XMLMapperBuilder { 
    
        private Configuration configuration;
    
        private String namespace;
        public XMLMapperBuilder(Configuration configuration) { 
            this.configuration =configuration;
        }
    
        public void parse(InputStream inputStream) throws DocumentException { 
    
            Document document = new SAXReader().read(inputStream);
            Element rootElement = document.getRootElement();
            //获取定义的命名空间
            namespace = rootElement.attributeValue("namespace");
            getNodes(rootElement);
        }
    
        public void getNodes(Element rootElement){ 
            //获取标签名称
            String name = rootElement.getName();
            List<Element> list = rootElement.selectNodes("//"+name);
            for (Element element : list) { 
                String id = element.attributeValue("id");
                String resultType = element.attributeValue("resultType");
                String paramterType = element.attributeValue("paramterType");
                String sqlText = element.getTextTrim();
                if(id!=null){ 
                    MappedStatement mappedStatement = new MappedStatement();
                    mappedStatement.setId(id);
                    mappedStatement.setResultType(resultType);
                    mappedStatement.setParamterType(paramterType);
                    mappedStatement.setSql(sqlText);
                    mappedStatement.setTypeValue(name);
                    //封装key
                    String key = namespace+"."+id;
                    configuration.getMappedStatementMap().put(key,mappedStatement);
    
                }
    
            }
    
    
            //递归遍历当前节点所有的子节点
            List<Element> listElement=rootElement.elements();//所有一级子节点的list
            for(Element e:listElement){ //遍历所有一级子节点
                this.getNodes(e);//递归
            }
        }
    }

#### 5.方法反射类 ####

public class DefaultSqlSession implements SqlSession { 
    
        private Configuration configuration;
    
        public DefaultSqlSession(Configuration configuration) { 
            this.configuration = configuration;
        }
    
        @Override
        public <E> List<E> selectList(String statementId, Object... param) throws Exception { 
            //调用执行器
    
            //将要去完成对simpleExecutor里的query方法的调用
            simpleExecutor simpleExecutor = new simpleExecutor();
            //根据statementId获取Mapped
            MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
            List<Object> list = simpleExecutor.query(configuration, mappedStatement, param);
            return (List<E>) list;
        }
    
        @Override
        public <T> T selectOne(String statementId, Object... params) throws Exception { 
            List<Object> objects = selectList(statementId, params);
            if (objects.size() == 1) { 
                return (T) objects.get(0);
            } else { 
                throw new RuntimeException("查询结果为空或者返回结果过多");
            }
        }
    
        @Override
        public int update(String statementId, Object... params) throws Exception { 
            simpleExecutor simpleExecutor = new simpleExecutor();
            MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
            int update = simpleExecutor.update(configuration, mappedStatement, params);
            return update;
        }
    
        @Override
        public <T> T getMapper(Class<?> mapperClass) { 
            // 使用JDK动态代理来为Dao接口生成代理对象，并返回
    // loader: 用哪个类加载器去加载代理对象
    // interfaces:动态代理类需要实现的接口
    // h:动态代理方法在执行时，会调用h里面的invoke方法去执行
            Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{ mapperClass}, new InvocationHandler() { 
                //proxy 当前代理对象的应用
                //method 当前被调用方法的引用
                //args 传递的参数
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    // 底层都还是去执行JDBC代码 
                    //根据不同情况，来调用selctList或者selectOne
                    // 准备参数 1：statmentid :sql语句的唯一标识：namespace.id= 接口全限定名.方法名
                    // 方法名：findAll
                    String methodName = method.getName();
                    String className = method.getDeclaringClass().getName();
    
                    Object result = new Object();
    
                    String statementId = className + "." + methodName;
                    //com.test.dao.IUserDao.updateById
                    //com.test.dao.IUserDao.update
                    MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
                    //获取方法的标签值
                    String typeValue = mappedStatement.getTypeValue();
    
                    switch (typeValue) { 
                        case "insert": { 
    
                            result = update(statementId, args);
                            break;
                        }
                        case "update": { 
    
                            result = update(statementId, args);
                            break;
                        }
                        case "delete": { 
                            result = update(statementId, args);
                            break;
                        }
                        case "select": { 
                            Type genericReturnType = method.getGenericReturnType();
                            // 判断是否进行了 泛型类型参数化
                            if (genericReturnType instanceof ParameterizedType) { 
                                List<Object> objects = selectList(statementId, args);
                                result= objects;
                                break;
                            }else{ 
    
                                result= selectOne(statementId, args);
                                break;
                            }
                        }
                    }
                    return result;
                }
            });
            return (T) proxyInstance;
        }
    
    
    }

#### 6.JDbc执行类 ####

public class simpleExecutor implements  Executor { 
    
        @Override                                                                                //user
        public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception { 
            // 1. 注册驱动，获取连接
            Connection connection = configuration.getDataSource().getConnection();
    
            // 2. 获取sql语句 : select * from user where id = #{id} and username = #{username}
                //转换sql语句： select * from user where id = ? and username = ? ，转换的过程中，还需要对#{}里面的值进行解析存储
            String sql = mappedStatement.getSql();
            BoundSql boundSql = getBoundSql(sql);
    
            // 3.获取预处理对象：preparedStatement
            PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
    
            // 4. 设置参数
            //获取到了 参数的全路径
             String paramterType = mappedStatement.getParamterType();
             Class<?> paramtertypeClass = getClassType(paramterType);
    
            List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
            for (int i = 0; i < parameterMappingList.size(); i++) { 
                ParameterMapping parameterMapping = parameterMappingList.get(i);
                String content = parameterMapping.getContent();
                //反射
                Field declaredField = paramtertypeClass.getDeclaredField(content);
                //暴力访问
                declaredField.setAccessible(true);
                Object o = declaredField.get(params[0]);
                preparedStatement.setObject(i+1,o);
            }
    
            // 5. 执行sql
            ResultSet resultSet = preparedStatement.executeQuery();
            //获取返回值类
            String resultType = mappedStatement.getResultType();
            Class<?> resultTypeClass = getClassType(resultType);
    
            ArrayList<Object> objects = new ArrayList<>();
    
            // 6. 封装返回结果集
            while (resultSet.next()){ 
                //反射new一个类
                Object o =resultTypeClass.newInstance();
                //元数据
                ResultSetMetaData metaData = resultSet.getMetaData();
                for (int i = 1; i <= metaData.getColumnCount(); i++) { 
    
                    // 字段名
                    String columnName = metaData.getColumnName(i);
                    // 字段的值
                    Object value = resultSet.getObject(columnName);
    
                    //使用反射或者内省，根据数据库表和实体的对应关系，完成封装
                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
                    Method writeMethod = propertyDescriptor.getWriteMethod();
                    writeMethod.invoke(o,value);
    
    
                }
                objects.add(o);
    
            }
    
            return (List<E>) objects;
    
        }
    
        @Override
        public int update(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception { 
            //update user set username=#{} where id=#{}
            // 1. 注册驱动，获取连接
            Connection connection = configuration.getDataSource().getConnection();
    
            // 2. 获取sql语句 : select * from user where id = #{id} and username = #{username}
            //转换sql语句： select * from user where id = ? and username = ? ，转换的过程中，还需要对#{}里面的值进行解析存储
            String sql = mappedStatement.getSql();
            BoundSql boundSql = getBoundSql(sql);
    
            // 3.获取预处理对象：preparedStatement
            PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
    
            // 4. 设置参数
            //获取到了 参数的全路径
            String paramterType = mappedStatement.getParamterType();
            Class<?> paramtertypeClass = getClassType(paramterType);
    
            List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
            for (int i = 0; i < parameterMappingList.size(); i++) { 
                ParameterMapping parameterMapping = parameterMappingList.get(i);
                String content = parameterMapping.getContent();
                Object o =null;
                if(mappedStatement.getTypeValue().equals("delete")){ 
                    o= params[i];
                }else{ 
                    //反射
                    Field declaredField = paramtertypeClass.getDeclaredField(content);
                    //暴力访问
                    declaredField.setAccessible(true);
                    o = declaredField.get(params[0]);
                }
    
                preparedStatement.setObject(i+1,o);
    
            }
    
            // 5. 执行sql
            int i1 = preparedStatement.executeUpdate();
    
            return i1;
        }
    
        private Class<?> getClassType(String paramterType) throws ClassNotFoundException { 
            if(paramterType!=null){ 
                Class<?> aClass = Class.forName(paramterType);
                return aClass;
            }
             return null;
    
        }
    
    
        /** * 完成对#{}的解析工作：1.将#{}使用？进行代替，2.解析出#{}里面的值进行存储 * @param sql * @return */
        private BoundSql getBoundSql(String sql) { 
            //标记处理类：配置标记解析器来完成对占位符的解析处理工作
            ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
            GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
            //解析出来的sql
            String parseSql = genericTokenParser.parse(sql);
            //#{}里面解析出来的参数名称
            List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
    
            BoundSql boundSql = new BoundSql(parseSql,parameterMappings);
            return boundSql;
    
        }
    }

#### 7.测试类 ####

@Test
    public void testProxyDao() throws IOException { 
     InputStream resourceAsStream =
    Resources.getResourceAsStream("SqlMapConfig.xml");
     SqlSessionFactory sqlSessionFactory = new
    SqlSessionFactoryBuilder().build(resourceAsStream);
     SqlSession sqlSession = sqlSessionFactory.openSession();
    
     UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
     User user = userMapper.findById(1);
     System.out.println(user);
     sqlSession.close();
    }

#### 2.2.3打jar问题 ####

1.在pom文件中添加编译属性

2.idea中点击 projrct Structure =>点击module 设置项目的编译版本  
3.srtting=> builder=>compiler=>java compiler设置编译版本

## 3.mybatis快速启动 ##

### 3.1导依赖 ###

<properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
            <java.version>1.8</java.version>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
    
        
        <dependencies>
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.5</version>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
                <scope>runtime</scope>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>

## 4 自定义插件 ##

### xml ###

### java ###

package com.lagou.plugin;
    
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.plugin.*;
    
    import java.sql.Connection;
    import java.util.Properties;
    
    
    
        @Intercepts({ 
                @Signature(type= StatementHandler.class,//拦截那个接口
                        method = "prepare",//这个接口内的那个方法名
                        args={ Connection.class,Integer.class})//拦截方法的入参，如果方法重载，通过方法名跟参数确定唯一
        })
        public class MyPlugin implements Interceptor { 
            //这里是每次执行操作的时候，都会进行这个方法
            @Override
            public Object intercept(Invocation invocation) throws Throwable { 
                System.out.println("增强了");
                return invocation.proceed();
            }
    
            //把这个拦截器生成一个代理放到拦截器链中
            @Override
            public Object plugin(Object target) { 
                System.out.println("将要包装的目标对象"+target);
                return Plugin.wrap(target,this);
            }
            //插件初始化时候调用，只调用一次 获取配置文件的属性
            @Override
            public void setProperties(Properties properties) { 
                System.out.println("获取配置文件的属性"+properties);
            }
        }

### mybatis 拦截的类 ###

一、executor，executor类可以说是执行sql的全过程，如组装参数，sql改造，结果处理，比较广泛，但实际用的不多

二、StatementHandler，这个是执行sql的过程，可以获取到待执行的sql，可用来改造sql，如分页，分表，最常拦截的类

三、paremeterHandler，这个用来拦截sql的参数，可以自定义参数组装规则

四、resultHandler，这个用来处理结果

## 5 缓存 ##

### 一级缓存 ###

### 二级缓存 ###

二级缓存是序列化存储 需要实现POJO需要实现Serializable接口

<settings>
      <setting name="cacheEnabled" value="true" />
    </settings>
    //在sql的mapper的添加 <cache/>表填

### 问题 ###

#### 1.缓存使用顺序 ####

先到二级缓存当中查找
    如果二级缓存中没有,就去找一级缓存
    如果一级缓存中也没有就去到数据库当中查询

#### 2.二级Chache使用原则 ####

**1.只能在一个命名空间下使用二级缓存**  
由于二级缓存中的数据是基于namespace的，即不同namespace中的数据互不干扰。在多个namespace中若均存在对同一个表的操作，那么这多个namespace中的数据可能就会出现不一致现象。  
**2.在单表上使用二级缓存**  
如果一个表与其它表有关联关系，那么久非常有可能存在多个namespace对同一数据的操作。而不同namespace中的数据互补干扰，所以就有可能出现多个namespace中的数据不一致现象。  
**3.查询多于修改时使用二级缓存**  
在查询操作远远多于增删改操作的情况下可以使用二级缓存。因为任何增删改操作都将刷新二级缓存，对二级缓存的频繁刷新将降低系统性能。

# java补充 #

## 1.java类型 T，E，K，V，？ ##

泛型中的通配符
    
    ？表示不确定的 java 类型
    ？无界通配符
    例子 List<? extends Animal> listAnimals
    
    T (type) 表示具体的一个java类型
     List<T>是确定的某一个类型
    
    K V (key value) 分别代表java键值中的Key Value
    
    E (element) 代表Element
    上界通配符 < ? extends E>
    下界通配符 < ? super E>
    
    T和？运用的地方有点不同,
    	? 是定义在引用变量上
    	T 是类上或方法上

## 2. List<T.?.Object>区别 ##

ArrayList<T> arrayList = new ArrayList<T>(); 指定集合元素类型只可以是T类型
    ArrayList<?>arrayList = new ArrayList<?>(); 集合元素可以是任意类型，一般是方法中为了说明方法
    ArrayList<? extends E> arrayList = new ArrayList<? extends E>();泛型的限定：？ extends E：接受E类型或者E的子类型、？ super E :接受E类型或者E的父类型

## 3.java的内省与反射 ##

//https://www.cnblogs.com/winclpt/articles/7405271.html
    　
    1.内省是先得到属性描述器PropertyDecriptor后再进行各种操作，内省（Introspector）是Java语言对JavaBean类属性、事件的处理方法
    2.反射则是先得到类的字节码Class后再进行各种操作的。对任意一个类，能够获取得到这个类的所有属性和方法；
    代码：
     反射：
         Field f = user.getClass().getDeclaredField("name");
         f.setAccessible(true);
         f.set(user, "mld");//设置属性值
     内省
         //操作单个属性
         PropertyDescriptor pd = new PropertyDescriptor("name", User.class);
         Method w = pd.getWriteMethod();//获取属性的setter方法
         w.invoke(user, "winclpt");

## 4.java的代理 ##

### 1.静态代理 ###

静态代理：由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成

### 2.动态代理 ###

实现InvocationHandler接口  
动态代理就是要生成一个包装类对象，由于代理的对象是动态的，所以叫动态代理。由于我们需要增强，这个增强是需要留给开发人员开发代码的，因此代理类不能直接包含被代理对象，而是一个InvocationHandler，该InvocationHandler包含被代理对象，并负责分发请求给被代理对象，分发前后均可以做增强。从原理可以看出，JDK动态代理是“对象”的代理。  
原文链接：https://blog.csdn.net/flyfeifei66/article/details/81481222 \*\*

// 使用JDK动态代理来为Dao接口生成代理对象，并返回
    // loader: 用哪个类加载器去加载代理对象
    //
    // interfaces:动态代理类需要实现的接口
    //
    // h:动态代理方法在执行时，会调用h里面的invoke方法去执行
            Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{ mapperClass}, new InvocationHandler() { 
                //proxy 当前代理对象的应用
                //method 当前被调用方法的引用
                //args 传递的参数
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                    // 底层都还是去执行JDBC代码 //根据不同情况，来调用selctList或者selectOne
                    // 准备参数 1：statmentid :sql语句的唯一标识：namespace.id= 接口全限定名.方法名
                    // 方法名：findAll
                    String methodName = method.getName();
                    String className = method.getDeclaringClass().getName();
    
                    String statementId = className+"."+methodName;
    
                    // 准备参数2：params:args
                    // 获取被调用方法的返回值类型
                    Type genericReturnType = method.getGenericReturnType();
                    // 判断是否进行了 泛型类型参数化
                    if(genericReturnType instanceof ParameterizedType){ 
                        List<Object> objects = selectList(statementId, args);
                        return objects;
                    }
    
                    return selectOne(statementId,args);
    
                }
            });
    
            return (T) proxyInstance;
        }

## 5.newInstance与new的区别 ##

new关键字能调用任何构造方法。  
newInstance()只能调用无参构造方法。  
newInstance()构造对象的地方通过new关键字也可以创建对象.  
在使用newInstance()方法的时候，必须保证这个类已经加载并且已经连接  
**适用:**  
使用newInstance()在通用性方面比较高，className我们可以用配置文件进行相关的配置。  
String className = 从配置文件中读取className;  
A a = (A) Class.forName(className).newInstance();  
再配合依赖注入的方法，就提高了软件的可伸缩性、可扩展性。框架的开发中用的比较多！

public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException { 
            String str = (String) Class.forName("java.lang.String").newInstance();
            String str1 = new String();
            if(str.getClass() == str1.getClass()){ 
                System.out.println("YES");
            }
        }
      
    output:YES
    //原文链接：https://blog.csdn.net/qq_33704186/java/article/details/86596614

# 单词 #

statement 声明，陈述  
bound 一定会，边界  
Declaring 公然地,生命  
Accessible 可进入的  
descrip 描述  
relation 关系  
example例子  
Generic通用的  
Security 安全的  
Multiple 多样的  
extract提取  
wrap包  
signature签名  
Additional附加的 额外的/

# 作业 #

简答题

### 一. ###

#### 1.Mybatis动态sql是做什么的？ ####

**1.动态sql就是** 根据条件标签动态的拼接sql，包括判空，循环，拼接等

#### 2.哪些动态sql? ####

动态sql大致有  
1.: if是为了判断传入的值是否符合某种规则，比如是否不为空；  
2.:where标签可以用来做动态拼接查询条件，当和if标签配合的时候，不用显示的声明类似where 1=1这种无用的条件  
3.:foreach标签可以把传入的集合对象进行遍历，然后把每一项的内容作为参数传到sql语句中，  
4.:include可以把大量重复的代码整理起来，当使用的时候直接include即可，减少重复代码的编写；  
5.:是一个格式化标签  
6.choose、when、otherwise 标签类似于 Java 中的 switch、case、default。只有一个条件生效，

<select id="findOneById" resultType="com.lagou.pojo.User">
      select <include refid="userInfo"/> from user
      <where>
            <if test="id != null and id != 0">
              AND id = #{id}
            </if>
      <foreach collection="list" item="id" open="(" close=")" separator="," >
        #{id}
      </foreach>
         <trim prefix="where" suffix="order by id" prefixOverrides="and | or" suffixOverrides=",">
            <if test="name != null and name != ''">
              AND name = #{name}
            </if>
            <if test="id != null">
              AND id = #{id}
            </if>
          </trim>
      </where>
    </select>

#### 3. 简述一下动态sql的执行原理？ ####

**1.在xmlMapperBuilder中 解析配置文件时**

**2.解析 `<mapper />` 节点**

**3.解析 节点**

// 1.在xmlMapperBuilder中 解析配置文件时
    	public void parse() { 
                // 解析 `<mapper />` 节点
                configurationElement(parser.evalNode("/mapper"));
        }
        //2. 解析 `<mapper />` 节点
        private void configurationElement(XNode context) { 
            try { 
                // 获得 namespace 属性
                String namespace = context.getStringAttribute("namespace");
                if (namespace == null || namespace.equals("")) { 
                    throw new BuilderException("Mapper's namespace cannot be empty");
                }
                // 设置 namespace 属性
                builderAssistant.setCurrentNamespace(namespace);
                // 解析 <resultMap /> 节点们
                resultMapElements(context.evalNodes("/mapper/resultMap"));
                // 解析 <sql /> 节点们
                sqlElement(context.evalNodes("/mapper/sql"));
                // 解析 <select /> <insert /> <update /> <delete /> 节点们
                buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
            } catch (Exception e) { 
                throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
            }
        }
      // 3.解析 <select /> <insert /> <update /> <delete /> 节点们
        private void buildStatementFromContext(List<XNode> list) { 
            if (configuration.getDatabaseId() != null) { 
                buildStatementFromContext(list, configuration.getDatabaseId());
            }
            buildStatementFromContext(list, null);
            // 上面两块代码，可以简写成 buildStatementFromContext(list, configuration.getDatabaseId());
        }
     	private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { 
            //遍历 <select /> <insert /> <update /> <delete /> 节点们
            for (XNode context : list) { 
                // 创建 XMLStatementBuilder 对象，执行解析
                final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
                try { 
                    statementParser.parseStatementNode();
                } catch (IncompleteElementException e) { 
                    // 解析失败，添加到 configuration 中
                    configuration.addIncompleteStatement(statementParser);
                }
            }
        }

**4.XMLStatementBuilder对象**

public class XMLStatementBuilder extends BaseBuilder { 
       /** * 执行解析 */
        public void parseStatementNode() { 
            // 获得 id 属性，编号。
            String id = context.getStringAttribute("id");
            // 获得 databaseId ， 判断 databaseId 是否匹配
            String databaseId = context.getStringAttribute("databaseId");
            if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { 
                return;
            }
    
            // 获得各种属性
            Integer fetchSize = context.getIntAttribute("fetchSize");
            Integer timeout = context.getIntAttribute("timeout");
            String parameterMap = context.getStringAttribute("parameterMap");
            String parameterType = context.getStringAttribute("parameterType");
            Class<?> parameterTypeClass = resolveClass(parameterType);
            String resultMap = context.getStringAttribute("resultMap");
            String resultType = context.getStringAttribute("resultType");
            String lang = context.getStringAttribute("lang");
    
            // 获得 lang 对应的 LanguageDriver 对象
            LanguageDriver langDriver = getLanguageDriver(lang);
    
            // 获得 resultType 对应的类
            Class<?> resultTypeClass = resolveClass(resultType);
            // 获得 resultSet 对应的枚举值
            String resultSetType = context.getStringAttribute("resultSetType");
            ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
            // 获得 statementType 对应的枚举值
            StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    
         
    }

**5.LanguageDriver的实现类XMLLanguageDriver的方法解析方法createSqlSource**

public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) { 
            // 创建 XMLScriptBuilder 对象，执行解析
            XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
            return builder.parseScriptNode();
        }

**6.解析**

XMLScriptBuilder标签解析
    /** * XML 动态语句( SQL )构建器，负责将 SQL 解析成 SqlSource 对象 * * @author Clinton Begin */
    public class XMLScriptBuilder extends BaseBuilder { 
    
        /** * 当前 SQL 的 XNode 对象 */
        private final XNode context;
        /** * 是否为动态 SQL */
        private boolean isDynamic;
        /** * SQL 方法类型 */
        private final Class<?> parameterType;
        /** * NodeNodeHandler 的映射 */
        private final Map<String, NodeHandler> nodeHandlerMap = new HashMap<>();
    
        public XMLScriptBuilder(Configuration configuration, XNode context) { 
            this(configuration, context, null);
        }
    
        public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) { 
            super(configuration);
            this.context = context;
            this.parameterType = parameterType;
            // 初始化 nodeHandlerMap 属性
            initNodeHandlerMap();
        }
    
        /** * 初始化 {@link #nodeHandlerMap} 属性 */
        private void initNodeHandlerMap() { 
            nodeHandlerMap.put("trim", new TrimHandler());
            nodeHandlerMap.put("where", new WhereHandler());
            nodeHandlerMap.put("set", new SetHandler());
            nodeHandlerMap.put("foreach", new ForEachHandler());
            nodeHandlerMap.put("if", new IfHandler());
            nodeHandlerMap.put("choose", new ChooseHandler());
            nodeHandlerMap.put("when", new IfHandler());
            nodeHandlerMap.put("otherwise", new OtherwiseHandler());
            nodeHandlerMap.put("bind", new BindHandler());
        }
    
        /** * 负责将 SQL 解析成 SqlSource 对象 * * @return SqlSource 对象 */
        public SqlSource parseScriptNode() { 
            // 解析 SQL
            MixedSqlNode rootSqlNode = parseDynamicTags(context);
            // 创建 SqlSource 对象
            SqlSource sqlSource;
            if (isDynamic) { 
                sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
            } else { 
                sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
            }
            return sqlSource;
        }
    
        /** * 解析 SQL 成 MixedSqlNode 对象 * * @param node XNode 节点 * @return MixedSqlNode */
        protected MixedSqlNode parseDynamicTags(XNode node) { 
            // 创建 SqlNode 数组
            List<SqlNode> contents = new ArrayList<>();
            // 遍历 SQL 节点的所有子节点
            NodeList children = node.getNode().getChildNodes();
            for (int i = 0; i < children.getLength(); i++) { 
                // 当前子节点
                XNode child = node.newXNode(children.item(i));
                // 如果类型是 Node.CDATA_SECTION_NODE 或者 Node.TEXT_NODE 时
                if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) { 
                    // 获得内容
                    String data = child.getStringBody("");
                    // 创建 TextSqlNode 对象
                    TextSqlNode textSqlNode = new TextSqlNode(data);
                    // 如果是动态的 TextSqlNode 对象
                    if (textSqlNode.isDynamic()) { 
                        // 添加到 contents 中
                        contents.add(textSqlNode);
                        // 标记为动态 SQL
                        isDynamic = true;
                    // 如果是非动态的 TextSqlNode 对象
                    } else { 
                        // 创建 StaticTextSqlNode 添加到 contents 中
                        contents.add(new StaticTextSqlNode(data));
                    }
                // 如果类型是 Node.ELEMENT_NODE
                } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) {  // issue #628
                    // 根据子节点的标签，获得对应的 NodeHandler 对象
                    String nodeName = child.getNode().getNodeName();
                    NodeHandler handler = nodeHandlerMap.get(nodeName);
                    if (handler == null) {  // 获得不到，说明是未知的标签，抛出 BuilderException 异常
                        throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
                    }
                    // 执行 NodeHandler 处理
                    handler.handleNode(child, contents);
                    // 标记为动态 SQL
                    isDynamic = true;
                }
            }
            // 创建 MixedSqlNode 对象
            return new MixedSqlNode(contents);
        }
    
        /** * Node 处理器接口 */
        private interface NodeHandler { 
    
            /** * 处理 Node * * @param nodeToHandle 要处理的 XNode 节点 * @param targetContents 目标的 SqlNode 数组。实际上，被处理的 XNode 节点会创建成对应的 SqlNode 对象，添加到 targetContents 中 */
            void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
    
        }
    
        /** * `<bind />` 标签的处理器 * * @see VarDeclSqlNode */
        private class BindHandler implements NodeHandler { 
    
            public BindHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析 name、value 属性
                final String name = nodeToHandle.getStringAttribute("name");
                final String expression = nodeToHandle.getStringAttribute("value");
                // 创建 VarDeclSqlNode 对象
                final VarDeclSqlNode node = new VarDeclSqlNode(name, expression);
                // 添加到 targetContents 中
                targetContents.add(node);
            }
        }
    
        /** * `<trim />` 标签的处理器 * * @see TrimSqlNode */
        private class TrimHandler implements NodeHandler { 
    
            public TrimHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 获得 prefix、prefixOverrides、"suffix"、suffixOverrides 属性
                String prefix = nodeToHandle.getStringAttribute("prefix");
                String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
                String suffix = nodeToHandle.getStringAttribute("suffix");
                String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
                // 创建 TrimSqlNode 对象
                TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
                // 添加到 targetContents 中
                targetContents.add(trim);
            }
    
        }
    
        /** * `<where />` 标签的处理器 * * @see WhereSqlNode */
        private class WhereHandler implements NodeHandler { 
    
            public WhereHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 创建 WhereSqlNode 对象
                WhereSqlNode where = new WhereSqlNode(configuration, mixedSqlNode);
                // 添加到 targetContents 中
                targetContents.add(where);
            }
    
        }
    
        /** * `<set />` 标签的处理器 * * @see SetSqlNode */
        private class SetHandler implements NodeHandler { 
    
            public SetHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 创建 SetSqlNode 对象
                SetSqlNode set = new SetSqlNode(configuration, mixedSqlNode);
                // 添加到 targetContents 中
                targetContents.add(set);
            }
    
        }
    
        /** * `<foreach />` 标签的处理器 * * @see ForEachSqlNode */
        private class ForEachHandler implements NodeHandler { 
    
            public ForEachHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 获得 collection、item、index、open、close、separator 属性
                String collection = nodeToHandle.getStringAttribute("collection");
                String item = nodeToHandle.getStringAttribute("item");
                String index = nodeToHandle.getStringAttribute("index");
                String open = nodeToHandle.getStringAttribute("open");
                String close = nodeToHandle.getStringAttribute("close");
                String separator = nodeToHandle.getStringAttribute("separator");
                // 创建 ForEachSqlNode 对象
                ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, index, item, open, close, separator);
                // 添加到 targetContents 中
                targetContents.add(forEachSqlNode);
            }
    
        }
    
        /** * `<if />` 标签的处理器 * * @see IfSqlNode */
        private class IfHandler implements NodeHandler { 
    
            public IfHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 获得 test 属性
                String test = nodeToHandle.getStringAttribute("test");
                // 创建 IfSqlNode 对象
                IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
                // 添加到 targetContents 中
                targetContents.add(ifSqlNode);
            }
    
        }
    
        /** * `<otherwise />` 标签的处理器 */
        private class OtherwiseHandler implements NodeHandler { 
    
            public OtherwiseHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                // 解析内部的 SQL 节点，成 MixedSqlNode 对象
                MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
                // 添加到 targetContents 中
                targetContents.add(mixedSqlNode);
            }
    
        }
    
        /** * `<choose />` 标签的处理器 * * @see ChooseSqlNode */
        private class ChooseHandler implements NodeHandler { 
    
            public ChooseHandler() { 
                // Prevent Synthetic Access
            }
    
            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) { 
                List<SqlNode> whenSqlNodes = new ArrayList<>();
                List<SqlNode> otherwiseSqlNodes = new ArrayList<>();
                // 解析 `<when />` 和 `<otherwise />` 的节点们
                handleWhenOtherwiseNodes(nodeToHandle, whenSqlNodes, otherwiseSqlNodes);
                // 获得 `<otherwise />` 的节点
                SqlNode defaultSqlNode = getDefaultSqlNode(otherwiseSqlNodes);
                // 创建 ChooseSqlNode 对象
                ChooseSqlNode chooseSqlNode = new ChooseSqlNode(whenSqlNodes, defaultSqlNode);
                // 添加到 targetContents 中
                targetContents.add(chooseSqlNode);
            }
    
            private void handleWhenOtherwiseNodes(XNode chooseSqlNode, List<SqlNode> ifSqlNodes, List<SqlNode> defaultSqlNodes) { 
                List<XNode> children = chooseSqlNode.getChildren();
                for (XNode child : children) { 
                    String nodeName = child.getNode().getNodeName();
                    NodeHandler handler = nodeHandlerMap.get(nodeName);
                    if (handler instanceof IfHandler) {  // 处理 `<when />` 标签的情况
                        handler.handleNode(child, ifSqlNodes);
                    } else if (handler instanceof OtherwiseHandler) {  // 处理 `<otherwise />` 标签的情况
                        handler.handleNode(child, defaultSqlNodes);
                    }
                }
            }
    
            // 至多允许有一个 SqlNode 节点
            private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) { 
                SqlNode defaultSqlNode = null;
                if (defaultSqlNodes.size() == 1) { 
                    defaultSqlNode = defaultSqlNodes.get(0);
                } else if (defaultSqlNodes.size() > 1) { 
                    throw new BuilderException("Too many default (otherwise) elements in choose statement.");
                }
                return defaultSqlNode;
            }
        }
    
    }

### 二、 ###

#### Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？ ####

延迟加载主要通过动态代理实现，通过代理拦截指定方法没执行数据加载。

javassisProxyFactory会创建一个User代理对象，所有调用User对象方法，都会经过EnhancedResultObjectProxyImpl.invoke()方法的拦截。、

于是当调用User.getOrder()方法时，才真正去执行查询Order的动作并把结果赋值

<settings>
        
        <setting name="lazyLoadingEnabled" value="true"/>
        
        <setting name="aggressiveLazyLoading" value="false"/>    
    </settings>
    <mapper namespace="demo.cyj.dao.TeacherDao">
        <select id="findTeacherByTname" resultType="Teacher" resultMap="getTeacher">
            select t.t_id t_id,t.t_name t_name from teacher t where t.t_name =#{name}
        </select>
    	//延迟加载
        <resultMap type="Teacher" id="getTeacher">
            <collection ofType="Student" property="stuList" fetchType="lazy" column="t_name" select="findTeacherByTnameLazy" />
        </resultMap>
    
        <select id="findTeacherByTnameLazy" resultType="Student" >
            select s.id id,s.stu_name stu_name,s.stu_age age,s.t_id t_id from student s left join teacher t on t.t_id = s.t_id where t.t_name=#{name} 
        </select>       
    </mapper>

#### 2.延迟加载的类 ####

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (closed) { 
          throw new ExecutorException("Executor was closed.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) { 
          clearLocalCache();
        }
        List<E> list;
        try { 
          queryStack++;
          list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
          if (list != null) { 
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
          } else { 
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
          }
        } finally { 
          queryStack--;
        }
        if (queryStack == 0) { 
          for (DeferredLoad deferredLoad : deferredLoads) { 
            deferredLoad.load();
          }
          // issue #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { 
            // issue #482
            clearLocalCache();
          }
        }
        return list;
      }

延迟加载的类

private static class DeferredLoad {
    
        private final MetaObject resultObject;
        private final String property;
        private final Class<?> targetType;
        private final CacheKey key;
        private final PerpetualCache localCache;
        private final ObjectFactory objectFactory;
        private final ResultExtractor resultExtractor;
    
        // issue #781
        public DeferredLoad(MetaObject resultObject,
                            String property,
                            CacheKey key,
                            PerpetualCache localCache,
                            Configuration configuration,
                            Class<?> targetType) {
          this.resultObject = resultObject;
          this.property = property;
          this.key = key;
          this.localCache = localCache;
          this.objectFactory = configuration.getObjectFactory();
          this.resultExtractor = new ResultExtractor(configuration, objectFactory);
          this.targetType = targetType;
        }
    
        public boolean canLoad() {
          return localCache.getObject(key) != null && localCache.getObject(key) != EXECUTION_PLACEHOLDER;
        }
    
        public void load() {
          @SuppressWarnings( "unchecked" )
          // we suppose we get back a List
          List<Object> list = (List<Object>) localCache.getObject(key);
          Object value = resultExtractor.extractObjectFromList(list, targetType);
          resultObject.setValue(property, value);
        }
    
      }

### 三 ###

#### 1.Mybatis都有哪些Executor执行器 ####

**BaseExecutor** 简单执行器，是 MyBatis 中默认使用的执行器，每执行一次 update 或 select，就开启一个 Statement 对象，用完就直接关闭 Statement 对象(可以是 Statement 或者是 PreparedStatment 对象)  
**BatchExecutor** 批处理执行器，用于将多个SQL一次性输出到数据库  
**simpleExexutor** 每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LX6M9gvA-1597914279840)(C:\\Users\\gaoyuan\\Desktop\\simpleExexutor.png)\]

**ReuseExecutor** 执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map内，供下一次使用。简言之，就是重复使用Statement对象。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MzQ5OTgy_size_16_color_FFFFFF_t_70_pic_center]

## cachingExecutor 更新缓存 ##

#### 2.它们之间的区别是什么？ ####

作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

默认是SimplExcutor，需要配置在创建SqlSession对象的时候指定执行器的类型即可。

### 四 ###

#### 1.一级缓存 ####

Mybatis的一级缓存是指SqlSession级别的，作用域是SqlSession，Mybatis默认开启一级缓存，在同一个SqlSession中，相同的Sql查询的时候，第一次查询的时候，就会从缓存中取，如果发现没有数据，那么就从数据库查询出来，并且缓存到HashMap中，如果下次还是相同的查询，就直接从缓存中查询，就不在去查询数据库，对应的就不在去执行SQL语句。当查询到的数据，进行增删改的操作的时候，缓存将会失效

#### 2. 二级缓存 ####

MyBatis的二级缓存是基于Mapper级别的，也就是说多个SqlSession去使用某个Mapper的查询语句时，得到的缓存数据是可共用的。第一次调用mapper下的sql 的时候去查询信息，查询到的信息会存放到该mapper对应的二级缓存区域，第二次调用namespace下的mapper映射文件中，相同的SQL去查询，回去对应的二级缓存内取结果。二级缓存开启后，查询就会走二级缓存，没查到直接查库。MyBatis默认不开启二级缓存

### 五 ###

简述Mybatis的插件运行原理，以及如何编写一个插件？

### 插件运行原理 ###

实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可

实现Interceptor接口 在定义StatementHandler处理器的时候拦截prepare方法也就是准备的方法

//1.configuration.newStatementHandler()获取对象
      public int doUpdate(MappedStatement ms, Object parameter) throws 	SQLException { 
        Statement stmt = null;
          Configuration configuration = ms.getConfiguration();
          //定义StatementHandler处理器
          StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
          //初始化
          stmt = prepareStatement(handler, ms.getStatementLog());
          //执行
          return handler.update(stmt);
       
      }
      //2.获取执行sql的StatementHandler组件
        public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        //代理对象
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
      }
      //3.
      public class InterceptorChain { 
    
      private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    
      public Object pluginAll(Object target) { 
        for (Interceptor interceptor : interceptors) { 
          target = interceptor.plugin(target);
        }
        return target;
      }
      }

### 如何编写插件 ###

实现Interceptor接口，Interceptors注解表明要拦截的类，方法，参数

package com.lagou.plugin;
    
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.plugin.*;
    
    import java.sql.Connection;
    import java.util.Properties;
    
        @Intercepts({ 
                @Signature(type= StatementHandler.class,//拦截那个接口
                        method = "prepare",//这个接口内的那个方法名
                        args={ Connection.class,Integer.class})//拦截方法的入参，如果方法重载，通过方法名跟参数确定唯一
        })
        public class MyPlugin implements Interceptor { 
            //这里是每次执行操作的时候，都会进行这个方法
            @Override
            public Object intercept(Invocation invocation) throws Throwable { 
                System.out.println("增强了");
                return invocation.proceed();
            }
    
            //把这个拦截器生成一个代理放到拦截器链中
            @Override
            public Object plugin(Object target) { 
                System.out.println("将要包装的目标对象"+target);
                return Plugin.wrap(target,this);
            }
            //插件初始化时候调用，只调用一次 获取配置文件的属性
            @Override
            public void setProperties(Properties properties) { 
                System.out.println("获取配置文件的属性"+properties);
            }
        }
    
    
    
    
    tementHandler);
        return statementHandler;
      }
      //3.
      public class InterceptorChain { 
    
      private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
    
      public Object pluginAll(Object target) { 
        for (Interceptor interceptor : interceptors) { 
          target = interceptor.plugin(target);
        }
        return target;
      }
      }

### 如何编写插件 ###

实现Interceptor接口，Interceptors注解表明要拦截的类，方法，参数

package com.lagou.plugin;
    
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.plugin.*;
    
    import java.sql.Connection;
    import java.util.Properties;
    
        @Intercepts({ 
                @Signature(type= StatementHandler.class,//拦截那个接口
                        method = "prepare",//这个接口内的那个方法名
                        args={ Connection.class,Integer.class})//拦截方法的入参，如果方法重载，通过方法名跟参数确定唯一
        })
        public class MyPlugin implements Interceptor { 
            //这里是每次执行操作的时候，都会进行这个方法
            @Override
            public Object intercept(Invocation invocation) throws Throwable { 
                System.out.println("增强了");
                return invocation.proceed();
            }
    
            //把这个拦截器生成一个代理放到拦截器链中
            @Override
            public Object plugin(Object target) { 
                System.out.println("将要包装的目标对象"+target);
                return Plugin.wrap(target,this);
            }
            //插件初始化时候调用，只调用一次 获取配置文件的属性
            @Override
            public void setProperties(Properties properties) { 
                System.out.println("获取配置文件的属性"+properties);
            }
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MzQ5OTgy_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/0ca5fe0b340a468eb1d2b57fa15274ed.png