spring boot运行原理分析（方便以后回忆回忆打发时间）

最新推荐文章于 2019-11-01 16:22:31 发布

如意小队

最新推荐文章于 2019-11-01 16:22:31 发布

阅读量141

点赞数

本文链接：https://blog.csdn.net/Ruyi_squad/article/details/98385433

版权

spring boot运行原理（方便以后回忆）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
</parent>

1、配置文件中spring-boot-starter-parent定义了version版本（自己选择版本固定下来）用来同一版本
点进去，进入spring-boot-starter-parent-版本.pom,有parent就点进去看看，一直到没有parent。会发现最后有一个listen，里面是一个网址
在浏览器打开网址，发现是一个协议！

Apache License, Version 2.0
https://www.apache.org/licenses/LICENSE-2.0

有些协议是半商业化协议，个人使用免费，如果用于商业，他要收费，不打招呼，会被搞！

最强连接池，没有之一，hikaricp

2、@SpringBootApplication这是一个复合型的annotation，就是在他里面还包含了一大堆的annotation

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration //对付配置文件
@EnableAutoConfiguration //开启搞配置
//扫描组件
//(excludeFilters 鼓捣过滤器
//（题外话，怎么快速学会一个框架！，看源码，别买书，没有比源码更好看的了，看源码时间长了之后，你的编码能力会变强，别人都看不懂这是啥）
//进源码追就行

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication

小结@SpringBootApplication
1 开启扫描
2 完成所有的基本配置（比如咱加了web工程，他会帮我们完成整合工作，AutoConfiguration做的）
原理太多，初学者不好总结，以后慢慢看呗！

3、 spring boot配置文件

application.properties配置文件，不足之处：层次不明显、不能配类似于数组的配置（同一个key,不同的value）。天生缺陷。

推荐使用application.yaml(yml)配置

直接上干货

3.运行原理分析
3.1.起步原理分析
3.1.1.分析spring-boot-starter-parent
按住Ctrl点击pom.xml中的spring-boot-starter-parent，跳转到了spring-boot-starter-parent的pom.xml，xml配置如下:
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.0.1.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
通过观察parent的pom文件，发现该pom主要定义了环境以及所依赖的插件。

按住Ctrl点击pom.xml中的spring-boot-starter-dependencies，跳转到了spring-boot-starter-dependencies的pom.xml，xml配置如下:
<properties>
    <activemq.version>5.15.9</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.75</appengine-sdk.version>
    <artemis.version>2.6.4</artemis.version>
    <aspectj.version>1.9.4</aspectj.version>
    <assertj.version>3.11.1</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <bitronix.version>2.1.4</bitronix.version>
    <build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
  </properties>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot</artifactId>
        <version>2.1.6.RELEASE</version>
      </dependency>
  …
从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。
3.1.2.分析spring-boot-starter-web
按住Ctrl点击pom.xml中的spring-boot-starter-web，跳转到了spring-boot-starter-web的pom.xml，xml配置如下:
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd" 
xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starters</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.0.1.RELEASE</version>
    <name>Spring Boot Web Starter</name>
  
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.0.1.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-json</artifactId>
            <version>2.0.1.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <version>2.0.1.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.9.Final</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.5.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.0.5.RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
从上面的spring-boot-starter-web的pom.xml中我们可以发现，spring-boot-starter-web就是将web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”，这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的作用。
3.2.自动配置原理解析
按住Ctrl点击查看启动类MySpringBootApplication上的注解@SpringBootApplication
@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class);
    }
}
注解@SpringBootApplication的源码:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = 
AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
 
    /**
     * Exclude specific auto-configuration classes such that they will never be 
applied.
     * @return the classes to exclude
     */
    @AliasFor(annotation = EnableAutoConfiguration.class)
    Class<?>[] exclude() default {};
 
    ... ... ...
 
}
其中，
@SpringBootConﬁguration：等同与@Conﬁguration，既标注该类是Spring的一个配置类
@EnableAutoConﬁguration：SpringBoot自动配置功能开启.
按住Ctrl点击查看注解@EnableAutoConﬁguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ... ... ...
}
其中，@Import(AutoConﬁgurationImportSelector.class) 导入了AutoConﬁgurationImportSelector类
按住Ctrl点击查看AutoConﬁgurationImportSelector源码
public String[] selectImports(AnnotationMetadata annotationMetadata) {
        ... ... ...
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                                   attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return StringUtils.toStringArray(configurations);
}
 
 
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        
        return configurations;
}
其中，SpringFactoriesLoader.loadFactoryNames 方法的作用就是从META-INF/spring.factories文件中读取指定类对应的类名称列表。

该配置文件存在大量的以Conﬁguration为结尾的类名称，这些类就是存有自动配置信息的类，而SpringApplication在获取这些类名后再加载。
以ServletWebServerFactoryAutoConﬁguration为例来分析源码：
@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    ... ... ...
}
其中，@EnableConﬁgurationProperties(ServerProperties.class) 代表加载ServerProperties服务器配置属性类，进入ServerProperties.class源码如下：
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
 
    /**
     * Server HTTP port.
     */
    private Integer port;
 
    /**
     * Network address to which the server should bind.
     */
    private InetAddress address;
  
    ... ... ...
  
}
其中，preﬁx = "server" 表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。
4.SpringBoot基本配置方式
在springboot中，可以使用properties文件和yaml(yml)文件完成配置，因properties文件已经比较熟悉，所以只介绍yaml文件的编写方法。
4.1.yml配置文件简介
YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。YML文件的扩展名可以使用.yml或者.yaml。
4.1.1.yaml语法
配置普通数据
语法： key: value
示例代码：
name: zhangsan
注意：张三前面需要添加一个空格
配置对象数据
语法：
   	key:
   	key1: value1
   	key2: value2
   	或者：
   	key: {key1: value1,key2: value2}
person:
  name: zhangsan
  age: 31
  addr: beijing 
#或者 
person: {name: haohao,age: 31,addr: beijing}
注意：key1前面的空格个数不限定，在yml语法中，相同缩进代表同一个级别
配置Map类型
同以上语法
配置数组（List、Set）数据
语法：
   key:
   - value1
   - value2
或者：
   		key: [value1,value2]
city:
  - beijing
  - tianjin
  - shanghai
  - chongqing
  
#或者
 
city: [beijing,tianjin,shanghai,chongqing]
#集合中的元素是对象形式
student:
  - name: zhangsan
    age: 18
    score: 100
  - name: lisi
    age: 28
    score: 88
  - name: wangwu
    age: 38
    score: 90
注意：value1与之间的 - 之间存在一个空格.
4.1.2.常用配置信息
上面提及过，SpringBoot的配置文件，主要的目的就是对配置信息进行修改的，但在配置时的key从哪里去查询呢？我们可以查阅SpringBoot的官方文档。常用的一些配置：
# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080 # Server HTTP port.
server.servlet.context-path= # Context path of the application.
server.servlet.path=/ # Path of the main dispatcher servlet.
 
# HTTP encoding (HttpEncodingProperties)
spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to 
the "Content-Type" header if not set explicitly.
 
# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date format 
class name. For instance, `yyyy-MM-dd HH:mm:ss`.
 
# SPRING MVC (WebMvcProperties)
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher 
servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.
 
# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-
detected based on the URL by default.
spring.datasource.password= # Login password of the database.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.
 
# JEST (Elasticsearch HTTP client) (JestProperties)
spring.elasticsearch.jest.password= # Login password.
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use.
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use.
spring.elasticsearch.jest.read-timeout=3s # Read timeout.
spring.elasticsearch.jest.username= # Login username.
我们可以通过配置application.poperties 或者 application.yml 来修改SpringBoot的默认配置，
该配置文件位于resources的根目录下。
server.port=8888
server.servlet.context-path=demo
application.yml：
server:
  port: 8888
4.1.3.配置文件与属性文件获取方式
4.1.3.1.使用注解@Value映射
可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上，例如：
application.properties配置如下：
person:
  name: zhangsan
  age: 18
或者，application.yml配置如下：
person:
  name: zhangsan
  age: 18
实体Bean代码：
@Controller
public class QuickStartController {
 
    @Value("${person.name}")
    private String name;
    @Value("${person.age}")
    private Integer age;
 
 
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "springboot 访问成功! name="+name+",age="+age;
    }
 
}

4.1.3.2.使用注解@ConﬁgurationProperties映射
通过注解@ConﬁgurationProperties(preﬁx="配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射
@Controller
@ConfigurationProperties(prefix = "person")
public class QuickStartController {
 
    private String name;
    private Integer age;
 
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "springboot 访问成功! name="+name+",age="+age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
}
5.SpringBoot整合Mybatis
5.1.添加Mybatis的起步依赖
<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
在application.properties中添加数据库连接信息：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
5.2.创建实体
public class User {
    // 主键
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;
  
    //此处省略getter和setter方法 .. ..
    
}
5.3.编写mapper
public interface UserMapper {
    public List<User> queryUserList();
}
5.4.配置Mapper映射文件
在src\main\resources\mapper路径下加入UserMapper.xml配置文件
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.csi.mapper.UserMapper">
    <select id="queryUserList" resultType="user">
        select * from user
    </select>
</mapper>
5.5.在application.properties中添加mybatis的信息
#spring集成Mybatis环境
#pojo别名扫描包
mybatis.type-aliases-package=com.csi.springboot.domain
#加载Mybatis映射文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
5.6.编写测试Controller
@Controller
public class MapperController {
 
    @Autowired
    private UserMapper userMapper;
 
    @RequestMapping("/queryUser")
    @ResponseBody
    public List<User> queryUser(){
        List<User> users = userMapper.queryUserList();
        return users;
    }
 
}
5.7.启动类
@SpringBootApplication
@MapperScan("com.csi.springboot.mapper")
public class SpringBootApp { 

6.SpringBoot整合Junit
6.1.添加Junit的起步依赖
<!--测试的起步依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
6.2.编写测试类
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApplication.class)
public class MapperTest {
 
    @Autowired
    private UserMapper userMapper;
 
    @Test
    public void test() {
        List<User> users = userMapper.queryUserList();
        System.out.println(users);
    }
 
}
其中，SpringRunner继承自SpringJUnit4ClassRunner，使用哪一个Spring提供的测试测试引擎都可以, @SpringBootTest的属性指定的是引导类的字节码对象。
7.Bootstrap
BootStrap最大特点就是能够实现响应式布局。其对应的目标也是手机移动端。
7.1.SpringBoot整合BootStrap
<!-- 最新版本的 Bootstrap 核心 CSS 文件 -->
    <link rel="stylesheet" href="js/bootstrap-3.3.7/dist/css/bootstrap.min.css" >

    <!--导入jquery-->
    <script type="text/javascript" src="js/jquery.min.js"></script>

    <!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
    <script src="js/bootstrap-3.3.7/dist/js/bootstrap.min.js"></script>

如意小队

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring boot运行原理分析（方便以后回忆回忆打发时间）

spring boot运行原理（方便以后回忆）<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.6.RELEASE...
复制链接

扫一扫