17_Spring Boot源码解析

最新推荐文章于 2024-10-03 16:46:14 发布
最新推荐文章于 2024-10-03 16:46:14 发布
阅读量129 收藏
点赞数
分类专栏： # 01_源码框架 文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lastinglate/article/details/120116201
版权

文章目录

一 spring注解之如何导入Bean的几种方式

  1. @Bean注解,不做讲解
  2. 包扫描来加载Bean 比如标识@Controller @Service @Repository @Compent 不做讲解
  3. @Import几种取值来注册bean
    ①：实现ImportSelector接口的类
    ②：实现ImportBeanDefinitionRegistrar接口来注冊bean
  4. 实现factoryBean的方式来导入组件 (不做讲解)

1.1 通过@Import注解来导入ImportSelector组件

①:写一个配置类在配置类上标注一个@Import的注解，

@Configuration
@Import(value = {TulingSelector.class})
public class TulingConfig {
}

②:在@Import注解的value值 写自己需要导入的组件
在selectImports方法中 就是你需要导入组件的全类名

public class TulingSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.tuling.service.TulingServiceImpl"};
    }
}

核心代码:

@RestController
public class TulingController {
    //自动注入 tulingServiceImpl
    @Autowired
    private TulingServiceImpl tulingServiceImpl;
    @RequestMapping("testTuling")
    public String testTuling() {
        tulingServiceImpl.testService();
        return "tulingOk";
    }
}
//这里是没有标注其他注解提供给spring包扫描的
public class TulingServiceImpl {
    public void testService() {
        System.out.println("我是通过importSelector导入进来的service"); }
}

测试结果:
在这里插入图片描述

1.2 通过@Import导入ImportBeanDefinitionRegistrar 从而进来导入组件

在这里插入图片描述

核心代码:

public class TulingImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        //定义一个BeanDefinition
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TulingDao.class);
        //把自定义的bean定义导入到容器中
        beanDefinitionRegistry.registerBeanDefinition("tulingDao", rootBeanDefinition);
    }
}
//通过ImportSelector功能导入进来的
public class TulingServiceImpl {
    @Autowired
    private TulingDao tulingDao;

    public void testService() {
        tulingDao.testTulingDao();
        System.out.println("我是通过importSelector导入进来的service");
    }
}
//通过ImportBeanDefinitionRegistar导入进来的
public class TulingDao {
    public void testTulingDao() {
        System.out.println("我是通过ImportBeanDefinitionRegistrar导入进来tulingDao组件");
    }
}

测试结果：
在这里插入图片描述

1.3 spring底层条件装配的原理@Conditional

应用要求:比如我有二个组件,一个是TulingLog 一个是TulingAspect
而TulingLog 是依赖TulingAspect的 只有容器中有TulingAspect组件才会加载TulingLog

//tulingLog组件  依赖TulingAspect组件
public class TulingLog {
}
//tulingAspect组件
public class TulingAspect {
}

①:自定义条件组件条件

public class TulingConditional implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //容器中包含tulingAspect组件才返回Truee 
        if (conditionContext.getBeanFactory().containsBean("tulingAspect")) {
            return true;
        } else {
            return false;
        }
    }
}

    // -------------------------------------该情况下会加载二个组件------------------------------------------------- 
    @Bean
    public TulingAspect tulingAspect() {
        System.out.println("TulingAspect组件自动装配到容器中");
        return new TulingAspect();
    }

    @Bean
    @Conditional(value = TulingConditional.class)
    public TulingLog tulingLog() {
        System.out.println("TulingLog组件自动装配到容器中");
        return new TulingLog();
    }

    //-------------------------------------二个组件都不会被加载---------------------------------------- 
     /*@Bean**/ 
    public TulingAspect tulingAspect() {
        System.out.println("TulingAspect组件自动装配到容器中");
        return new TulingAspect();
    }

    @Bean
    @Conditional(value = TulingConditional.class)
    public TulingLog tulingLog() {
        System.out.println("TulingLog组件自动装配到容器中");
        return new TulingLog();
    }

二 Spring Boot自动装配原理

2.1 @Springboot注解组合图

根据上面的@SpringBootApplication注解 我们来着重分析如下二个类
①：AutoConfigurationImportSelector.class
②：AutoConfigurationPackages.Registrar.class
在这里插入图片描述

先分析AutoConfigurationImportSelector为我们干了什么活？

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(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());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you " + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

    //加载配置类
    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }
        try {
            //"META-INF/spring.factories" 去类路径下该文件中加载
            EnableAutoConfiguration.class
            Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            //遍历解析出来的集合
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                //放在Properties中
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryClassName = ((String) entry.getKey()).trim();
                    for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            //返回
            return result;
        } catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

主要是扫描spring-boot-autoconfigure\2.0.8.RELEASE\spring-boot-autoconfigure-
2.0.8.RELEASE.jar!\META-INF\spring.factories 中EnableAutoConfiguration对应的全类名

org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\        org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\       org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\       org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\ org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\ org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\      org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\ org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\           org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\ org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\ org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\      org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\ org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\ org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\

org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.core.ReactorCoreAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityRequestMatcherProviderAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\ org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\         org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\ org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.OAuth2ClientAutoConfiguration,\ org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\ org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\ org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\          org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\ org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\ org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\   org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\       org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\ org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

上面的一些个 XXXAutoConfiguration都是一个个自动配置类
我们就拿二个来分析一下 这些自动配置类是如何工作的???
分析源码1: org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

@Configuration  //标识是一个配置类
@ConditionalOnClass(RedisOperations.class)  // 判断是否导入了 redis的jar包
@EnableConfigurationProperties(RedisProperties.class)  //开启自动配置属性类加载到容器中
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    //自动配置了一个 redisTemlate 操作对象的
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    // 操作字符串的
    @Bean
    @ConditionalOnMissingBean

    public StringRedisTemplate stringRedisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}
// =============================================配置jedis连接工厂配置类================

@Configuration
@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
class JedisConnectionConfiguration extends RedisConnectionConfiguration {
    private final RedisProperties properties;
    private final List<JedisClientConfigurationBuilderCustomizer> builderCustomizers;

    JedisConnectionConfiguration(RedisProperties properties, 
                                 ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration, 
                                 ObjectProvider<RedisClusterConfiguration> clusterConfiguration, 
                                 ObjectProvider<List<JedisClientConfigurationBuilderCustomizer>> builderCustomizers) {
        super(properties, sentinelConfiguration, clusterConfiguration);
        this.properties = properties;
        this.builderCustomizers = builderCustomizers
                .getIfAvailable(Collections::emptyList);
    }

    @Bean
    @ConditionalOnMissingBean(RedisConnectionFactory.class)
    public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException {
        return createJedisConnectionFactory();
    }
}

我们来看下 org.springframework.boot.autoconfigure.data.redis.RedisProperties ，这个类是用来什么的？
就是我们yml中能配置什么类 ， 在这个类中都会有一个属性一一对应

public class RedisProperties {
    /**
     * Database index used by the connection factory.
     */
    private int database = 0;
    /**
     * Connection URL. Overrides host, port, and password. User is ignored. Example:
     * redis://user:password@example.com:6379
     */
    private String url;
    /**
     * Redis server host.
     */
    private String host = "localhost";
    /**
     * Login password of the redis server.
     */
    private String password;
    /**
     * Redis server port.
     */
    private int port = 6379;
    /**
     * Whether to enable SSL support.
     */
    private boolean ssl;
    /**
     * Connection timeout.
     */
    private Duration timeout;
    private Sentinel sentinel;
    private Cluster cluster;
}

我们对应的配置文件(yml)中就会有对应属性来配置
在这里插入图片描述

spring:
  redis:
    host: 47.104.128.12
    port: 6379
    password: 123456
    jedis:
      pool:
      max-active: 20
      max-idle: 10
      min-idle: 5

以上 就是 AutoConfigurationImportSelector为我们容器中注册了那些组件，然后根据maven依赖导入的jar包，根据条件装配来指定哪些组件起作用 哪些组件不起作用。

三 上面我们分析了springboot 自动装配原理，接下来我们依靠自动装配原理来分析出Spring Boot的jar包的启动流程.

在这里插入图片描述
在这里插入图片描述

3.1 我们先来看springboot 怎么来自动装配tomcat 相关的组件

EmbeddedWebServerFactoryCustomizerAutoConfiguration(内嵌web容器工厂自定义定制器装配类)?
疑问1？定制器是用来干什么的？

疑问2？定制器何时工作？
类的继承关系
在这里插入图片描述

我们就以tomcat 作为内嵌容器来分析

@Configuration
@ConditionalOnWebApplication
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {
    //配置tomcat的
    @Configuration
    @ConditionalOnClass({Tomcat.class, UpgradeProtocol.class})
    public static class TomcatWebServerFactoryCustomizerConfiguration {
        @Bean
        public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
        }
    }

    //配置jetty
    @Configuration
    @ConditionalOnClass({Server.class, Loader.class, WebAppContext.class})
    public static class JettyWebServerFactoryCustomizerConfiguration {
        @Bean
        public JettyWebServerFactoryCustomizer jettyWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new JettyWebServerFactoryCustomizer(environment, serverProperties);
        }
    }

    // 配置undertow的
    @Configuration
    @ConditionalOnClass({Undertow.class, SslClientAuthMode.class})
    public static class UndertowWebServerFactoryCustomizerConfiguration {
        @Bean
        public UndertowWebServerFactoryCustomizer undertowWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new UndertowWebServerFactoryCustomizer(environment, serverProperties);
        }
    }
}

我们来看下tomat 工厂定制器 是用来修改设置容器的内容的(把serverProperties的属性设置到tomcat的创建工厂中)

public class TomcatWebServerFactoryCustomizer implements WebServerFactoryCustomizer<ConfigurableTomcatWebServerFactory>, Ordered {
    @Override
    public void customize(ConfigurableTomcatWebServerFactory factory) {
        ServerProperties properties = this.serverProperties;
        ServerProperties.Tomcat tomcatProperties = properties.getTomcat();
        PropertyMapper propertyMapper = PropertyMapper.get();
        propertyMapper.from(tomcatProperties::getBasedir).whenNonNull().to(factory::setBaseDirectory);
        propertyMapper.from(tomcatProperties::getBackgroundProcessorDelay).whenNonNull().as(Duration::getSeconds).as(Long::intValue).to(factory::setBackgroundProcessorDelay);
        customizeRemoteIpValve(factory);
        propertyMapper.from(tomcatProperties::getMaxThreads).when(this::isPositive).to((maxThreads) -> customizeMaxThreads(factory, tomcatProperties.getMaxThreads()));
        propertyMapper.from(tomcatProperties::getMinSpareThreads).when(this::isPositive).to((minSpareThreads) -> customizeMinThreads(factory, minSpareThreads));
        propertyMapper.from(() -> determineMaxHttpHeaderSize()).when(this::isPositive).to((maxHttpHeaderSize) -> customizeMaxHttpHeaderSize(factory, maxHttpHeaderSize));
        propertyMapper.from(tomcatProperties::getMaxHttpPostSize).when((maxHttpPostSize) -> maxHttpPostSize != 0).to((maxHttpPostSize) -> customizeMaxHttpPostSize(factory, maxHttpPostSize));
        propertyMapper.from(tomcatProperties::getAccesslog).when(ServerProperties.Tomcat.Accesslog::isEnabled).to((enabled) -> customizeAccessLog(factory));
        propertyMapper.from(tomcatProperties::getUriEncoding).whenNonNull().to(factory::setUriEncoding);
        propertyMapper.from(properties::getConnectionTimeout).whenNonNull().to((connectionTimeout) -> customizeConnectionTimeout(factory, connectionTimeout));
        propertyMapper.from(tomcatProperties::getMaxConnections).when(this::isPositive)
                .to((maxConnections) -> customizeMaxConnections(factory, maxConnections));
        propertyMapper.from(tomcatProperties::getAcceptCount).when(this::isPositive).to((acceptCount) -> customizeAcceptCount(factory, acceptCount));
        customizeStaticResources(factory);
        customizeErrorReportValve(properties.getError(), factory);
    }
}

ServletWebServerFactoryAutoConfiguration Servletweb工厂自动配置类
很重要*********************:@Import({
ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class}******************

@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 {
    @Bean
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(
            ServerProperties serverProperties) {
        return new ServletWebServerFactoryCustomizer(serverProperties);
    }

    @Bean
    @ConditionalOnClass(name = "org.apache.catalina.startup.Tomcat")
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }
}

    //.....................................................ServletWebServerFactoryCustomizer核心代码...........................................
    public void customize(ConfigurableServletWebServerFactory factory) {
        PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
        map.from(this.serverProperties::getPort).to(factory::setPort);
        map.from(this.serverProperties::getAddress).to(factory::setAddress);
        map.from(this.serverProperties.getServlet()::getContextPath)
                .to(factory::setContextPath);
        map.from(this.serverProperties.getServlet()::getApplicationDisplayName)
                .to(factory::setDisplayName);
        map.from(this.serverProperties.getServlet()::getSession).to(factory::setSession);
        map.from(this.serverProperties::getSsl).to(factory::setSsl);
        map.from(this.serverProperties.getServlet()::getJsp).to(factory::setJsp);
        map.from(this.serverProperties::getCompression).to(factory::setCompression);
        map.from(this.serverProperties::getHttp2).to(factory::setHttp2);
        map.from(this.serverProperties::getServerHeader).to(factory::setServerHeader);
        map.from(this.serverProperties.getServlet()::getContextParameters)
                .to(factory::setInitParameters);
    }

    public void customize(TomcatServletWebServerFactory factory) {
        ServerProperties.Tomcat tomcatProperties = this.serverProperties.getTomcat();
        if (!ObjectUtils.isEmpty(tomcatProperties.getAdditionalTldSkipPatterns())) {
            factory.getTldSkipPatterns()
                    .addAll(tomcatProperties.getAdditionalTldSkipPatterns());
        }
        if (tomcatProperties.getRedirectContextRoot() != null) {
            customizeRedirectContextRoot(factory,
                    tomcatProperties.getRedirectContextRoot());
        }
        if (tomcatProperties.getUseRelativeRedirects() != null) {
            customizeUseRelativeRedirects(factory,
                    tomcatProperties.getUseRelativeRedirects());
        }
    }

ServletWebServerFactoryConfiguration 容器工厂配置类

@Configuration
class ServletWebServerFactoryConfiguration {
    @Configuration
    @ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedTomcat {
        //配置tomcat 容器工厂
        @Bean
        public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
            return new TomcatServletWebServerFactory();
        }
    }
}

现在我们来分析一下启动流程。

1 com.tuling.TulingvipSpringbootAutoconfigPrincipleApplication#main 运行main方法

2 org.springframework.boot.SpringApplication#run(java.lang.Class<?>, java.lang.String…)

2.1 传入主配置类 ， 以及命令行参数
2.2 创建SpringApplication对象
①:保存主配置类
②:保存web应用的配置类型
③:去mate-info/spring.factories文件中获取   ApplicationContextInitializer(容器初始化器) 保存到
springapplication对象中
④:去mate-info/spring.factories文件中获取   ApplicationListener(容器监听器) 保存到
springapplication对象中
⑤:保存选取 主配置类

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //保存主配置类
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //保存web应用的类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //保存 容器初始化器(ApplicationContextInitializer类型的)
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        //把监听器保存到 SpringApplication中[ApplicationListener]
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //保存主配置类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

    //还是去META-INFO/spring.factories 中获取ApplicationContextInitializer 类型，用于初始化容器
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
                                                          Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // Use names and ensure unique to protect against duplicates
        Set<String> names = new LinkedHashSet<>(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

    //查找主配置类 查询的依据就是看哪个方法是否有main方法
    private Class<?> deduceMainApplicationClass() {
        try {
            StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
            for (StackTraceElement stackTraceElement : stackTrace) {
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        } catch (ClassNotFoundException ex) {
            // Swallow and continue
        }
        return null;
    }

在这里插入图片描述
在这里插入图片描述

3 运行SpringbootApplication的run方法

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        //创建一个 容器对象
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        //去meta-info/spring.factories中获取SpringApplicationRunListener 监听器(事件发布监听器)
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //发布容器 starting事件(通过spring的事件多播器)
        listeners.starting();
        try {
            //封装命令行参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //准备容器环境
            //1:获取或者创建环境
            //2：把命令行参数设置到环境中
            //3：通过监听器发布环境准备事件
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            configureIgnoreBeanInfo(environment);
            //打印springboot的图标
            Banner printedBanner = printBanner(environment);
            //创建容器 根据webApplicationType 来创建容器 通过反射创建
            context = createApplicationContext();
            //去meta-info类中 获取异常报告
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[]{ConfigurableApplicationContext.class}, context);
            //准备环境
            //1:把环境设置到容器中
            //2:循环调用AppplicationInitnazlier 进行容器初始化工作
            //3:发布容器上下文准备完成事件
            //4:注册关于springboot特性的相关单例Bean
            //5:发布容器上下文加载完毕事件
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            refreshContext(context);
            //运行 ApplicationRunner  和CommandLineRunner
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            //发布容器启动事件
            listeners.started(context);
            //运行 ApplicationRunner  和CommandLineRunner
            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;
    }

5 org.springframework.boot.SpringApplication#refreshContext

6 org.springframework.context.support.AbstractApplicationContext#refresh

7 org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#onRefresh

8 org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#createWebServer

8.1 org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#getWebServerFactory获取web 服务器工厂

以下是springioc容器启动的核心流程， 在这里不做详细解释,大概步骤为如下:
在这里插入图片描述

8.2 org.springframework.boot.web.server.WebServerFactoryCustomizerBeanPostProcessor#postProcessBeforeInitialization

在这里插入图片描述

8.3 org.springframework.boot.web.server.WebServerFactoryCustomizerBeanPostProcessor#postProcessBeforeInitialization

在这里插入图片描述

8.3.1 WebServerFactoryCustomizerBeanPostProcessor 是一个什么东西？ 在哪里注册到容器中的??

我们往容器中导入了 BeanPostProcessorsRegistrar 他实现了 ImportBeanDefinitionRegistrar
在他的 registerBeanDefinitions注册Bean定义的时候 注册
了 webServerFactoryCustomizerBeanPostProcessor
想知道 webServerFactoryCustomizerBeanPostProcessor何时在容器中注册的么？

public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
    private ConfigurableListableBeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (beanFactory instanceof ConfigurableListableBeanFactory) {
            this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
        }
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        if (this.beanFactory == null) {
            return;
        }
        registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);
        registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class);
    }
}

9 org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory#getWebServer 创建tomcat 并且容器启动

    public WebServer getWebServer(ServletContextInitializer... initializers) {
        Tomcat tomcat = new Tomcat();
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory
                : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
        tomcat.getService().addConnector(connector);
        customizeConnector(connector);
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        configureEngine(tomcat.getEngine());
        for (Connector additionalConnector : this.additionalTomcatConnectors) {
            tomcat.getService().addConnector(additionalConnector);
        }
        prepareContext(tomcat.getHost(), initializers);
        return getTomcatWebServer(tomcat);
    }

    protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
        //端口大于0启动启动
        return new TomcatWebServer(tomcat, getPort() >= 0);
    }

    public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        initialize();
    }

    // tomcat启动流程
    private void initialize() throws WebServerException {
        TomcatWebServer.logger
                .info("Tomcat initialized with port(s): " + getPortsDescription(false));
        synchronized (this.monitor) {
            try {
                addInstanceIdToEngineName();
                Context context = findContext();
                context.addLifecycleListener((event) -> {
                    if (context.equals(event.getSource())
                            && Lifecycle.START_EVENT.equals(event.getType())) {         // Remove service connectors so that protocol binding doesn't // happen when the service is started.                                      removeServiceConnectors();
                    }
                });
                // Start the server to trigger initialization listeners
                this.tomcat.start();
                // We can re-throw failure exception directly in the main thread rethrowDeferredStartupExceptions();
                try {
                    ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
                } catch (NamingException ex) {
                    // Naming is not enabled. Continue
                }
                // Unlike Jetty, all Tomcat threads are daemon threads. We create a
                // blocking non-daemon to stop immediate shutdown
                startDaemonAwaitThread();
            } catch (Exception ex) {
                stopSilently();
                throw new WebServerException("Unable to start embedded Tomcat", ex);
            }
        }
    }

10 在IOC 容器中的 org.springframework.context.support.AbstractApplicationContext#refresh 的

onReFresh()带动tomcat启动
然后在接着执行 ioc容器的其他步骤。
在这里插入图片描述
疑问？

1）AutoConfigurationImportSelector#selectImports 的方法是怎么触发的？

在这里插入图片描述

2）我们自己定义的一些@Controller @Service 怎么到容器中去的？

接下来 我们就一一解答你们的疑问?还是以debug的方式来为大家解答

1 AbstractApplicationContext#refresh(容器的刷新)
2 AbstractApplicationContext#invokeBeanFactoryPostProcessors 调用bean工厂的后置处理器
3 PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
4 ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry 配置类的后置处理器
5 ConfigurationClassPostProcessor#processConfigBeanDefinitions 处理配置的bean定义
5.1 找到候选的配置类(tulingvipSpringbootAutoconfigPrincipleApplication)我们自己项目中的配

置类

5.2 创建配置类解析器
6 ConfigurationClassParser#parse 解析我们自己的配置类

(tulingvipSpringbootAutoconfigPrincipleApplication)

7 ConfigurationClassParser#processConfigurationClass处理配置类
7.1 处理配置类上的@PropertySource注解

ConfigurationClassParser#processPropertySource

7.2 处理@ComponentScan注解的 ComponentScanAnnotationParser#parse
①:创建 类路径下的bean定义扫描器 ClassPathBeanDefinitionScanner ..多个步骤  解析@ComponentScan 注解的属性
②:ClassPathBeanDefinitionScanner#doScan  真正的扫描
(tulingvipSpringbootAutoconfigPrincipleApplication所在的包)
③:返回我们标志了@Controller @Service @Response  @compent注解的bean定
义
7.3 处理@Import注解 ConfigurationClassParser#processImports
7.4 处理@ImportSource注解
7.5 处理@Bean注解的
8 ConfigurationClassParser#processDeferredImportSelectors 处理实现了ImportSelectors接口的
9 AutoConfigurationGroup#process (获取 容器中的所有ImportSelector 包含了 AutoConfigurationImportSelector)
10 ImportSelector#selectImports 回调 AutoConfigurationImportSelector.selectImports
11 ConfigurationClassBeanDefinitionReader#loadBeanDefinitions 把解析出来的类的bean定义 注册到容器中

在这里插入图片描述

lastinglate
关注
专栏目录
Spring源码深度解析 Spring Boot 体系原理总结
勤劳的搬运工
03-22 1196
Spring Boot 特点如下： 创建独立的 Spring 应用程序； 嵌入的 Tomcat ，无须部署 WAR 文件； 简化 Maven 配置； 自动配置 Spring; 提供生产就绪型功能，如指标、健康检查和外部配置； 绝对没有代码生成，以及对 XML 没有配置要求 首先搭建一个 maven 工程， pom 如下： 然后建立一个 controller 类 最后再加入启动整个项目的 main 函数 最后启动main函数并在浏览器中输入localhost:8080 第一个 Starter spr
Spring boot源码分析一
热门推荐
liushangzaibeijing的博客
04-16 6万+
本文主要记录springBoot start的机制以及自动装配的原理解读。
SpringBoot启动原理源码解析
业精于勤，荒于嬉
11-25 615
jar运行SpringBoot应用 spring-boot-maven-plugin java -jar启动，首先需要配置一个插件，该插件会： 在打包时帮我们编写MANIFEST.MF文件； 把项目所依赖的jar包也都打包到jar中，成为fat jar。 <!-- pom.xml文件中默认使用该插件进行打包 --> <build> <plugins> <plugin> <groupId>org.s
Spring Boot编程问题
后而来者
12-20 449
问题1：想通过IDEA创建一个SpringBoot项目，在各个博客上都有看到Spring Initializr这种插件可以直接生成SprigBoot项目，但是我的软件上却没有 原因： 使用社区版的IDEA没有安装此插件 使用付费的版的IDEA，会有，如果没有，请查看是否将这个插件勾上 勾上后，可以愉快的玩耍了。。。。 ...
Spring Boot源码解读与原理分析
herosunly的博客
10-17 5万+
最近机缘巧合之下，读到了LinkedBear编写的《Spring Boot源码解读与原理分析》这本书，本人花了一周的时间认真研读了一下这本书，真的是受益匪浅，特此推荐给大家，好书不容错过啊。 文章目录 1. 关于作者 2. 本书定位 3. 目标读者 4. 读后感受 5. 书籍特点 6. 总结与展望 LinkedBear是一名资深的Java开发工程师，他倾力研究Spring技术体系多年，对Spring、Spring Boot、MyBatis等框架有独到的见解，拥有丰富的框架体系实践经验和架构封装经验。
Spring Boot的原理以及源码解析
Liu_csdn_csdn的博客
06-03 1390
Spring Boot是一个基于Spring框架的轻量级框架，它的主要特点是快速开发、便捷部署。在运行时，Spring Boot通过内嵌的Tomcat、Jetty等Web容器，将应用程序打包成一个可执行JAR文件或WAR文件，从而方便开发、测试和部署。
【Spring Boot】自动配置源码解析
smile_sundays的博客
07-28 4804
定义需要自动装配的类信息：@Configuration、@Bean，Spring Boot 配置类。设置自动配置条件依赖：@Conditional。将外部配置文件读取并封装成 Bean，让配置类读取参数：@EnableConfigurationProperties、@ConfigurationProperties。实现 Bean 的发现与加载：@EnableAutoConfiguration、@Import。
spring-boot源码解析
weixin_47723535的博客
09-07 1351
（1）为什么导入dependency时不需要指定版本？ 在springboot pom.xml文件中有两个核心依赖，分别是spring-boot-starter-parent和spring-boot-starter-web 先看spring-boot-starter-parent中的properties节点 工程的Java版本为 1.8 。 工程代码的编译源文件编码格式为 UTF-8 工程编译后的文件编码格式为 UTF-8 Maven打包编译的版本 再看Build节点，分别定义了resource和
Spring Boot源码解析：Spring 和 Spring Boot 有哪些区别？
小识的博客
01-01 992
手写一个Spring Boot 当别人问你Spring和Spring Boot的区别时，你可能会随口而出 应用可以直接运行，而不用打成jar包再放到tomcat中运行 当使用某些功能时，引入相应的starter即可，不用再配置各种Bean了 其实我觉得自动装配才是Spring Boot最大的创新。应用直接运行我们用嵌入式tomcat就可以办到。我们把之前的spring mvc项目改为直接运行 依赖如下 <dependency> <groupId>org.springfram.
果子学院Spring boot源码解析
04-22
《果子学院Spring Boot源码解析》是一套深入学习Spring Boot源码的教程，旨在帮助开发者深入了解这个流行的Java开发框架的内部工作机制。Spring Boot简化了Java应用的初始搭建以及开发过程，它集成了大量常用的第三...
Spring Boot源码（spring-boot-2.6.2.zip）
01-07
Spring Boot是Java开发中的一个关键框架，它简化了基于Spring的应用程序开发流程。Spring Boot 2.6.2是该框架的一个稳定版本，提供了一系列...对于Java开发者来说，研究Spring Boot源码是一项非常有价值的学习过程。
spring-boot-project:spring-boot原始解析-源码解析
03-24
spring-boot实现原理 读懂spring-boot预设条件是熟悉spring-framework实现原理 spring-boot特性 独立应用 嵌入式容器支持 提供starter依赖，实现自动配置 提供监控组件 构建模块 spring-boot-project依赖根 spring-...
Spring Boot 文件上传原理解析
08-27
Spring Boot 文件上传原理主要涉及到Spring MVC的处理机制。Spring Boot本身并不直接处理文件上传，而是依赖于Spring MVC的组件来完成这项任务。Spring MVC通过一个名为`MultipartResolver`的接口来处理文件上传请求...
spring-boot-source-analysis-code:SpringBoot源码解读与原理分析小册测试代码-源码解析
03-24
掘金《 SpringBoot源码解读与原理分析》小册测试和演示代码。 当初我写小册的时候，一直用的这一个工程，所以pom一直在变化（逃...），当然也由于研究原理通常最好是动手实践，所以我没做那种现成的，只要克隆下来就...
Spring
m0_74728220的博客
10-02 1243
不直接创建对象，而是由容器创建，并设定一个或多个标识，需要的时候通过Bean名字从容器中获取，这看上去是类似于EJB的服务查找，但是Spring真正的核心是对于依赖的处理，使用配置的方式注入依赖。以A、B、C三个类为例，B、C都是单例模式的类，A需要调用B、C类的方法，这样A就和B、C形成了依赖，如果B、C交由容器管理，A虽然和容器产生依赖，但是依赖程度降低了。
Spring（学习笔记）
m0_74728220的博客
10-02 1139
context:annotation-config/>是 Spring 配置文件中的一个标签，用于开启注解配置功能。这个标签可以让 Spring 容器识别并处理使用注解定义的 bean。例如，可以使用 @Autowired 注解自动装配 bean，或者使用 @Component 注解将类标记为 bean 等。为什么加载上下文的时候，被包含的Bean它的构造函数的代码会执行呀？好像是很多代码都执行了！！！没有无参构造，有有参构造会报错！也就是说必须要有无参构造！这是为什么呀！
【springboot】整合沙箱支付
BlackPudding_的博客
10-02 1328
【springboot】整合沙箱支付
健康信息管理：SpringBoot的创新应用
2402_85762143的博客
10-02 1339
Java语言具有很好的面向对象性，可以符合人的思维模式进行设计，封装是将对象的属性和方法尽可能地隐藏起来，使得外界并不知道是如何实现的，外界能通过接口进行访问，继承是指每个类都会有一个父类，所有的子类都有父类的方法，可以进行继承，但是只有final修饰的类不能被继承，通过继承可以使得代码得到重新利用，能够提高软件的开发效率，也是多态的前提。数据库存储了很多信息，可以说是信息管理系统的核心和基础，数据库还提供了添加、删除、修改和检查，使系统能够快速找到自己想要的信息，而不是在程序代码中找到。
SpringCloud入门（十二）全局过滤器和跨域
最新发布
kong7906928的博客
10-03 1066
网关Gateway全局过滤器，过滤器执行顺序，网关的跨域配合
Spring Boot入门教程与示例源码解析
资源摘要信息:"Spring Boot最全入门教程&源码.zip" 知识点： 1. Spring Boot概述： - Spring Boot是基于Spring框架的一个项目，旨在简化新Spring应用的初始搭建以及开发过程。 - 它使用“约定优于配置”的原则，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lastinglate

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值