SpringBoot2源码1-嵌入式Tomcat启动和@SpringBootApplication注解原理

SpringBoot面试核心:自动装配、启动流程与生产部署实战解析 在Java企业级开发领域,SpringBoot以其约定大于配置的理念,极大地简化了基于Spring框架的应用开发。其核心机制自动装配,通过条件注解与SpringFactoriesLoader,实现了依赖的智能导入与Bean的自动化配置,这是理解SpringBoot设计思想的关键。从技术价值看,这种机制不仅提升了开发效率,降低了配置复杂度,还为微服务架构提供了理想的构建单元。在实际应用场景中,开发者需要掌握其启动流程,理解从main方法到内嵌Servlet容器的完整初始化序列,并熟悉多种生产部署方式,例如将应 阅读详情

1. 测试案例

1.1 引入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.5</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.tomcat.embed/tomcat-embed-core -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
    <version>8.5.64</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.tomcat.embed/tomcat-embed-jasper -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <version>8.5.64</version>
</dependency>

1.2 Servlet处理类

public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("hello tomcat");
    }
}

1.3 启动类

public class Main {

    public static void main(String[] args) throws LifecycleException {
        //自己写Tomcat的启动源码
        Tomcat tomcat = new Tomcat();


        tomcat.setPort(8888);
        tomcat.setHostname("localhost");
        tomcat.setBaseDir(".");

        Context context = tomcat.addWebapp("/boot", System.getProperty("user.dir") + "/src/main");

        //给Tomcat里面添加一个Servlet
        Wrapper hello = tomcat.addServlet("/boot", "hello", new HelloServlet());
        hello.addMapping("/66"); //指定处理的请求

        tomcat.start(); //启动tomcat 注解版MVC利用Tomcat SPI机制

        tomcat.getServer().await(); //服务器等待
    }
}

直接运行main方法,在浏览器中输入 http://localhost:8888/boot/66 ,输出为:

hello tomcat

以上只是一个Tomcat的启动并使用HelloServlet处理一个请求的案例。下面我们结合SpringMVC,看如何优雅的启动。

2. 嵌入式Tomcat启动SpringMVC

2.1 最简单的方法

public class Main {

    public static void main(String[] args) throws LifecycleException {
        //自己写Tomcat的启动源码
        Tomcat tomcat = new Tomcat();


        tomcat.setPort(8888);
        tomcat.setHostname("localhost");
        tomcat.setBaseDir(".");

        Context context = tomcat.addWebapp("/boot", System.getProperty("user.dir") + "/src/main");

        //自己创建 DispatcherServlet 对象,并且创建ioc容器,DispatcherServlet里面有ioc容器
        DispatcherServlet servlet = new DispatcherServlet();
        Wrapper hello = tomcat.addServlet("/boot", "hello", servlet);

        tomcat.start(); //启动tomcat 注解版MVC利用Tomcat SPI机制

        tomcat.getServer().await(); //服务器等待
    }
}

当然,如果使用这种方法启动,需要自己往容器中注入DispatcherServlet的各种初始化(九大组件等),所以这种方式比较麻烦,我们不采用这种方式。

2.2 Tomcat的SPI机制启动

利用tomcat的SPI启动机制,SPI机制下 QuickAppStarter生效创建 ioc容器配置DispatcherServlet等各种组件。可以参考Spring5源码14-SpringMVC入口及启动流程。代码如下:

Main.java:

public class Main {

    public static void main(String[] args) throws LifecycleException {
        //自己写Tomcat的启动源码
        Tomcat tomcat = new Tomcat();


        tomcat.setPort(8888);
        tomcat.setHostname("localhost");
        tomcat.setBaseDir(".");

        Context context = tomcat.addWebapp("/boot", System.getProperty("user.dir") + "/src/main");

        tomcat.start(); //启动tomcat 注解版MVC利用Tomcat SPI机制

        tomcat.getServer().await(); //服务器等待

    }

}

QuickAppStarter类:

/**
 * 最快速的整合注解版SpringMVC和Spring的
 */
public class QuickAppStarter extends AbstractAnnotationConfigDispatcherServletInitializer {
   @Override //根容器的配置(Spring的配置文件===Spring的配置类)
   protected Class<?>[] getRootConfigClasses() {
      return new Class<?>[]{SpringConfig.class};
   }

   @Override //web容器的配置(SpringMVC的配置文件===SpringMVC的配置类)
   protected Class<?>[] getServletConfigClasses() {
      return new Class<?>[]{SpringMVCConfig.class};
   }

   @Override //Servlet的映射,DispatcherServlet的映射路径
   protected String[] getServletMappings() {
      return new String[]{"/"};
   }

   @Override
   protected void customizeRegistration(ServletRegistration.Dynamic registration) {
//    super.customizeRegistration(registration);

//    registration.addMapping("");//
   }
}

启动后,在浏览器访问http://localhost:8888/boot/hello66 ,输出为:

66666666~~~~~

SpringBoot就是采用上面的这种方式来启动Tomcat的。SpringBoot封装了功能的自动配置,导入各种starter依赖,SpringBoot封装了很多的自动配置,帮我们给容器中放了很多组件。

3. @SpringBootApplication 注解原理

1.@SpringBootApplication注解

对于Springboot项目,它有一个启动类。一般如下(此处以Springboot演示案例为例):

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

从上述代码里看出,启动类引用了一个注解 @SpringBootApplication,而
@SpringBootApplication实际上是一个复合注解,它的类定义如下所示:

@Target(ElementType.TYPE)         
@Retention(RetentionPolicy.RUNTIME)
@Documented                     
@Inherited                        
@SpringBootConfiguration             // 继承了Configuration,表示当前是注解类
@EnableAutoConfiguration             // 开启自动配置
@ComponentScan(excludeFilters = {    // 扫描组件
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}

实际上 @SpringBootApplication内的核心注解有三个: @SpringBootConfiguration, @EnableAutoConfiguration, @ComponentScan

3.1 @SpringBootConfiguration

@SpringBootConfiguration实际上是引入的@Configuration,而@Configuration是Spring的注解类,用于定义配置类,并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中,并且实例名就是方法名,等同于spring的XML配置文件。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

 @Configuration与XML配置的简单对比如下:

@Configuration
public class SpringDemo{

}

等价于XML形式的<beans></beans>:

<?xml version="1.0" encoding="UTF-8" ?>
<beans   xmlns="http://www.springframework.org/schema/beans" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
</beans>

3.2 @EnableAutoConfiguration

@EnableAutoConfiguration是借助@Import的帮助,将所有符合自动配置条件的bean定义加载到IoC容器,它也是复合注解,定义如下所示:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage      //自动配置包
@Import({AutoConfigurationImportSelector.class})  //借助AutoConfigurationImportSelector自动配置类
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

@EnableAutoConfiguration里重要的注解分别是@AutoConfigurationPackage和@Import(AutoConfigurationImportSelector.class),看名知意,@AutoConfigurationPackage:自动配置包,AutoConfigurationImportSelector:自动配置组件的导入。

3.2.1 @AutoConfigurationPackage

@AutoConfigurationPackage具体定义如下所示:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

由@AutoConfigurationPackage定义可以看出,实际是借助@Import导入了Registrar,而Registrar中主要调用了registerBeanDefinition方法来进行bean定义的注册。Registrar类定义如下:

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //此处是注册了一个Bean的定义。
            //getPackageName()其实返回了当前主程序类的 同级以及子级的包组件。
            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
           
        }
        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
        }
    }

Registrar里registerBeanDefinitions实际是调用AutoConfigurationPackages的register方法,其定义如下:

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
   if (registry.containsBeanDefinition(BEAN)) {
      BasePackagesBeanDefinition beanDefinition = (BasePackagesBeanDefinition) registry.getBeanDefinition(BEAN);
      beanDefinition.addBasePackages(packageNames);
   }
   else {
      registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
   }
}

作者:hsfxuebao
链接:https://juejin.cn/post/7145073146272432158
来源:稀土掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

可以看到这里主要面有一个注册bean定义的方法,主要就是把被org.springframework.boot.autoconfigure.SpringBootApplication注解标记的包的定义信息注册到容器中中 。

3.2.2 AutoConfigurationImportSelector

AutoConfigurationImportSelector实现了DeferredImportSelector,所以@EnableAutoConfiguration什么时候处理已经清楚了: ConfigurationClassParser解析启动类这个配置类过程中处理了该注解,由于AutoConfigurationImportSelector是一个DeferredImportSelector,所以会将AutoConfigurationImportSelector暂存在DeferredImportSelectorHandler#deferredImportSelectors一个List中,等当前一轮配置类都解析完了才会处理AutoConfigurationImportSelector。

DeferredImportSelector

// ImportSelector
public interface ImportSelector {

   String[] selectImports(AnnotationMetadata importingClassMetadata);

   @Nullable
   default Predicate<String> getExclusionFilter() {
      return null;
   }
}

public interface DeferredImportSelector extends ImportSelector {

	@Nullable
	default Class<? extends Group> getImportGroup() {
		return null;
	}

	interface Group {
		void process(AnnotationMetadata metadata, DeferredImportSelector selector);

		Iterable<Entry> selectImports();

		class Entry {

			private final AnnotationMetadata metadata;
			private final String importClassName;
            
            // constructor, getters and setters
		}
	}
}

ImportSelector比较简单,就是一个selectImports方法,就是基于当前配置类的AnnotationMetadata返回一些需要import的类名。DeferredImportSelector扩展了ImportSelector,增加了getImportGroup方法,作用是什么?

由于DeferredImportSelector是先暂存,延迟到一批配置类处理完后会统一处理这些DeferredImportSelector,此时这些不同的DeferredImportSelector导入哪些类可以放在一起做一定的逻辑处理。每个DeferredImportSelector的会属于一个Group,属于同一个Group的DeferredImportSelector会统一处理,Group为null则默认为DefaultDeferredImportSelectorGroup。Entry保存了需要import的类名和配置类的AnnotationMetadata的映射关系,因为多个DeferredImportSelector可能是由多个配置类导入的,最后返回的时候要知道import进来的类是由哪个配置类import进来的

DeferredImportSelector调用上与ImportSelector不同,对于ImportSelector,会直接调用selectImports;而对于DeferredImportSelector,外部先按照Group对所有DeferredImportSelector进行分组,属于同一组的DeferredImportSelector,调用这个组的Group#process方法处理每个DeferredImportSelector,Group#process里面一般会调用DeferredImportSelector#selectImports将导入进来的类暂存一下,然后调用一次Group#selectImports方法,返回这一组DeferredImportSelector最重要import的类

DefaultDeferredImportSelectorGroup

先看一下默认的DefaultDeferredImportSelectorGroup实现细节

private static class DefaultDeferredImportSelectorGroup implements Group {

        private final List<Entry> imports = new ArrayList<>();

        @Override
        public void process(AnnotationMetadata metadata, DeferredImportSelector selector) {
                for (String importClassName : selector.selectImports(metadata)) {
                        this.imports.add(new Entry(metadata, importClassName));
                }
        }

        @Override
        public Iterable<Entry> selectImports() {
                return this.imports;
        }
}

imports保存了导入类的Entry。process方法将DeferredImportSelector导入了的类缓存一下;然后selectImports返回每个DeferredImportSelector导入的类。

既然多个DeferredImportSelector属于一个Group,那么哪些DeferredImportSelector属于AutoConfigurationGroup?

  • AutoConfigurationImportSelector和ImportAutoConfigurationImportSelector都属于AutoConfigurationGroup,分别对应@EnableAutoConfiguration注解和@ImportAutoConfiguration注解

AutoConfigurationGroup

private static class AutoConfigurationGroup
                implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {

        private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();

        private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();

        @Override
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
                Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                                () -> String.format("Only %s implementations are supported, got %s",
                                                AutoConfigurationImportSelector.class.getSimpleName(),
                                                deferredImportSelector.getClass().getName()));
                AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
                                .getAutoConfigurationEntry(annotationMetadata);
                this.autoConfigurationEntries.add(autoConfigurationEntry);
                for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                        this.entries.putIfAbsent(importClassName, annotationMetadata);
                }
        }
}

AutoConfigurationGroup#process过程

AutoConfigurationGroup#process方法调用了AutoConfigurationImportSelector或者ImportAutoConfigurationImportSelector的selectImports方法,拿到AutoConfigurationEntry,暂存在autoConfigurationEntries里,并且每个导入进来的类都暂存在entries里。

两个ImportSelector的selectImports做了什么?

AutoConfigurationImportSelector#selectImports

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
                return NO_IMPORTS;
        }
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
                return EMPTY_ENTRY;
        }
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        // 从 spring.factories 里面去读取配置的好的AutoConfiguration类
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = getConfigurationClassFilter().filter(configurations);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
}

可以看到这里主要做了三件事:

  1. 加载需要自动配置的类信息;
  2. 根据条件筛选自动配置类信息;
  3. 发布事件

接下来,我们看一下getCandidateConfigurations()方法:

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;
}

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
}

接下来,我们看一下SpringFactoriesLoader.loadFactoryNames()方法:

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
   Map<String, List<String>> result = cache.get(classLoader);
   if (result != null) {
      return result;
   }

   result = new HashMap<>();
   try {
      Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
      while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         UrlResource resource = new UrlResource(url);
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
         for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String factoryTypeName = ((String) entry.getKey()).trim();
            String[] factoryImplementationNames =
                  StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
            for (String factoryImplementationName : factoryImplementationNames) {
               result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                     .add(factoryImplementationName.trim());
            }
         }
      }

      // Replace all lists with unmodifiable lists containing unique elements
      result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
      cache.put(classLoader, result);
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
   return result;
}

AutoConfigurationImportSelector#selectImports实际上就是调用了SpringFactoriesLoader从spring.factories里面去读取配置的好的AutoConfiguration类。

我们来看一下 META-INF/spring.factories下的文件:

我们看其中一个类:

可以看到这里面定义了一堆需要自动装配的bean,而这些ben里面都会有一个或多个条件,也就是说他要装配这个bean,需要满足已经达成这些条件才进行自动装配

AutoConfigurationGroup#selectImports过程

AutoConfigurationGroup#selectImports方法主要做了两个事情

  • 导进来的类排掉exclusion
  • 排序,返回
private static class AutoConfigurationGroup
                implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {

        private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();

        private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();

@Override
        public Iterable<Entry> selectImports() {
                if (this.autoConfigurationEntries.isEmpty()) {
                        return Collections.emptyList();
                }
                Set<String> allExclusions = this.autoConfigurationEntries.stream()
                                .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
                Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
                                .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
                                .collect(Collectors.toCollection(LinkedHashSet::new));
                processedConfigurations.removeAll(allExclusions);

                return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
                                .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
                                .collect(Collectors.toList());
        }
}

 主要看一下配置类的排序逻辑:

private List<String> sortAutoConfigurations(Set<String> configurations,
                AutoConfigurationMetadata autoConfigurationMetadata) {
        return new AutoConfigurationSorter(getMetadataReaderFactory(), autoConfigurationMetadata)
                        .getInPriorityOrder(configurations);
}

其实还是通过AutoConfigurationSorter来排序的,看一下AutoConfigurationSorter#getInPriorityOrder方法:

List<String> getInPriorityOrder(Collection<String> classNames) {
        AutoConfigurationClasses classes = new AutoConfigurationClasses(this.metadataReaderFactory,
                        this.autoConfigurationMetadata, classNames);
        List<String> orderedClassNames = new ArrayList<>(classNames);
        // Initially sort alphabetically
        Collections.sort(orderedClassNames);
        // Then sort by order
        orderedClassNames.sort((o1, o2) -> {
                int i1 = classes.get(o1).getOrder();
                int i2 = classes.get(o2).getOrder();
                return Integer.compare(i1, i2);
        });
        // Then respect @AutoConfigureBefore @AutoConfigureAfter
        orderedClassNames = sortByAnnotation(classes, orderedClassNames);
        return orderedClassNames;
}

注释上:先按字母顺序排序,再按order排序,最后按@AutoConfigureBefore @AutoConfigureAfter两个注解排序,由于排序是稳定排序,所有三种排序方法中:注解定义的顺序优先;注解没定义顺序则按order来;order相同则按字母顺序

order排序怎么排?

  • classes.get(o1)获取到了AutoConfigurationClass,AutoConfigurationClass#getOrder实际上获取的是AutoConfigureOrder定义的order,跟ordered接口、@Order注解都没关系,主要是为了不影响bean注册的顺序
private int getOrder() {
        if (wasProcessed()) {
                return this.autoConfigurationMetadata.getInteger(this.className, "AutoConfigureOrder",
                                AutoConfigureOrder.DEFAULT_ORDER);
        }
        Map<String, Object> attributes = getAnnotationMetadata()
                        .getAnnotationAttributes(AutoConfigureOrder.class.getName());
        return (attributes != null) ? (Integer) attributes.get("value") : AutoConfigureOrder.DEFAULT_ORDER;
}
  • getAutoConfigurationMetadata()封装自动配置元数据信息

  • private AutoConfigurationMetadata getAutoConfigurationMetadata() {
       if (this.autoConfigurationMetadata == null) {
          this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
       }
       return this.autoConfigurationMetadata;
    }

    AutoConfigurationMetadataLoader类:

static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
   try {
      Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
            : ClassLoader.getSystemResources(path);
      Properties properties = new Properties();
      while (urls.hasMoreElements()) {
         properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
      }
      return loadMetadata(properties);
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
   }
}

 

可以看到这里主要就是去加载spring-autoconfigure-metadata.properties文件中的信息进行封装返回,那这个文件里都定义了啥呢: 可以看到这里主要就是定义了一些需要自动配置的类自动装配需要满足的一些条件

3.3 @ComponentScan

@ComponentScan的功能其实就是自动扫描并加载符合条件的组件(比如@Component和@Repository等)或者bean定义,最终将这些bean定义加载到IoC容器中。我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围,如果不指定,则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。

注意:开发者可以通过basePakage等属性来细粒度的定制@ComponentScan自动扫描的范围。如果不指定,则默认Spring框架实现会从声明·@ComponentScan·所在类的·package·进行扫描。这就是SpringBoot的启动类为什么最好放在root package包下面的原因

 

tomcat-embed-core-9.0.16.jar 立即下载

相关推荐

PostgreSQL14 离线安装全攻略:从下载到配置详解

本文详细介绍了PostgreSQL14在无网络环境下的离线安装全流程,涵盖RPM包与源码编译两种主流方法。文章重点解析了安装前的系统环境检查、依赖包准备、数据库初始化、远程访问配置以及安装后的关键检查与性能调优,旨在帮助运维和开发人员在离线服务器上高效、稳定地部署PostgreSQL14数据库。

p5l2m9n4o6q的博客 732

11-30 SpringBoot

tomcat的依赖 对于tomcat其实还是一个jar包 spring是一个IOC容器 tomcat的核心对象交给Spring容器 调用核心对象方法 启动Tomcat。对于tomcat的依赖排除以及tomcat的重新非排除设置:加入exclutions配置进行排除即可,以及使用jetty依赖进行tomcat的重新加入。二.在命令行运行springboot项目:mvc命令 mvc spring-boot:run。springboot的打包插件: spring-boot-maven-plugin。

weixin_53415999的博客 2822

双击文件夹弹窗“找不到应用程序”,但是右键点击打开可以

此电脑、回收站、c、d、f盘、控制面板、任意文件夹等都没有办法双击打开。 右键中包含“使用filemanager打开”,是由于FileManager卸载残留导致的。 懒人专用附件 下载解压上面附件,双击导入可以清理FileManager软件残留 参考: 双击此电脑出现找不到应用程序,但是右键点击可以-其他-优快云问答https://ask.youkuaiyun.com/questions/7631439 电脑上的文件夹双击都提示找不到应用程序,但是右击打开就能打开,该怎么解决? - 知乎 (z

webmasterqpwou的博客 1万+

Spring Boot辅助功能之内嵌服务器【Tom Cat】

内嵌Tomcat服务器是SpringBoot辅助功能之一

一切总会归于平淡 5154

【全网最新】使用 1panel面板 部署若依系统( springboot 和 vue)项目

打开前端项目的vue.config.js文件,检查devServer下的proxy代理部分,然后将下面这个端口修改为你要在打包后访问的端口,即使用nginx代理前的接口。这个端口默认是80端口,这里把其修改为不会冲突的8010端口,后台接口的地址配置为9080,不过感觉这里设置的8010和9080可能没有用,因为部署前端静态页面是,也配置了一次网页的外部接口和api的接口,后期有空了再验证。打开右侧的Maven,点击:生存期->package,然后点击运行,等待打包成功,包在如图所示的文件夹中。

老薛的专栏 1758

Shader Graph实战:5分钟搞定Flow Map水体流动效果(含UV偏移避坑指南)

本文详细解析了如何使用Unity的Shader Graph工具快速实现Flow Map水体流动效果,涵盖基础原理、核心节点搭建、高级技巧及性能优化。特别针对UV偏移问题提供避坑指南,帮助开发者轻松打造专业级动态水面效果,适合游戏场景增强视觉表现。

weixin_29250403的博客 246

SpringBoot启动过程分析

SpringBoot启动过程分析 SpringBoot的出现给我们带了许多的便利性,其中一点就是可以内置tomcat,从而实现从jar包直接运行,那么SpringBoot是怎么实现的呢? 嵌入式tomcat 在一个简单的SpringBoot项目中,我们只需要在项目中添加spring-boot-starter-web依赖,然后通过SpringApplication.run方法就可以启动一个web服务。查看spring-boot-starter-web的依赖关系,发现其依赖了tomcat-embed-cor

ja.rome 4679

手把手教你学Simulink--四翼无人机滑模控制器设计与仿真

四翼无人机(Quadcopter)滑模控制(Sliding Mode Control, SMC)是一种鲁棒性很强的非线性控制方法,特别适用于存在模型不确定性和外部扰动的情况。滑模控制器通过强制系统状态进入并保持在一个预定义的滑模面上,从而实现对期望轨迹或姿态的精确跟踪。在这个教程中,我们将使用MATLAB和Simulink来设计并仿真一个基于滑模控制策略的四翼无人机系统。

MHD0815的博客 185

SpringBoot关于内嵌tomcat的相关问题

Springboot

weixin_45827905的博客 4362

【3D Slicer】的小白入门使用指南一

3D Slicer 是一个免费的开源软件平台,用于医学、生物医学和其他 3D 图像的可视化、处理、分割、配准和分析。Slicer 的功能包括:读/写。

图挖掘领域,新晋砖家 ☞ 未来可期,欢迎和静静一起学习交流吖 5559

Python爬虫实战:高德地图POI信息爬取(餐馆/加油站等),附选址分析技巧

高德API配置AMAP_KEY = "你的高德API Key" # 替换成自己的Key# 爬取参数CITY = "成都" # 城市DISTRICTS = ["锦江区"] # 区域,可添加多个(比如["锦江区", "武侯区"])KEYWORDS_LIST = ["川菜馆", "加油站"] # 要爬取的POI类型TYPES = {"川菜馆": "050101", # 餐饮服务→中餐→川菜馆(高德POI分类编码)"加油站": "110100" # 交通设施→加油站。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 2473

SpringBoot2源码-嵌入式Tomcat启动和@SpringBootApplication注解原理

SpringBoot封装了功能的自动配置,导入各种starter依赖,SpringBoot封装了很多的自动配置,帮我们给容器中放了很多组件。的selectImports方法,拿到AutoConfigurationEntry,暂存在autoConfigurationEntries里,并且每个导入进来的类都暂存在entries里。可能是由多个配置类导入的,最后返回的时候要知道import进来的类是由哪个配置类import进来的。是Spring的注解类,用于定义配置类,并会将当前类内声明的一个或多个以。

老男孩的架构路 818

RLHF 家族的奇巧魔改:On Policy 与 Off Policy 路线大PK

无论是 On Policy 还是 Off Policy,RLHF 家族的“魔改”之路都充满了奇思妙想。相信随着研究的深入,RLHF 技术将会在 Alignment 领域发挥越来越重要的作用。

步子哥的博客 2083

SpringBoot源码深度剖析——@SpringBootApplication注解和new SpringApplication().run()方法深度解密

SpringBoot源码深度剖析一、依赖管理1.spring-boot-starter-parent依赖2.spring-boot-starter-web依赖二、自动装配(启动流程)三、@SpringBootApplication注解的底层实现1.@SpringBootConfifiguration注解2.@EnableAutoConfifiguration注解(1)@AutoConfifigurationPackage注解(2)@Import(AutoConfigrationImportSelector.

weixin_42460087的博客 2134

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

SpringBoot启动嵌入式tomcat源码解读

原文链接:http://www.studyshare.cn/blog-front/blog/details/1136/1 一、SpringBoot自动拉起Tomcat SpringBoot框架是当前比较流行的java后端开发框架,与maven结合大大简化了开发人员项目搭建的步骤,我们知道SpringBoot的启动类启动后,tomcat容器、SpringMVC、spring事务等...

Adonis_D_Gogh的博 客 949

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

SpringBoot嵌入Tomcat原理分析

SpringBoot嵌入Tomcat原理 内嵌Tomcat启动原理 首先,来到启动SpringBoot项目的地方,也就是朱配置类. @SpringBootApplication public class InakiApplication { public static void main(String[] args) { SpringApplication.run(InakiApplication.class, args); } } 点击@SpringBootAp

weixin_43169335的博客 1077

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

springboot 自定义启动类_SpringBoot启动tomcat源码解读

一、SpringBoot自动拉起Tomcat SpringBoot框架是当前比较流行的java后端开发框架,与maven结合大大简化了开发人员项目搭建的步骤,我们知道SpringBoot的启动类启动后,tomcat容器、SpringMVC、spring事务等第三方依赖也已经自动启动。那么SpringBoot是如何启动这些第三方依赖的呢?下面以SpringBoot拉起tomcat容器为...

weixin_39526459的博客 296

springboot 是如何启动tomcat的

1. 添加 @SpringBootApplication注解 点击进入该注解,我们可以发现其是一个复合注解,包括@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。 @SpringBootConfiguration 该注解底层其实就是@Configuration注解。 从Spring3.0,@Configuration用于定义配置类,可替换xml配置文件,被注解的类内部包含有一个或多个被@Bean注解的方法,这些方法将

sun 1248

三方源码 画饼图_SpringBoot启动tomcat源码解读

一、SpringBoot自动拉起Tomcat SpringBoot框架是当前比较流行的java后端开发框架,与maven结合大大简化了开发人员项目搭建的步骤,我们知道SpringBoot的启动类启动后,tomcat容器、SpringMVC、spring事务等第三方依赖也已经自动启动。那么SpringBoot是如何启动这些第三方依赖的呢?下面以SpringBoot拉起tomcat容器为...

weixin_39886929的博客 73

手写 Spring Boot 嵌入式Tomcat项目开发教学

本文将详细介绍如何从零开始开发一个基于Spring Boot和嵌入式Tomcat的Web应用程序。 该项目采用现代化的Java技术栈,展示了Spring Boot的核心特性和最佳实践。

桃李不言下自成蹊 1079

SpringBoot源码解析:从自动装配到核心机制

SpringBoot作为Java生态中广泛使用的框架,其核心机制如自动装配、启动流程和外部化配置是开发者必须掌握的技术要点。自动装配通过条件注解和配置类加载机制实现组件智能注入,大幅简化了Spring应用的配置复杂度。从技术实现来看,SpringBoot利用Spring框架的扩展点,在应用启动时通过Environment准备运行环境,结合内嵌容器实现开箱即用的Web服务能力。这些设计不仅提升了开发效率,也为微服务架构提供了基础设施支持。通过分析自动配置原理和启动过程源码,开发者可以深入理解框架的扩展机制,解

weixin_33670713的博客 343

SpringBoot启动流程源码剖析

前言 今天学习了springBoot,对spring框架的兼容性和强大所折服,然后自己扒了源码,上网也搜了一些,总结了一下。刚学springBoot的时候只觉得很强大,综合了自动配置和启动Tomcat服务器,当时就好奇怎么启动的,在执行启动类的时候,spring帮我们做了什么?然后扒了源码,根据自己和网上教程的理解,写了如下内容: 1、SpringBoot的认识 既然要学springBoot当然要知道其主要作用是什么,SpringBoot时Spring项目的一个子工程,是Spring Framework同属

weixin_44160476的博客 285

springboot原理

引言 不论在工作中,亦或是求职面试,Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外,如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然,作为Spring Boot的精髓,自动配置原理的工作过程往往只有在“面试”的时候才能用得上,但是如果在工作中你能够深入的理解Spring Boot的自动配置原理,将无往不利。 Spring Boot的出现,得益于“习惯优于配置”的理念,没有繁琐的配置、难以集成的内容(大多数流行第三方技术都被集成),

梦想是很难很难的,所以先勇敢一点 275

SpringBoot自动配置原理与生产实践指南

依赖注入和面向切面编程是现代Java开发的核心技术,Spring框架通过IoC容器实现了这些理念。自动配置机制基于条件注解(如@ConditionalOnClass)智能加载组件,大幅减少了XML配置的复杂度。这种设计显著提升了开发效率,特别适合微服务架构和云原生应用场景。SpringBoot作为Spring的增强工具链,通过起步依赖和嵌入式容器等特性,解决了传统JavaEE项目中的配置地狱问题。结合Actuator提供的健康检查与性能监控能力,开发者可以快速构建生产级应用。本文深入解析自动配置的底层机制,

weixin_34054866的博客 398

SpringBoot基础知识点汇总

本文介绍了SpringBoot框架的基础知识点,包括其简化Spring应用开发的作用和三大核心技术:内置Tomcat服务器、起步依赖管理(基于Maven依赖传递)和自动配置机制。重点解析了自动配置原理。文章还提出关于自动配置类筛选条件的问题。全文对SpringBoot核心机制进行了简明扼要的梳理。

A93793616的博客 1580
上一篇: 基于SpringDataElasticsearch+SpEL表达式实现ES动态索引
下一篇: 两万字带你了解Java多线程(详细大总结)
java_lujj
博客等级 码龄4年 18粉丝 152原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值