SpringBoot深入理解

SpringBoot深入理解

项目打包SpringBoot启动过程

当使用打包时，会下载org-springframework-boot-loader的jar，并且不会放在lib存放的第三方jar包文件中，该jar包中有个JarLauncher.class文件中设置了jar包运行时的入口和打包后文件的结构（定义了BOOT-INF,META-INF中放什么数据）

使用java -jar 启动项目时，因为META-INF中文件记载了启动的顺序

Manifest-Version: 1.0		#版本
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Start-Class: com.zyy.gradletest1.GradleTest1Application	     #项目的启动器
Spring-Boot-Classes: BOOT-INF/classes/		#记录编译后文件存放地址
Spring-Boot-Lib: BOOT-INF/lib/						  #记录第三方jar包存放地址
Spring-Boot-Version: 2.3.0.RELEASE		        #SpringBoot版本
Main-Class: org.springframework.boot.loader.JarLauncher			#标记了程序的入口,程序的入口定义类加载器去加载项目的启动器

所以程序会直接进入JarLauncher.class中执行main方法

public class JarLauncher extends ExecutableArchiveLauncher {

	static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";

	static final String BOOT_INF_LIB = "BOOT-INF/lib/";

	public JarLauncher() {
	}

	protected JarLauncher(Archive archive) {
		super(archive);
	}

	@Override
	protected boolean isNestedArchive(Archive.Entry entry) {
		if (entry.isDirectory()) {
			return entry.getName().equals(BOOT_INF_CLASSES);
		}
		return entry.getName().startsWith(BOOT_INF_LIB);
	}

	public static void main(String[] args) throws Exception {
		new JarLauncher().launch(args);
	}

}

JarLancher继承了ExecutableArchiveLauncher，ExecutableArchiveLauncher抽象类是归档启动器的父类，它有两个子类

​ Lancher：是整个归档的基类（抽象类）

​ |

ExecutableArchiveLauncher

​ | |

JarLancher WarLancher

顾名思义jarLancher就是打包成jar的归档启动类，WarLancher是War打包方式的归档启动类。

当执行JarLancher的main方法时，会调用Lancher基类的launch方法，该方法注释为：启动应用程序。 此方法是初始入口点应该由一个子类被称为public static void main(String[] args)方法。

---

使用SpringBoot自定义类加载器（LaunchedURLClassLoader）来加载打包好的Jar文件中BOOT-INF里面的类和lib

ClassLoader classLoader = createClassLoader(getClassPathArchives());

getClassPathArchives()方法：返回嵌套Archive S表示匹配指定过滤器条目。

意思就是：获得需要自定义类加载器需要加载的类的路径并返回（归档文件）

public abstract class ExecutableArchiveLauncher extends Launcher {
    @Override
    protected List<Archive> getClassPathArchives() throws Exception {
       List<Archive> archives = new ArrayList<>(
             /*this::isNestedArchive:确定指定JarEntry是应添加到类路径嵌套项。 该方法被调用一次为每个条目。
                 说人话就是查看当前需要加载的路径是否符合，如果符合返回true，这个方法调用的就是JarLancher类				  中的isNestedArchive方法*/
             this.archive.getNestedArchives(this::isNestedArchive));
       postProcessClassPathArchives(archives);
        //返回Archive类型的集合，Archive是可以由{@link Launcher}启动的档案类，里面记录的需要加载类的路径
       return archives;
    }
}

补充知识：

正常的jar包加载的方式就是直接找到classpath下的顶层路径加载（例如：org.springframework）

传统的打包方式是将第三方包和自己写的代码打包在一块，这就有可能出现，包名冲突之类的。为了解决这种问题，Spring的打包方式就是把第三方包和自己的代码分开。但是此时就出现了一个问题，不能正常找到顶层的加载文件，那么spring就出现了org-springframework-boot-loader包，spring默认规定该包在打包时将该包放到classpath下（顶层路径），首先加载该类中对应的Lancher类，然后通过该类创建的自定义类加载器去加载项目中其他的类。

---

准备去加载项目的主运行程序

launch(args, getMainClass(), classLoader);

getMainClass()：获得ExecutableArchiveLauncher.Archive类中的清单，Archive在创建自定义类加载器时，被构造方法初始化，初始化的路径就是classpath路径下的META-INF文件中的信息然后读取对应的主程序入口的路径（也就是META-INF文件中的信息）key为Start-Class的值（就是项目主程序的启动器）

public abstract class ExecutableArchiveLauncher extends Launcher {

	private final Archive archive;

	public ExecutableArchiveLauncher() {
		try {
			this.archive = createArchive();
		}
		catch (Exception ex) {
			throw new IllegalStateException(ex);
		}
	}
    @Override
    protected String getMainClass() throws Exception {
       Manifest manifest = this.archive.getManifest();
       String mainClass = null;
       if (manifest != null) {
          mainClass = manifest.getMainAttributes().getValue("Start-Class");
       }
       if (mainClass == null) {
          throw new IllegalStateException(
                "No 'Start-Class' manifest entry specified in " + this);
       }
       return mainClass;
    }
}

当所有参数准备完毕之后，进入launch方法中

public abstract class Launcher {
    /**
     * Launch the application given the archive file and a fully configured classloader.
     * @param args the incoming arguments
     * @param mainClass the main class to run
     * @param classLoader the classloader
     * @throws Exception if the launch fails
     */
    protected void launch(String[] args, String mainClass, ClassLoader classLoader)
          throws Exception {
        //将当前线程的上下文设置为自定义类加载器
       Thread.currentThread().setContextClassLoader(classLoader);
       createMainMethodRunner(mainClass, args, classLoader).run();
    }
}

创建一个运行Main的县城，将运行产参数和类加载器传入进去

createMainMethodRunner(mainClass, args, classLoader)

/**
 * Create the {@code MainMethodRunner} used to launch the application.
 * @param mainClass the main class					main方法运行的路径
 * @param args the incoming arguments		  方法的参数
 * @param classLoader the classloader			 自定义类加载器
 * @return the main method runner				返回线程
 */
protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args,
      ClassLoader classLoader) {
   return new MainMethodRunner(mainClass, args);
}

当线程创建好之后！！！重点来了！！！！运行run方法

createMainMethodRunner(mainClass, args, classLoader).run();

public void run() throws Exception {
    //获得线程上下文取出类加载器，然后获得要运行的main方法的路径
   Class<?> mainClass = Thread.currentThread().getContextClassLoader()
         .loadClass(this.mainClassName);
    //通过反射定位到main方法的位置
   Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
    //调用对应的main方法（此时调用的就是SpringBoot项目的启动器）
   mainMethod.invoke(null, new Object[] { this.args });
}

注意：mainMethod.invoke(null, new Object[] { this.args });

​ 为什么invoke第一个参数是空，因为main方法是static的，static不归存与类中，它只是把类当做寄存的场所而已，原因是所有的方法必须存在与类中

jar包启动时，使用-agentlib：jdwp远程debug

什么是jdwep？

JDWP 是 Java Debug Wire Protocol 的缩写，它定义了调试器（debugger）和被调试的 Java 虚拟机（target vm）之间的通信协议，可以项目在线运行时，远程debug查看运行的流程，如果项目是部署在tomcat中运行，需要在tomcat中配置相关的启动，才能使用远程debug

启动jar包时，使用命令

然后在idea中配置

注意：这种调试需要在配置之前在idea中有相同的代码，然后打上断点

注解

java.lang.annotation 提供了四种元注解，专门注解其他的注解（在自定义注解的时候，需要使用到元注解）：

@Documented – 注解是否将包含在JavaDoc中

@Retention – 什么时候使用该注解

@Target – 注解用于什么地方

@Inherited – 是否允许子类继承该注解

1.）@Retention – 定义该注解的生命周期

RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。

RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式

RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地方。可用的ElementType 参数包括

ElementType.CONSTRUCTOR: 用于描述构造器

ElementType.FIELD: 成员变量、对象、属性（包括enum实例）

ElementType.LOCAL_VARIABLE: 用于描述局部变量

ElementType.METHOD: 用于描述方法

ElementType.PACKAGE: 用于描述包

ElementType.PARAMETER: 用于描述参数

ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

3.)@Documented – 一个简单的Annotations 标记注解，表示是否将注解信息添加在java 文档中。

4.)@Inherited – 定义该注释和子类的关系

@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的annotation 类型被用于一个class，则这个annotation 将被用于该class 的子类。

@Configuration官方文档

修饰一个类为配置类，将Bean注入到Spring容器中，在运行期间生成bean的定义

@Configuration
   public class AppConfig {

       @Bean
       public MyBean myBean() {
           // instantiate, configure and return bean ...
       }
   }

@Configuration类通常使用AnnotationConfigApplicationContext或者支持web的AnnotationConfigWebApplicationContext的引导，来使用@Bean

//在test类中可以使用，或者直接使用@Autowired自动注入
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
   ctx.register(AppConfig.class);
   ctx.refresh();
   MyBean myBean = ctx.getBean(MyBean.class);
   // use myBean ...

@PropertySource

@Configuration类可以使用@PropertySource注释将属性源贡献给环境对象:

@Configuration
   @PropertySource("classpath:/com/acme/app.properties")
   public class AppConfig {

       @Inject Environment env;

       @Bean
       public MyBean myBean() {
           return new MyBean(env.getProperty("bean.name"));
       }
   }

@ComponentScan

@Configuration类不仅可以使用组件扫描引导，还可以自己使用@ComponentScan注释配置组件扫描:

@Configuration
   @ComponentScan("com.acme.app.services")
   public class AppConfig {
       // various @Bean definitions ...
   }

@Import

@Configuration类可以使用@Import注释组合，因为@Configuration对象在容器中被管理为Spring bean，所以导入的配置可能会被注入——例如，通过构造函数注入:

@Configuration

   public class DatabaseConfig {

       @Bean
       public DataSource dataSource() {
           // instantiate, configure and return DataSource
       }
   }

   @Configuration
   @Import(DatabaseConfig.class)
   public class AppConfig {

       private final DatabaseConfig dataConfig;

       public AppConfig(DatabaseConfig dataConfig) {
           this.dataConfig = dataConfig;
       }

       @Bean
       public MyBean myBean() {
           // reference the dataSource() bean method
           return new MyBean(dataConfig.dataSource());
       }
   }

@ContextConfiguration

组合多个@Configuration配置组件

@RunWith(SpringRunner.class)
   @ContextConfiguration(classes = {AppConfig.class, DatabaseConfig.class})
   public class MyTests {

       @Autowired MyBean myBean;

       @Autowired DataSource dataSource;

       @Test
       public void test() {
           // assertions against myBean ...
       }
   }

@Component

修饰一个类，表明一个注解的类是“部件”。@Configuration就是基于该注解。

@Autowired

自动注入，按照类型来匹配。

@Profile

分别开发环境和生产环境的配置

application.properties 配置文件

spring.profiles.active=development

测试环境

@Profile("development")
@Configuration
  public class EmbeddedDatabaseConfig {
        @Bean
          public DataSource dataSource() {
              // instantiate, configure and return embedded DataSource
          }
  }

生产环境

  @Profile("production")
  @Configuration
  public class ProductionDatabaseConfig {
    @Bean
      public DataSource dataSource() {
          // instantiate, configure and return production DataSource
      }
  }

第二种方法

@Configuration
  public class ProfileDatabaseConfig {
      //测试环境
      @Bean("dataSource")
      @Profile("development")
      public DataSource embeddedDatabase() { ... }
     //生产环境
      @Bean("dataSource")
      @Profile("production")
      public DataSource productionDatabase() { ... }
  }

@ImportResource

导入Spring的配置文件，让配置文件里面的内容生效；Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件

•     例：@ImportResource(locations = {"classpath:beans.xml"})
  

•     但是SpringBoott推荐给容器中添加组件的方式；推荐使用全注解的方式
  

@EnableAutoConfiguration

启用Spring应用程序上下文的自动配置(开启自动配置spring)，当你不需要加载某个自定义类时可以在yml文件中：spring.autoconfigure.exclude: XXXX 来排除某个类。

@ComponentScan

配置使用组件扫描指令与@ Configuration类。 提供与Spring XML的支持并行context:component-scan元件。它包含了annotation-config这个属性。

SpringBoot启动过程

从main中执行SpringApplication.run(GradleTest1Application.class, args);

@SpringBootApplication
public class GradleTest1Application {

    public static void main(String[] args) {
        SpringApplication.run(GradleTest1Application.class, args);
    }

}

进入到SpirngApplication类中，然后在run方法中间接调用new SpringApplication的构造方法

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
   return run(new Class<?>[] { primarySource }, args);
}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   return new SpringApplication(primarySources).run(args);
}

SpringApplication(primarySources):源码开始

---

public SpringApplication(Class<?>... primarySources) {
   this(null, primarySources);
}

从这里开始，有SpringApplication构造方法中嵌套的源码

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   this.resourceLoader = resourceLoader;		//资源加载器，因为上一次调用赋值为null，所以之这里时null
   Assert.notNull(primarySources, "PrimarySources must not be null");	  //断言这里是否传入的SpringBoot的启动器是否为空
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));		//将SpringBoot启动器放入一个Set<Class<?>>中
    /*WebApplicationType：Web应用程序可能类型的枚举，里面有三个枚举参数（查看Web是那种类型），deduceFromClasspath()方法中使用CLassUtils的class工具查看对应 的classpath路径下是否有对应的配置，如果有返回对应的Web类型
    注意：源码在本代码块后第一个代码块中
    */
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
    /*加载默认配置类（ApplicationContextInitializer是初始化所有自动配置类的类），扫描所有自动配置jar包中“META-INF/spring.factories”的配置类jar包（
    	主要有org.springframework.boot.autoconfigure、org.springframework.boot.context、org.springframework.boot.beans）
       找到实现ApplicationContextInitializer接口的类，并实例化他们
       提示：源码在本代码块后第二个代码块中
       */
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //和上一行代码操作一致，只不过是在三个jar包中找到实现ApplicationListener.class类并实例化它们
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    //找到主要的应用程序类
   this.mainApplicationClass = deduceMainApplicationClass();
    /**
    deduceMainApplicationClass();源码说明：
    	private Class<?> deduceMainApplicationClass() {
		try {
			//直接new出一个运行异常，然后获得堆信息
			StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
			//在堆信息中找到main方法
			for (StackTraceElement stackTraceElement : stackTrace) {
				if ("main".equals(stackTraceElement.getMethodName())) {
					//加载main方法，并返回class对象
					return Class.forName(stackTraceElement.getClassName());
				}
			}
		}
		catch (ClassNotFoundException ex) {
			// Swallow and continue
		}
		return null;
	}
    */
}

this.webApplicationType = WebApplicationType.deduceFromClasspath();源码：

WebApplicationType：Web应用程序可能类型的枚举，里面有三个枚举参数（查看Web是那种类型），deduceFromClasspath()方法中使用CLassUtils的class工具查看对应 的classpath路径下是否有对应的配置，如果有返回对应的Web类型

/**
 * An enumeration of possible types of web application.
 *
 * @author Andy Wilkinson
 * @author Brian Clozel
 * @since 2.0.0
 */
public enum WebApplicationType {

	/**
	 * The application should not run as a web application and should not start an
	 * embedded web server.
	 应用程序不应作为web应用程序运行，也不应该启动嵌入式web服务器。
	 */
	NONE,

	/**
	 * The application should run as a servlet-based web application and should start an
	 * embedded servlet web server.
	 应用程序应作为基于servlet的web应用程序运行，并应启动嵌入式servlet web服务器。
	 */
	SERVLET,

	/**
	 * The application should run as a reactive web application and should start an
	 * embedded reactive web server.
	 应用程序应该作为一个反应性web应用程序运行，并启动一个嵌入式反应性web服务器。当前反应性web服务器在Spring5引进，它可以支持servlet容器，也可以支持servlet职位的容器
	 */
	REACTIVE;

    static WebApplicationType deduceFromClasspath() {
        //判断类路径是否存在，存在：true    不存在：false
       if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
             && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
          return WebApplicationType.REACTIVE;
       }
       for (String className : SERVLET_INDICATOR_CLASSES) {
          if (!ClassUtils.isPresent(className, null)) {
             return WebApplicationType.NONE;
          }
       }
       return WebApplicationType.SERVLET;
    }
}

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); 源码：

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
   return getSpringFactoriesInstances(type, new Class<?>[] {});
}

/**
重点！！！！！！！！！
这个类是返回在org.springframework.boot.autoconfigure、org.springframework.boot.context、org.springframework.boot.beans这三个包中继承type类型的所有类，
这个类在SpringApplication中经常使用！！！！！！！
*/
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    //获得类加载器
   ClassLoader classLoader = getClassLoader();

    //获得所有的自动配置类的路径信息
   Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
       /*     SpringFactoriesLoader.loadFactoryNames(type, classLoader)说明和源码
       |															|										        	|
       使用set集合为了确保惟一以防止重复，因为这里存放的是所有自动配置类（AutoConfiguration）
       loadFactoryNames(type, classLoader));
      参数说明： (type = ApplicationContextInitializer.class(记录被加载类的配置信息，并初始化)         classLoader = 系统加载器）

       方法调用了loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader)的同名方法，
       loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader)源码：

       public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
            String factoryTypeName = factoryType.getName();
            //loadSpringFactories(classLoader)：找到所有“META-INF/spring.factories”配置文件中的类
            //getOrDefault(factoryTypeName, Collections.emptyList());   过滤所有的类找出实现factoryTypeName的类并放入集合中		   				  （factoryTypeName=ApplicationContextInitializer.class
            return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
		}
		在return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());中获得所有的自动配置类的路径信息
       */

    //在获得所有需要初始化的自动配置类后，初始化他们
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    //对类排序
   AnnotationAwareOrderComparator.sort(instances);
    //返回所有排序后的自动配置类集合
   return instances;
}

到这里结束

---

run(args)：源码开始

---

/**
 * Run the Spring application, creating and refreshing a new
 运行Spring应用程序，创建并刷新一个新应用程序
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    //计时器（Spring创始人2001年写的）
   StopWatch stopWatch = new StopWatch();
    //启动计时器
   stopWatch.start();
    //ApplicationContext子类，封装了配置和生命周期，防止ApplicationContext客户端代码看到它们
   ConfigurableApplicationContext context = null;
    //存放SpringApplication启动运行时的异常
   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    //以服务器模式运行，在系统可能缺少显示设备、键盘或鼠标这些外设的情况下可以使用该模式，激活该模式：System.setProperty("java.awt.headless", "true");
   configureHeadlessProperty();
    /*SpringApplication运行时的监视器，每运行一次都会创建一个SpringApplicationRunListener的子类放入SpringApplicationRunListeners类中的List<SpringApplicationRunListener> 的集合中*/
   SpringApplicationRunListeners listeners = getRunListeners(args);
    /**     |                                              |											|			源码：
    	private SpringApplicationRunListeners getRunListeners(String[] args) {
            Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
            return new SpringApplicationRunListeners(logger,
                    getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));	//找到继承SpringApplicationRunListener类的所有类
		}
	    */

    //开始启动所有继承SpringApplicationRunListener的监视器
   listeners.starting();
   try {
       //加载默认参数，只是把args赋值给DefaultApplicationArguments类中的成员变量
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
       //配置环境，传入所有监听器和应用程序的参数
      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
       //配置忽略一些Bean信息
      configureIgnoreBeanInfo(environment);
       //向控制台打印Banner（就是那个大的Spring字体，我们可以在classpath目录下创建一个banner.txt文件，把想要打印的东西放入进去就可以在程序启动时打印出来）
      Banner printedBanner = printBanner(environment);
       //创建应用上下文
      context = createApplicationContext();
       //获取Spring工厂的实例
      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
            new Class[] { ConfigurableApplicationContext.class }, context);
       //准备上下文，并输出某些日志
      prepareContext(context, environment, listeners, applicationArguments, printedBanner);
       //刷新上下文，并输出某个日志
      refreshContext(context);
       //刷新上下问后置处理
      afterRefresh(context, applicationArguments);
       //计时停止了
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      listeners.started(context);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
      throw new IllegalStateException(ex);
   }
   return context;
}