Mybatis原理学习

怼烎@ 2023-02-22 05:13 6阅读 0赞

# Mybatis原理学习 #

学习文档 ----jdbc的中文文档 更多的是使用

http://www.mybatis.cn/archives/789.html

## 入门demo ##

下面是mybatis的入门demo

<dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>x.x.x</version>
    </dependency>

String resource = "org/mybatis/example/mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

<?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"/>
          <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>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
      </mappers>
    </configuration>

try (SqlSession session = sqlSessionFactory.openSession()) { 
      BlogMapper mapper = session.getMapper(BlogMapper.class);
      Blog blog = mapper.selectBlog(101);
    }

大家应该都能看懂 主要就是 SqlSessionFactory SqlSession Mapper的使用 实体类这里就不贴了 大家都会写

下面会一步步介绍 这几个底层说明

## 先从JDBC说起 ##

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NyKfT9m4-1593607466891)(C:\\Users\\caomingxing6\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200628164628544.png)\]

JDBC为程序员提供了一套标准统一的API去访问不同的数据库。

JDBC访问数据库流程：  
（1）注册驱动  
（2）建立连接  
（3）创建数据库操作对象用于执行SQL的语句  
（4）执行语句  
（5）处理执行结果  
（6）释放db资源

代码如下：

import java.sql.*;
    public class JDBConnection 
    { 
        public static String url_encrypt="jdbc:mysql://127.0.0.1:3306/student?useSSL=false";
        public static String user="root";
        public static String password="longdaye";
    
        public static void main(String[] args) throws Exception
        { 
            Class.forName("com.mysql.jdbc.Driver");
            //建立数据库对象
            Connection conn  = DriverManager.getConnection(url_encrypt,user,password);
            //建立操作对象
            Statement stmt= conn.createStatement();
            //结果集
            ResultSet rs = stmt.executeQuery("select * from information");
            //依次输出结果集内容
            while(rs.next()){ 
            System.out.println(
                rs.getInt(1) + "\t"
               +rs.getString(2)+"\t"
               +rs.getString(3)+"\t"
               +rs.getInt(4)+"\t"
               +rs.getString(5)+"\t");
            }
            //依次关闭结果集，操作对象，数据库对象
            if(rs!=null){ 
                rs.close();
            }
            if(stmt!=null){ 
                stmt.close();
            }
            if(conn!=null){ 
                conn.close();
            }
        }
    }

mybatis 底层使用的是PrepareStatement实现 。

PrepareStatement使用更方便一点，性能更好，且能**避免sql注入**，有了mybatis之后 我们不会去写这些代码。

PrepareStatement先写sql 再对sql中的参数？赋值 where pwd=‘1 or 1=1’

Statement 出来的是 where pwd='1‘ or 1=1 这样密码就无效了 所有的都会查出来

不是重点 jdbc都学过。

## 全局配置文件解析 ##

new SqlSessionFactoryBuilder().build(inputStream);

解析xml 文件 生成Configuration对象

源码如下：

//解析生成Configuration 对象 
    public Configuration parse() { 
        if (parsed) { 
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
    
    //对应解析生成的不同节点
      private void parseConfiguration(XNode root) { 
        try { 
          //issue #117 read properties first
          propertiesElement(root.evalNode("properties"));
          Properties settings = settingsAsProperties(root.evalNode("settings"));
          loadCustomVfs(settings);
          typeAliasesElement(root.evalNode("typeAliases"));
          pluginElement(root.evalNode("plugins"));
          objectFactoryElement(root.evalNode("objectFactory"));
          objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
          reflectorFactoryElement(root.evalNode("reflectorFactory"));
          settingsElement(settings);
          // read it after objectFactory and objectWrapperFactory issue #631
          environmentsElement(root.evalNode("environments"));
          databaseIdProviderElement(root.evalNode("databaseIdProvider"));
          typeHandlerElement(root.evalNode("typeHandlers"));
            //映射器的代码解析
          mapperElement(root.evalNode("mappers"));
        } catch (Exception e) { 
          throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
      }

private void mapperElement(XNode parent) throws Exception { 
        if (parent != null) { 
          for (XNode child : parent.getChildren()) { 
              //package方式
            if ("package".equals(child.getName())) { 
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else { 
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
                //3个属性只能配一个
                
                //resouce方式---mapper.xml 常见
              if (resource != null && url == null && mapperClass == null) { 
                ErrorContext.instance().resource(resource);
                InputStream inputStream = Resources.getResourceAsStream(resource);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url != null && mapperClass == null) { 
                  //url 远程机器上的输入流
                ErrorContext.instance().resource(url);
                InputStream inputStream = Resources.getUrlAsStream(url);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url == null && mapperClass != null) { 
                  //class 指定一个接口
                Class<?> mapperInterface = Resources.classForName(mapperClass);
                configuration.addMapper(mapperInterface);
              } else { 
                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
              }
            }
          }
        }
      }

不管是使用注解 还是使用xml 配置mapper的方法 最终都会转换成MappedStatement对象 ，将MappedStatement对象的属性加到Configuration里面

使用的StrictHashMap 同样的key put 会报错

如果同时配置了注解和xml 会报错 因为生成的MappedStatement的id相同 put的时候会报错

//解析xml中的文件
    private void configurationElement(XNode context) { 
        try { 
          String namespace = context.getStringAttribute("namespace");
          if (namespace == null || namespace.equals("")) { 
            throw new BuilderException("Mapper's namespace cannot be empty");
          }
          builderAssistant.setCurrentNamespace(namespace);
          cacheRefElement(context.evalNode("cache-ref"));
          cacheElement(context.evalNode("cache"));
          parameterMapElement(context.evalNodes("/mapper/parameterMap"));
            //resultmap
          resultMapElements(context.evalNodes("/mapper/resultMap"));
          sqlElement(context.evalNodes("/mapper/sql"));
            //增删改查
          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);
        }
      }

//解析buildStatementFromContext里面的每一个sql 解析里面的属性值 转换成MappedStatement
    public void parseStatementNode() { 
        String id = context.getStringAttribute("id");
        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");
        //语言解析器 解析#id 可以自己指定 默认是有的 XMLLanguageDriver
        LanguageDriver langDriver = getLanguageDriver(lang);
    
        Class<?> resultTypeClass = resolveClass(resultType);
        String resultSetType = context.getStringAttribute("resultSetType");
        StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
        ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    
        String nodeName = context.getNode().getNodeName();
        SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
        boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
        boolean useCache = context.getBooleanAttribute("useCache", isSelect);
        boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
    
        // Include Fragments before parsing
        XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
        includeParser.applyIncludes(context.getNode());
    
        // Parse selectKey after includes and remove them.
        processSelectKeyNodes(id, parameterTypeClass, langDriver);
        
        // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
        //核心 是转换成SqlSource $---对应的是动态sql 如果没有$都是#就是静态sql
        SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
        String resultSets = context.getStringAttribute("resultSets");
        String keyProperty = context.getStringAttribute("keyProperty");
        String keyColumn = context.getStringAttribute("keyColumn");
        KeyGenerator keyGenerator;
        String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
        keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
        if (configuration.hasKeyGenerator(keyStatementId)) { 
          keyGenerator = configuration.getKeyGenerator(keyStatementId);
        } else { 
          keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
              configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
              ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
        }
    	//增加MappedStatement
        builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
            fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
            resultSetTypeEnum, flushCache, useCache, resultOrdered, 
            keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
      }

语言解析器 会将sql 转换成SqlSource 可以自己调试一下

#### 静态sql ####

select \* from user where id = \#\{id\}

语言解析器会解析成 select \* from user where id = ？ -------------对应的就是jdbc的语法

执行sql的时候才对 ? 赋值

#### 动态sql ####

解析配置文件的时候sql 是什么样子 就是什么样子 执行的时候才会做

select \* from user where id = $\{id\}

**− − − 对 应 的 是 动 态 s q l 如 果 没 有 ---对应的是动态sql 如果没有 −−−对应的是动态sql如果没有都是\#就是静态sql**

动态sql 可能会出现sql注入 尽可能用\#

动态sql 使用是在 select的值用

select $\{id\} from user;

这里不能用\# 用\#传进去的就是一个字符串 传的什么查的就是什么

## sql调用 ##

session.getMapper(BlogMapper.class)

getMapper是利用动态代理获取 一个代理对象

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { 
          //利用代理工厂 
        final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
        if (mapperProxyFactory == null) { 
          throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        }
        try { 
            //创建一个实例对象 调用的jdk的动态代理
          return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception e) { 
          throw new BindingException("Error getting mapper instance. Cause: " + e, e);
        }
      }
    
      protected T newInstance(MapperProxy<T> mapperProxy) { 
          //jdk的动态代理
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {  mapperInterface }, mapperProxy);
      }
    
      public T newInstance(SqlSession sqlSession) { 
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }

调用方法的时候会进入到invoke

// MapperProxy
    @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        try { 
          if (Object.class.equals(method.getDeclaringClass())) { 
            return method.invoke(this, args);
          } else if (isDefaultMethod(method)) { 
            return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) { 
          throw ExceptionUtil.unwrapThrowable(t);
        }
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }

//方法的执行 MapperMethod
    public Object execute(SqlSession sqlSession, Object[] args) { 
        Object result;
        switch (command.getType()) { 
          case INSERT: { 
          Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
          case UPDATE: { 
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
          }
          case DELETE: { 
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.delete(command.getName(), param));
            break;
          }
          case SELECT:
            if (method.returnsVoid() && method.hasResultHandler()) { 
              executeWithResultHandler(sqlSession, args);
              result = null;
            } else if (method.returnsMany()) { 
              result = executeForMany(sqlSession, args);
            } else if (method.returnsMap()) { 
              result = executeForMap(sqlSession, args);
            } else if (method.returnsCursor()) { 
              result = executeForCursor(sqlSession, args);
            } else { 
                //转换函数参数到sql中的参数 @param注解 看参数使用的param1 param2 还是arg0 arg1 如果都没有会报错 或者用map 做函数的入参
              Object param = method.convertArgsToSqlCommandParam(args);
              result = sqlSession.selectOne(command.getName(), param);
            }
            break;
          case FLUSH:
            result = sqlSession.flushStatements();
            break;
          default:
            throw new BindingException("Unknown execution method for: " + command.getName());
        }
        if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { 
          throw new BindingException("Mapper method '" + command.getName() 
              + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
        }
        return result;
      }

@Override
      public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
        try { 
          MappedStatement ms = configuration.getMappedStatement(statement);
            //executor 执行最终的sql
          return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }
       Object parameter, RowBounds rowBounds) { 
        try { 
          MappedStatement ms = configuration.getMappedStatement(statement);
            //executor 执行最终的sql
          return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }