SpringBoot2源码-嵌入式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等各种组件。代码如下:

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

可以看到这里主要面有一个注册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包下面的原因

3.4 流程框图

使用embeded tomcat进行嵌入式javaee开发-启动tomcat 立即下载

相关推荐

同花顺PC端逆向解析:Hook注入与加密破解实战指南

在Windows客户端数据采集场景中,当常规HTTP爬虫失效时,内存级逆向分析成为获取实时行情数据的关键路径。其核心涉及进程注入、运行时解密、反调试绕过等底层技术,本质是理解PE加载机制、函数调用约定与内存保护策略的协同过程。同花顺作为典型加固客户端,采用ASPack加壳+自研解密+多线程校验三重防护,迫使开发者转向APC注入、动态密钥提取与XXTEA算法复刻等高阶手段。本文聚焦于DLL注入选型依据、解密函数定位方法及二进制Blob结构化解析,最终实现从内存读取到Pandas DataFrame的端到端数据

weixin_32234493的博客 1216

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

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

一切总会归于平淡 5154

组态王|以一定的时间间隔查询某个时间段内的历史数据

使用该函数其他都可以满足,唯一问题是变量的选择,当切换站点后查询历史数据时,所选的变量依然是上次站点查询时所选择的变量,每当更换站点查询时都需要重新选择变量,这一点太繁琐,是用户和操作者无法忍受的。但是由于现场可能数据变化并非太过频繁,想要实现记录频率不变,还是以1分钟一次的频率进行存储,但是报表查询的时候想要只显示整点的数据。其中日历控件的设置与之前的历史数据查询是一样的,报表的抬头设置都是不用变的,此处不再赘述,有兴趣的可以。以上为组态王中以一定的时间间隔查询某个时间段内的历史数据的实现过程。

做有价值的事,积累有价值的笔记! 2550

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

动手学Moveit2|使用配置助手创建自己机械臂的功能包

今天没时间了,先生成功能包,下一步还需要装一些依赖才能运行,明天再补充下面的内容。

生活不止眼前的苟且 1万+

JavaScript比较与逻辑运算符底层原理详解

JavaScript中的比较运算符(如==、===、>)和逻辑运算符(如&&、||)并非简单返回布尔值,而是基于类型转换规则(ToNumber、ToPrimitive、ToBoolean)执行抽象操作的确定性过程。理解其背后的标准协议——抽象相等比较、严格相等判断、关系运算数值化,以及逻辑运算的短路与原值返回机制,是避免隐式转换陷阱、写出可预测代码的关键。这些机制直接支撑着条件判断、默认值处理、安全访问等高频工程实践,广泛应用于表单校验、API响应处理、状态管理及UI渲染逻辑中。

weixin_32075843的博客 331

Tomcat启动项目的三种方式

Tomcat启动项目的三种方式 在这里介绍在Tomcat中部署web项目的三种方式: 1.部署解包的webapp目录 2.打包的war文件 3.Manager Web应用程序 一:部署解包的webapp目录 将Web项目部署到Tomcat中的方法之一,是部署没有封装到WAR文件中的Web项目。要使用这一方法部署未打包的webapp目录,只要把我们的项目(编译好的发布项目,非开发项目)放到Tomcat的webapps目录下就可以了。如下图所示: 这时,打开Tomcat服务器(确保服务器打开),就可以在浏览器

qq_46416934的博客 1677

Web工程内嵌Tomcat实现jar运行

# Web工程内嵌Tomcat实现jar运行自从Spring boot出来后,他的嵌入式Tomcat,Jetty容器,无需部署WAR包的方式,也是受很开发运维人员的喜爱,但是碰到旧的web项目进行部署,习惯了spring boot启动方式,还是感 觉到有点狗血的,所以如何将web工程改成java -jar xx.jar 方式启动,可以使用Embeded-Tomcat,内嵌入Tomcat来达到我们的...

Harris的博客 2万+

一层一责,一聚合一包:DDD分层架构下的微服务代码模型、三重边界与服务数据协作

领域模型画得再清楚,落不进代码也是空谈。本文以一个可运行的客户中心微服务为线索,先对比整洁架构、六边形架构与DDD分层架构,指出三者共同守护的那条隔离核心业务的红线;再把DDD分层落成四个一级目录、以聚合为单位分包、一个聚合一个仓储的代码模型,拆解实体、聚合根、值对象、领域事件、领域服务与仓储的设计要点;随后厘清逻辑、物理、代码三重边界,并用检查器实测:干净代码零越界,拆出积分聚合时领域代码无需改动;注入九处越界后,必须先重构才能拆分。最后梳理服务调用三场景与PO、DO、DTO、VO的协作。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 177万+

第三天:Python基础语法详解

Python代码规范与注释最佳实践 摘要: 本文深度解析Python缩进规则与代码结构的技术规范,包括缩进的底层原理、语法规则和错误处理。详细阐述Python注释系统,涵盖行内注释、文档字符串和类型注释等多种形式,并提供工业级代码组织方案。研究显示,良好的缩进可提升40%的代码识别速度,降低50%的认知负荷。文章还对比了Sphinx、pdoc等主流文档生成工具,给出企业级项目中的注释编写原则和模板建议,帮助开发者构建更可维护的Python代码。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 1014

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

AutoConfigurationGroup#process方法调用了AutoConfigurationImportSelector或者ImportAutoConfigurationImportSelector的selectImports方法,拿到AutoConfigurationEntry,暂存在autoConfigurationEntries里,并且每个导入进来的类都暂存在entries里。可能是由多个配置类导入的,最后返回的时候要知道import进来的类是由哪个配置类import进来的。

java_lujj的博客 450

Apollo Planning2.0决策规划算法代码详细解析 (1):环境搭建

1、官方提供连接:git clone https://github.com/ApolloAuto/application-pnc.git。此外,也更新了dreamview对pnc的支持,使得调试更加方便。apollo开源团队近期更新了planning版本,对代码进行了一定程度上的重构。(2)进入docker,并编译整个工程:./apollo.sh build_dbg。下载项目环境后使用aem进行环境配置;2、有一定基础建议直接拉取最新代码,自己手动进行编译。(1)环境安装: ./dev_start.sh。

自动驾驶Player的博客 1842

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

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

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

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

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

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

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
上一篇: Eureka读时加写锁,写时加读锁,到底是故意为之还是一个bug?
下一篇: 为什么要设计非公平锁?
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值