### 准备

在阅读源码前,需要先clone源码 地址:https://github.com/mybatis/mybatis-3

>Mybatis框架使用大量常见的设计模式,学习Mybatis源码我们主要学习以下几点:

- 学习大佬们的编码思想及规范
- 学习一些传承下来的设计模式
- 实践java基础理论

>带着问题阅读源码 

- 问题1:源码中用了哪些设计模式？为什么要用这些设计模式？
- 问题2.Mybatis打开调试模式之后，能打印sql语句等信息，这是怎么实现的？实现过程中使用了什么设计模式？假如有多个日志实现,加载顺序是什么?


带着这些个问题 我们去源码中找寻答案
首先我们先来看看源码包功能模块图 
![image.png](http://liangtengyu.com/opt/deploy/upload/9eef3423-1606354697191.png)
Mybatis框架提供了一个顶层接口`SqlSession` ,核心处理层,基础支撑层 这里使用了一个常见的设计模式:`外观模式/门面模式`
今天我们主要讲解`基础支撑层`中`日志模块`内部是如何处理的.

### 源码-logging

打开源码项目,可以看到有20个目录,这里我们先不深入去看,把目光聚焦到logging目录
![image.png](http://liangtengyu.com/opt/deploy/upload/349d6bed-1606355259874.png)
打开目录,我们可以看到映入眼帘的就是 *Log*   *LogException*    *LogFactory*  (红色部分)和具体的日志实现(黄色部分),
![image.png](http://liangtengyu.com/opt/deploy/upload/b1303293-1606355485078.png)
打开Log接口,我们可以看到Log接口提供了七个接口方法
![image.png](http://liangtengyu.com/opt/deploy/upload/7a064b4f-1606355877768.png)
实现这个接口的实现方法我们看看都是谁呢,可以看到就是我们刚刚黄色框框部分,那么他是怎么来处理那么多Log实现的呢,别急,继续往下看
![image.png](http://liangtengyu.com/opt/deploy/upload/d4635646-1606355934556.png)
我们随便打开一个Log的实现类,可一看到实际上这并不是真正的实现了所需要的Log只是在对每个用到的Log实现做了参数适配而已
(其他的类也是类似,这里使用了适配器模式)
![image.png](http://liangtengyu.com/opt/deploy/upload/b12347ff-1606356255602.png)
那么有那么多日志实现,他的加载顺序是什么呢.到这里我们会想到刚刚看到的LogFactory类,大叫都知道工厂方法就是用来获取实例的既然要获取实例那么他的处理也肯定在工厂内部处理完毕了(这里使用了简单工厂模式) 那么我们打开LogFactory类来看看他的加载顺序到底是怎么实现的:

```java 
import java.lang.reflect.Constructor;


public final class LogFactory {


  public static final String MARKER = "MYBATIS";

  private static Constructor<? extends Log> logConstructor; //定义logConstructor 他继承于Constructor

  static {	//加载顺序在这里.初始化时必定按照这个顺序执行,可以发现下面这一排排就是我们刚刚看到的各个适配器
    tryImplementation(LogFactory::useSlf4jLogging);
    tryImplementation(LogFactory::useCommonsLogging);
    tryImplementation(LogFactory::useLog4J2Logging);
    tryImplementation(LogFactory::useLog4JLogging);
    tryImplementation(LogFactory::useJdkLogging);
    tryImplementation(LogFactory::useNoLogging);
  }

  private LogFactory() {
    // 在这里私有化构造器 就不能通过new来创建实例了
  }

  public static Log getLog(Class<?> clazz) {//第一步.如果我们需要一个Log 那么我们就调用这个方法,传入需要的类即可
    return getLog(clazz.getName());
  }

  public static Log getLog(String logger) {//第二步.根据类的名字获取Log实现.如果获取不到会报错,这个logConstructor就是我们上面的,他内部在初始化时已经通过static的静态代码块进行了处理,所以会处理为对应的日志实现,
    try {
      return logConstructor.newInstance(logger);
    } catch (Throwable t) {
      throw new LogException("Error creating logger for logger " + logger + ".  Cause: " + t, t);
    }
  }

  public static synchronized void useCustomLogging(Class<? extends Log> clazz) {
    setImplementation(clazz);
  }

  public static synchronized void useSlf4jLogging() {//每个静态同步方法都是去调用setImplementation
    setImplementation(org.apache.ibatis.logging.slf4j.Slf4jImpl.class);
  }

  public static synchronized void useCommonsLogging() {
    setImplementation(org.apache.ibatis.logging.commons.JakartaCommonsLoggingImpl.class);
  }

  public static synchronized void useLog4JLogging() {
    setImplementation(org.apache.ibatis.logging.log4j.Log4jImpl.class);
  }

  public static synchronized void useLog4J2Logging() {
    setImplementation(org.apache.ibatis.logging.log4j2.Log4j2Impl.class);
  }

  public static synchronized void useJdkLogging() {
    setImplementation(org.apache.ibatis.logging.jdk14.Jdk14LoggingImpl.class);
  }

  public static synchronized void useStdOutLogging() {
    setImplementation(org.apache.ibatis.logging.stdout.StdOutImpl.class);
  }

  public static synchronized void useNoLogging() {
    setImplementation(org.apache.ibatis.logging.nologging.NoLoggingImpl.class);
  }

  private static void tryImplementation(Runnable runnable) {//将传入的代码块执行,注意这里是.run 不是.start 
    if (logConstructor == null) {//如果还没有实现才执行
      try {
        runnable.run();
      } catch (Throwable t) {//如果加载这个实现出现了异常,如:ClassNotFoundException 这个时候直接忽略,等待下一个实现调用
        // ignore
      }
    }
  }
		//在获取到一个实现成功后 会调用这个方法来初始化Log
  private static void setImplementation(Class<? extends Log> implClass) {
    try {
      Constructor<? extends Log> candidate = implClass.getConstructor(String.class);
      Log log = candidate.newInstance(LogFactory.class.getName());
      if (log.isDebugEnabled()) {
        log.debug("Logging initialized using '" + implClass + "' adapter.");
      }
      logConstructor = candidate;
    } catch (Throwable t) {
      throw new LogException("Error setting Log implementation.  Cause: " + t, t);
    }
  }

}

```

回顾一下问题:源码中用了哪些设计模式？
到目前我们看到Mybatis使用了 1.外观模式/门面模式 2.适配器模式 3简单工厂模式
到这里我们已经拿到了Log的实例不管他是通过log4j还是slf4j的实现,那他是怎么实现对日志进行增强的呢 怎么打印出来的SQL语句和参数以及结果计数的?
如果想要输出这些信息,那么首先肯定要获取到这些信息.
下面我们就去看这块,看看他是怎么获取和存贮这些信息的.
![image.png](http://liangtengyu.com/opt/deploy/upload/41204163-1606358700692.png)

```java
public abstract class BaseJdbcLogger {

  protected static final Set<String> SET_METHODS;//set方法容器
  protected static final Set<String> EXECUTE_METHODS = new HashSet<>();//执行方法容器

  private final Map<Object, Object> columnMap = new HashMap<>();//列的键值对

  private final List<Object> columnNames = new ArrayList<>();//所有key的列表
  private final List<Object> columnValues = new ArrayList<>();//所有value的列表

  protected final Log statementLog;  // Log实现
  protected final int queryStack;

  /*
   * Default constructor
   */
  public BaseJdbcLogger(Log log, int queryStack) {//默认的构造
    this.statementLog = log;
    if (queryStack == 0) {
      this.queryStack = 1;
    } else {
      this.queryStack = queryStack;
    }
  }

  static {//初始化 就加载两个容器 这两个容器用来装所有的预编译set参数的方法和所有执行方法
    SET_METHODS = Arrays.stream(PreparedStatement.class.getDeclaredMethods())//这里使用JAVA8新特性将PreparedStatement类的所有set开头的方法映射成一个Set
            .filter(method -> method.getName().startsWith("set"))
            .filter(method -> method.getParameterCount() > 1)
            .map(Method::getName)
            .collect(Collectors.toSet());

    EXECUTE_METHODS.add("execute");//将4个执行方法添加到EXECUTE_METHODS这个Set
    EXECUTE_METHODS.add("executeUpdate");
    EXECUTE_METHODS.add("executeQuery");
    EXECUTE_METHODS.add("addBatch");
  }

  protected void setColumn(Object key, Object value) {
    columnMap.put(key, value);
    columnNames.add(key);
    columnValues.add(value);
  }

  protected Object getColumn(Object key) {
    return columnMap.get(key);
  }

  protected String getParameterValueString() {
    List<Object> typeList = new ArrayList<>(columnValues.size());
    for (Object value : columnValues) {
      if (value == null) {
        typeList.add("null");
      } else {
        typeList.add(objectValueString(value) + "(" + value.getClass().getSimpleName() + ")");
      }
    }
    final String parameters = typeList.toString();
    return parameters.substring(1, parameters.length() - 1);
  }

  protected String objectValueString(Object value) {
    if (value instanceof Array) {
      try {
        return ArrayUtil.toString(((Array) value).getArray());
      } catch (SQLException e) {
        return value.toString();
      }
    }
    return value.toString();
  }

  protected String getColumnString() {
    return columnNames.toString();
  }

  protected void clearColumnInfo() {
    columnMap.clear();
    columnNames.clear();
    columnValues.clear();
  }

  protected String removeExtraWhitespace(String original) {
    return SqlSourceBuilder.removeExtraWhitespaces(original);
  }

  protected boolean isDebugEnabled() {
    return statementLog.isDebugEnabled();
  }

  protected boolean isTraceEnabled() {
    return statementLog.isTraceEnabled();
  }

  protected void debug(String text, boolean input) {
    if (statementLog.isDebugEnabled()) {
      statementLog.debug(prefix(input) + text);
    }
  }

  protected void trace(String text, boolean input) {
    if (statementLog.isTraceEnabled()) {
      statementLog.trace(prefix(input) + text);
    }
  }

  private String prefix(boolean isInput) {
    char[] buffer = new char[queryStack * 2 + 2];
    Arrays.fill(buffer, '=');
    buffer[queryStack * 2 + 1] = ' ';
    if (isInput) {
      buffer[queryStack * 2] = '>';
    } else {
      buffer[0] = '<';
    }
    return new String(buffer);
  }

}
```
到这我们知道了他是怎么存贮信息的获取的方式就是在调用时通过存贮的方法和set方法列表来查询,那么他是什么时候被调用呢?仔细看看这个图我们发现了端倪 在BaseJdbcLogger下面还有
- ConnectionLogger
- PreparedStatementLogger
- ResultSetLogger
- StatementLogger
这些不就是我们很眼熟的流程吗 获取数据库连接-->  预编译SQL-->  执行SQL-->  获取结果 
![image.png](http://liangtengyu.com/opt/deploy/upload/41204163-1606358700692.png)
我们随便打开一个 看看他们是怎么在自己的一亩三分地干活的
```java
public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {//继承于BaseJdbcLogger 实现InvocationHandler 看到InvocationHandler 就会想到->代理模式

  private final Connection connection;//他实要代理的就是这connection

  private ConnectionLogger(Connection conn, Log statementLog, int queryStack) {
    super(statementLog, queryStack);
    this.connection = conn;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] params)
      throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, params);
      }
      if ("prepareStatement".equals(method.getName()) || "prepareCall".equals(method.getName())) {//判断方法名是不是这两中的一个 短语或 有一个就为true
        if (isDebugEnabled()) {//原来开启debug 就会打出日志是在这里呀
          debug(" Preparing: " + removeExtraWhitespace((String) params[0]), true);
        }
        PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);// 通过connection创建了PreparedStatement
        stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack); //把stmt 传过去给PreparedStatementLogger的newInstance 创建了一个stmt的代理返回
        return stmt;//注意这里返回的不是真实stmt 而是代理过后的stmt
      } else if ("createStatement".equals(method.getName())) {//如果是创建Statement
        Statement stmt = (Statement) method.invoke(connection, params); //拿到连接去创建一个Statement
        stmt = StatementLogger.newInstance(stmt, statementLog, queryStack);//把Statement传进StatementLogger 获取Statement的代理对象来返回
        return stmt;//注意这里返回的不是真实stmt 而是代理过后的stmt
      } else {
        return method.invoke(connection, params);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  /**
   * Creates a logging version of a connection.
   *
   * @param conn
   *          the original connection
   * @param statementLog
   *          the statement log
   * @param queryStack
   *          the query stack
   * @return the connection with logging
   */
  public static Connection newInstance(Connection conn, Log statementLog, int queryStack) {
    InvocationHandler handler = new ConnectionLogger(conn, statementLog, queryStack);
    ClassLoader cl = Connection.class.getClassLoader();
    return (Connection) Proxy.newProxyInstance(cl, new Class[]{Connection.class}, handler);
  }

  /**
   * return the wrapped connection.
   *
   * @return the connection
   */
  public Connection getConnection() {
    return connection;
  }
```


```java
public final class PreparedStatementLogger extends BaseJdbcLogger implements InvocationHandler {

  private final PreparedStatement statement; //还是一样 这里是被代理的实际对象

  private PreparedStatementLogger(PreparedStatement stmt, Log statementLog, int queryStack) {
    super(statementLog, queryStack);
    this.statement = stmt;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {//增强的逻辑在这里
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, params);
      }
      if (EXECUTE_METHODS.contains(method.getName())) {//还记得那几个容器吗 用来存储各种方法的  现在他来了
        //开启DEBUG 我就把参数打印出来
        if (isDebugEnabled()) {
          debug("Parameters: " + getParameterValueString(), true);
        }
        clearColumnInfo();
        if ("executeQuery".equals(method.getName())) {
          ResultSet rs = (ResultSet) method.invoke(statement, params);//获取到一个resultset
          return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);//把resultset 也代理了来返回
        } else {
          return method.invoke(statement, params);
        }
      } else if (SET_METHODS.contains(method.getName())) {
        if ("setNull".equals(method.getName())) {
          setColumn(params[0], null);
        } else {
          setColumn(params[0], params[1]);
        }
        return method.invoke(statement, params);
      } else if ("getResultSet".equals(method.getName())) {
        ResultSet rs = (ResultSet) method.invoke(statement, params);
        return rs == null ? null : ResultSetLogger.newInstance(rs, statementLog, queryStack);
      } else if ("getUpdateCount".equals(method.getName())) {
        int updateCount = (Integer) method.invoke(statement, params);
        if (updateCount != -1) {
          debug("   Updates: " + updateCount, false);
        }
        return updateCount;
      } else {
        return method.invoke(statement, params);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  /**
   * Creates a logging version of a PreparedStatement.
   *
   * @param stmt - the statement
   * @param statementLog - the statement log
   * @param queryStack - the query stack
   * @return - the proxy
   */
  public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
    InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
    ClassLoader cl = PreparedStatement.class.getClassLoader();
    return (PreparedStatement) Proxy.newProxyInstance(cl, new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
  }

  /**
   * Return the wrapped prepared statement.
   *
   * @return the PreparedStatement
   */
  public PreparedStatement getPreparedStatement() {
    return statement;
  }

}

```
最后是ResultSetLogger
```java
  @Override
  public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {//ResultSetLogger的增强方法
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, params);
      }
      Object o = method.invoke(rs, params);
      if ("next".equals(method.getName())) { 
        if ((Boolean) o) {
          rows++;//只要还有下一条next,就记数加1  rows++;
          if (isTraceEnabled()) {
            ResultSetMetaData rsmd = rs.getMetaData();
            final int columnCount = rsmd.getColumnCount();
            if (first) {
              first = false;
              printColumnHeaders(rsmd, columnCount);
            }
            printColumnValues(columnCount);
          }
        } else {
          debug("     Total: " + rows, false);//开启debug情况下 打印出总数计数
        }
      }
      clearColumnInfo();
      return o;
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }
```

到这里我们基本已经摸完了这块逻辑 现在复盘一下问题
- 问题1.源码中用了哪些设计模式？为什么要用这些设计模式？
	门面/外观模式 适配器模式 代理模式 简单工厂模式. 为什么要使用这些模式 太长了我就不写了,大家自行总结
- 问题2.Mybatis打开调试模式之后，能打印sql语句等信息，这是怎么实现的？实现过程中使用了什么设计模式？假如有多个日志实现,加载顺序是什么?
	在调试模式能打印日志,是mybatis框架在实际执行时对对象进行了代理,进行了增强.他使用了代理设计模式.他实现日志的顺序是:
```java
  static {
    tryImplementation(LogFactory::useSlf4jLogging);
    tryImplementation(LogFactory::useCommonsLogging);
    tryImplementation(LogFactory::useLog4J2Logging);
    tryImplementation(LogFactory::useLog4JLogging);
    tryImplementation(LogFactory::useJdkLogging);
    tryImplementation(LogFactory::useNoLogging);
  }
```

Mybatis源码阅读(一)

 Mybatis数据源结构解析

### Mybatis中重要组件的生命周期
在之前的章节中我们讲了Mybatis一些主要组件的基本用法和配置方式,但是掌握这些主要组件的生命周期也是非常重要的,不能只是单单了解基本的使用方法。这对于MyBatis应⽤的正确性和高性能是极其重要的，我们必须掌握他们

本单主要内容:

以下各组件的生命周期理解:

- SqlSessionFactoryBuilder
- SqlSessionFactory
- SqlSession
- Mapper

#### SqlSessionFactoryBuilder 

>SqlSessionFactoryBuilder是利用XML或者Java编码获得资源来构建SqlSessionFactory
>的，通过它可以构建多个SessionFactory。它的作⽤用就是一个构建器`一旦我们构建了SqlSessionFactory 它的作用就⼰经完结`，失去了存在的意义，这时我们就应该毫不犹豫的废弃它，将它回收。

所以它的⽣命周期只存在于⽅法的局部，`它的作用就是⽣成SqlSessionFactory对象`

#### SqlSessionFactory

>SqlSessionFactory的作用是创建SqlSession，而SqlSession就是一个会话，相当于JDBC
>中的Connection对象。每次应用程序需要访问数据库，我们就要通过SqlSessionFactory创
>建SqlSession，所以`SqlSessionFactory应该在MyBatis应用的整个⽣命周期中`。而如果我们
>多次创建同一个数据库的SqlSessionFactory，则每次创建SqlSessionFactory会打开更更多的数
>据库连接（Connection）资源，那么连接资源就很快会被耗尽(这就很严重!)

因此SqlSessionLFactory的责任是唯一的，它的责任就是创建SqlSession，所以我们果断采用单例模式。如果我们采用多例，那么它对数据库连接的消耗是很大的，不利于我们统⼀的管理,所以正确的做法应该是使得每⼀个数据库只对应一个SqlSessionFactory，管理好
数据库资源的分配，避免过多的Connection被占用,导致数据库连接被占满.
#### SqlSession

>SqlSession是⼀个会话，相当于JDBC的一个Connection对象，它的⽣命周期应该是
>`在请求数据库处理事务的过程中`

它是一个线程不安全的对象，在涉及多线程的时候我们
需要特别的当心，操作数据库需要注意其隔离级别，数据库锁等⾼级特性。此外，每次创
建的SqlSession都必须及时关闭它，它长期存在就会使数据库连接池的活动资源减少，对
系统性能的影响很大。正如Mybatis源码阅读(一)中的代码⼀样，我们往往通过finally语句块保证我们正确
的关闭了SqlSession

#### Mapper

Mapper是个接⼝，⽽没有任何实现类，它的作⽤是发送SQL，然后返回我们需要的结果 `因此它的生命周期应该在⼀个SqlSession事务⽅法之内`，它的最大范围和SqlSession是相同的


### 总结
有了上面的叙述后,我们已经清楚了 Mybatis各组件的生命周期和联系:


![](pic/e3b67df9-2c90-46c6-ae28-907f5bd976df.png)

Mybatis中重要组件的生命周期

MYBATIS映射器解析

hello 我是宝哥 , 接上一篇文章,我们聊到了

[JVM加载类的流程](https://mp.weixin.qq.com/s/waSEkKlpG4dE-4SKbt3uIw)

有面试官会让你解释一下Java的内存模型，有些人解释对了，结果面试官说不对，应该是堆啊、栈啊、方法区什么的（遇到这种面试官,就是你装逼的时刻了..）

看完本篇文章你将了解:
- 1.JVM内存结构
- 2.JVM栈帧剖析
- 3.方法区在JDK1.7和1.8中的区别
- 4.堆分代结构

建议收藏!

[toc]



## JVM内存结构
首先`JVM内存结构`和`JAVA内存模型`是两个概念.

### JVM内存结构:


![](https://imgkr2.cn-bj.ufileos.com/80fb539b-55a6-41ab-a310-2ee0008f4e48.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=1JCdN4gNwPax3cgdRaRdQ9YhBjo%253D&Expires=1615345046)

Class文件通过类加载机制 加载到内存空间,`JVM内存结构`就是上图中内存空间，Java内存模型，则是另外的一个概念. 

>根据《Java 虚拟机规范(Java SE 7 版)》规定，Java 虚拟机所管理的内存如下图所示。

![](https://imgkr2.cn-bj.ufileos.com/041c3924-9e12-4541-a9fa-62ec3a6cdb76.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=8xHAWMc4Hsdt4DglkKQSr7hKnXs%253D&Expires=1615354986)
从上图可看出,运行时数据区分为`五大区域`。这些区域各有各的用途,其中方法区和堆是所有`线程共享`的，栈，本地方法栈和程序计数器则为`线程私有`的。




## 1.程序计数器
>程序计数器是一块很小的内存空间，它是线程私有的，可以认作为当前线程的行号指示器。

为什么要程序计数器呢

因为CPU会在多个线程中切换上下文,需要使用程序计数器`纪录当前线程运行到哪一行了`,等待线程重新获取到运行时间时,继续`从计数的位置往下执行`.至于它是线程私有的,是因为每个线程都需要独立计数,各个线程之间不会产生影响.

`面试题:程序计数器会发生OutOfMemoryError吗?`

答:这块内存区域是虚拟机规范中唯一没有OutOfMemoryError的区域。如果线程执行的是个java方法，那么计数器记录虚拟机字节码指令的地址。如果为native方法，那么计数器为空。

## 2.Java栈（JVM线程栈）
首先我们要记住,栈描述的是方法执行的内存模型,它是线程私有的.
>每个方法被执行的时候都会创建一个栈帧用于存储局部变量表，操作栈，动态链接，方法出口等信息。每一个方法被调用的过程就对应一个栈帧在虚拟机栈中从入栈到出栈的过程,如下图:


![](https://imgkr2.cn-bj.ufileos.com/d0a55166-f722-4e58-89f4-d85b17c0f6ea.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=zYQB9GcPTS9TsCWBmAm7lWuz2hA%253D&Expires=1615355992)



`面试题:Java虚拟机栈可能出现哪两种类型的异常?`

- 1 虚拟机栈是一个栈,当我们的栈帧超过最大深度时,会抛出StackOverflowError
- 2 栈无法申请到足够的空间时，抛出OutOfMemoryError异常


### 栈帧(Stack Frame)
每一个方法从调用至执行完成的过程，都对应着一个栈帧在虚拟机栈里从入栈到出栈的过程,那么一个栈帧包含什么?

- `局部变量表(Local Variable Table)`
也叫`本地变量表`,它所需要的内存空间在编译期完成分配，当进入一个方法时，这个方法在栈中需要分配多大的局部变量空间是完全确定的，在方法运行期间不会改变,它的最小单位为`Slot`,一个Slot可以存放一个`32位以内的数据类型`.虚拟机通过索引定位的方法查找相应的局部变量，索引的范围是从`0~局部变量表最大容量`。如果Slot是32位的，则遇到一个64位数据类型的变量(如long或double型)，则会`使用两个连续的Slot`来存储
- `操作数栈(Operand Stack)`
也常称为`操作栈`，它是一个后入先出栈(LIFO)。当一个方法刚刚开始执行时，其操作数栈是空的，随着方法执行和字节码指令的执行，会从局部变量表或对象实例的字段中复制常量或变量写入到操作数栈，再随着计算的进行将栈中元素出栈到局部变量表或者返回给方法调用者，也就是出栈/入栈操作。一个完整的方法执行期间往往包含多个这样出栈/入栈的过程。
- `动态连接(Dynamic Linking)`
在一个class文件中，一个方法要调用其他方法，需要将这些方法的符号引用转化为其在内存地址中的直接引用，而符号引用存在于方法区中的运行时常量池。
Java虚拟机栈中，每个栈帧都包含一个指向运行时常量池中该栈所属方法的符号引用，持有这个引用的目的是为了支持方法调用过程中的动态连接(Dynamic Linking)。
这些符号引用一部分会在类加载阶段或者第一次使用时就直接转化为直接引用，这类转化称为`静态解析`。另一部分将在每次运行期间转化为直接引用，这类转化称为`动态连接`。
- `方法返回地址(Return address)`
  一般方法执行时,有2种方式会退出该方法
   * 1.`正常退出`
      正常退出指方法正常完成并退出，没有抛出任何异常,当前方法正常完成，则根据当前方法返回的字节码指令，这时有可能会有返回值传递给方法调用者`(调用它的方法)`，或者无返回值`(void)`。具体是否有返回值以及返回值的数据类型将根据该方法返回的字节码指令确定。
   * 2.`异常退出`
      方法执行过程中遇到异常，并且这个异常在方法体内部没有得到处理，导致方法退出,只要在本方法的异常表中没有搜索到相应的异常处理器，就会导致方法退出。
      

   方法退出过程实际上就等同于把当前栈帧出栈，因此退出可以执行的操作有：恢复上层方法的局部变量表和操作数栈，把返回值(如果有的话)压如调用者的操作数栈中，调整PC计数器的值以指向方法调用指令后的下一条指令。
  一般来说，方法正常退出时，调用者的PC计数值可以作为返回地址，栈帧中可能保存此计数值。而方法异常退出时，返回地址是通过异常处理器表确定的，栈帧中一般不会保存此部分信息   

- `附加信息`
指的是在虚拟机实现中加入了一些规范里没有描述的信息到栈帧之中，例如与调试相关的信息。

## 本地方法栈
>本地方法栈是与虚拟机栈发挥的作用十分相似,区别是虚拟机栈执行的是Java方法(也就是字节码)服务，而本地方法栈则为虚拟机使用到的native方法服务，可能底层调用的c或者c++,我们打开jdk安装目录可以看到也有很多用c编写的文件，可能就是native方法所调用的c代码。

java是跨平台的语言，既然是跨了平台，所付出的代价就是牺牲一些对底层的控制，而java要实现对底层的控制，就需要一些其他语言的帮助，这个就是native的作用了.

## 堆
>它是所有线程共享的，它的目的是存放对象实例。同时它也是GC所管理的主要区域，因此常被称为GC堆，现在收集器常使用分代算法进行垃圾回收,这里是垃圾回收重灾区.

### 堆分代结构
堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。

新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。它们的默认比例关系如下图:
![](https://static01.imgkr.com/temp/9005de7e31a94d7cad4482e66bcc6498.png)

- `新生代 (Young Generation)`
 新生成的对象优先存放在新生代中，新生代对象朝生夕死，存活率很低，在新生代中常规应用进行一次垃圾收集一般可以回收70％～95％的空间，回收效率很高
- `幸存者区 (Survivor)`
  幸存者区有2块, From Survivor区， To Survivor区,也称S0,S1区.被面试官问了不要懵,GC进行时，Eden区中所有存活的对象都会被复制到 To Survivor区，而在FromSurvivor区中，仍存活的对象会根据它们的年龄值决定去向，年龄值达到年龄阀值(默认为15，新生代中的对象毎熬过一轮垃圾回收，年龄值就加1，GC分代年龄存储在对象的 header中)的对象会被移到老年代中，没有达到阀值的对象会被复制到 To Survivor区。接着清空Eden区和 From Survivor区，新生代中存活的对象都在 To Survivor区。接着，From Survivor区和 To Survivor区会交换它们的角色,GC时当 To Survivor区没有足够的空间存放上一次新生代收集下来的存活对象时，需要依赖老年代进行分配担保，将这些对象存放在老年代中.
  
- `老年代(Old)`
在新生代中经历了多次(具体看虚拟机配置的值)GC后仍然存活下来的对象会进入老年代中。老年代中的对象生命周期较长，存活率比较高，在老年代中进行GC的频率相对而言较低，而且回收的速度也比较慢
  

---
常见面试题:

- `何时发生Minor GC/Young GC ? `
新生成的对象在Eden区分配(大对象除外，大对象直接进入老年代)，当Eden区没有足够的空间进行分配时，虚拟机将发起一次 `Minor GC`也叫`Young GC`


- `为什么分代？`
  将对象根据存活概率进行分类，对存活时间长的对象，放到固定区，从而减少扫描垃圾时间及GC频率。针对分类进行不同的垃圾回收算法，对算法扬长避短



## 方法区

![](https://imgkr2.cn-bj.ufileos.com/e5b82fe4-288e-4c7b-a0aa-dabab17b2b8c.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=k0G3DS3oNIjjiUo%252FtjlqG2OdGg0%253D&Expires=1615359161)
从这张图可以看到JDK1.8和JDK1.7相比最大的区别是：`元空间区取代了永久代`，永久代原本主要存放`Class`和`Meta`的信息。而元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：`元空间并不在虚拟机中，而是使用本地内存`。因此，默认情况下，元空间的大小仅受本地内存限制。

上图中我们可以看到,JDK1.7和1.8对于运行时数据区和堆中的方法区都做了调整,jdk8中引入了一个新的内存区域叫metaspace。并不是所有的jvm中都有永久代，IBM的J9，oracle的JRocket都没有永久代，永久代是实现层面的东西，永久代里面存的东西基本上就是方法区规定的那些东西。

---

`面试题`: 方法区、永久代、元空间的区别?
- `方法区`：
  是JVM的规范，所有虚拟机必须遵守的。是JVM 所有线程共享的、用于存储类的信息、常量池、方法数据、方法代码等。
- `永久代`:
  全称Permanent Generation space ，是指内存的永久保存区域。是 HotSpot 虚拟机`基于JVM规范`对方法区的一个落地实现，并且只有 HotSpot 才有 PermGen space,在JDK8被移除了.
- `元空间`:
  元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。它也是`基于JVM规范`对方法区的一个落地实现

JDK6、JDK7 时，方法区 就是 PermGen（永久代）。
JDK8 时，方法区就是 Metaspace（元空间）

在`不同版本的JDK中` 堆溢出的实例:

 


![](https://imgkr2.cn-bj.ufileos.com/de86e29f-0b57-4e61-ace2-2a22acfa3b5e.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=2RiyHe8%252B%252Fv6kTm2fZE6io4rioTE%253D&Expires=1615361734)



![](https://imgkr2.cn-bj.ufileos.com/c333f4c7-8ce0-49fb-8157-53760cffd309.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=1DIs0jM5xlCSLE%252BBMFxkjjiJh2g%253D&Expires=1615361746)

---

`面试题`:为什么去除了永久代:

1）字符串存在永久代中，容易出现性能问题和内存溢出。

2）类及方法的信息等比较难确定其大小，因此对于永久代的大小指定比较困难，太小容易出现永久代溢出，太大则容易导致老年代溢出。

3）永久代会为 GC 带来不必要的复杂度，并且回收效率偏低。

## 结语

经过本篇学习,我们已经知道JVM对于内存的管理,以及它的结构,

千万不要搞混 JVM运行时数据区和JMM(Java memory modle)的关系

而JAVA对象布局在我的一篇文章中有讲过他们是不同的概念
[JAVA对象布局](https://mp.weixin.qq.com/s/0eSiHchlOHAZSAGAchkWmA)

下一篇我们来研究JMM(java的内存模型)和Java中的逃逸分析,以及多线程编程延伸.
请持续关注公众号:`JAVA宝典`

准备

Mybatis中重要组件的生命周期

Mybatis映射器