@ZhouyuSpringBootApplicationpublic class MyApplication {public static void main(String[] args) {ZhouyuSpringApplication.run(MyApplication.class);}}

run方法

run方法中需要实现什么具体的逻辑呢？

        首先，我们希望run方法一旦执行完，我们就能在浏览器中访问到UserController，那势必在run方法 中要启动Tomcat，通过Tomcat就能接收到请求了。

        大家如果学过Spring MVC的底层原理就会知道，在SpringMVC中有一个Servlet非常核心，那就是 DispatcherServlet，这个DispatcherServlet需要绑定一个Spring容器，因为DispatcherServlet接收 到请求后，就会从所绑定的Spring容器中找到所匹配的Controller，并执行所匹配的方法。

所以，在run方法中，我们要实现的逻辑如下：

1. 创建一个Spring容器

2. 创建Tomcat对象

3. 生成DispatcherServlet对象，并且和前面创建出来的Spring容器进行绑定

4. 将DispatcherServlet添加到Tomcat中

5. 启动Tomcat

创建Spring容器

这个步骤比较简单，代码如下

public class ZhouyuSpringApplication {public static void run(Class clazz){AnnotationConfigWebApplicationContext applicationContext = new
AnnotationConfigWebApplicationContext();applicationContext.register(clazz);applicationContext.refresh();}}

        我们创建的是一个AnnotationConfigWebApplicationContext容器，并且把run方法传入进来的class 作为容器的配置类，比如在MyApplication的run方法中，我们就是把MyApplication.class 传入到了 run方法中，最终MyApplication就是所创建出来的Spring容器的配置类，并且由于MyApplication类 上有@ZhouyuSpringBootApplication注解，而@ZhouyuSpringBootApplication注解的定义上又 存在@ComponentScan注解，所以AnnotationConfigWebApplicationContext容器在执行refresh时，就会解析MyApplication这个配置类，从而发现定义了@ComponentScan注解，也就知道了要 进行扫描 ，只不过扫描路径为空，而AnnotationConfigWebApplicationContext容器会处理这种情 况，如果扫描路径会空，则会将MyApplication所在的包路径做为扫描路径 ，从而就会扫描到UserService和UserController。

所以Spring容器创建完之后，容器内部就拥有了UserService和UserController这两个Bean。

启动Tomcat

我们用的是Embed-Tomcat，也就是内嵌的Tomcat，真正的SpringBoot中也用的是内嵌的Tomcat，

而对于启动内嵌的Tomcat，也并不麻烦，代码如下：

public class TomcatWebServer implements WebServer{@Overridepublic void start() {System.out.println("启动Tomcat");}public static void startTomcat(WebApplicationContext applicationContext){Tomcat tomcat = new Tomcat();Server server = tomcat.getServer();Service service = server.findService("Tomcat");Connector connector = new Connector();connector.setPort(8081);Engine engine = new StandardEngine();engine.setDefaultHost("localhost");Host host = new StandardHost();host.setName("localhost");String contextPath = "";Context context = new StandardContext();context.setPath(contextPath);context.addLifecycleListener(new Tomcat.FixContextListener());host.addChild(context);engine.addChild(host);service.setContainer(engine);service.addConnector(connector);tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(applicationContext));context.addServletMappingDecoded("/*", "dispatcher");try {tomcat.start();} catch (LifecycleException e) {e.printStackTrace();}}
}

        代码虽然看上去比较多，但是逻辑并不复杂，比如配置了Tomcat绑定的端口为8081，后面向当前 Tomcat中添加了DispatcherServlet，并设置了一个Mapping关系，最后启动，其他代码则不用太过

关心。

        而且在构造DispatcherServlet对象时，传入了一个ApplicationContext对象，也就是一个Spring容 器，就是我们前文说的，DispatcherServlet对象和一个Spring容器进行绑定。

接下来，我们只需要在run方法中，调用startTomcat即可：

        接下来，我们只需要在run方法中，调用startTomcat即可：

 public static void run(Class clazz){
AnnotationConfigWebApplicationContext applicationContext = new
AnnotationConfigWebApplicationContext();applicationContext.register(clazz); 
applicationContext.refresh(); startTomcat(applicationContext);}

        实际上代码写到这，一个极度精简版的SpringBoot就写出来了，比如现在运行MyApplication，就能正常的启动项目，并能接收请求。

启动能看到Tomcat的启动日志：

然后在浏览器上访问： http://localhost:8081/test

也能正常的看到结果：

@Target({ ElementType.TYPE, ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Conditional(ZhouyuOnClassCondition.class)public @interface ZhouyuConditionalOnClass {String value() default "";}

注意核心为@Conditional(ZhouyuOnClassCondition.class)中的ZhouyuOnClassCondition，因为
它才是真正得条件逻辑:

public class ZhouyuOnClassCondition implements Condition {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {Map<String, Object> annotationAttributes =
metadata.getAnnotationAttributes(ZhouyuConditionalOnClass.class.getName());String className = (String) annotationAttributes.get("value");try {context.getClassLoader().loadClass(className);return true;} catch (ClassNotFoundException e) {return false;}}}

        具体逻辑为，拿到@ZhouyuConditionalOnClass中的value属性，然后用类加载器进行加载，如果加载到了所指定的这个类，那就表示符合条件，如果加载不到，则表示不符合条件。

模拟实现自动配置类
有了条件注解，我们就可以来使用它了，那如何实现呢？

这里就要用到自动配置类的概念，我们先看代码：

@Configuration
public class WebServiceAutoConfiguration {@Bean@ZhouyuConditionalOnClass("org.apache.catalina.startup.Tomcat")public TomcatWebServer tomcatWebServer(){return new TomcatWebServer();}@Bean@ZhouyuConditionalOnClass("org.eclipse.jetty.server.Server")public JettyWebServer jettyWebServer(){return new JettyWebServer();}
}

只有存在"org.apache.catalina.startup.Tomcat"类，那么才有TomcatWebServer这个Bean
只有存在"org.eclipse.jetty.server.Server"类，那么才有TomcatWebServer这个Bean

并且我们只需要在ZhouyuSpringApplication中getWebServer方法，如此实现：

public static WebServer getWebServer(ApplicationContext applicationContext){// key为beanName, value为Bean对象
Map<String, WebServer> webServers =
applicationContext.getBeansOfType(WebServer.class);if (webServers.isEmpty()) {
throw new NullPointerException(); }if (webServers.size() > 1) {
throw new IllegalStateException(); }// 返回唯一的一个return webServers.values().stream().findFirst().get();}

这样整体SpringBoot启动逻辑就是这样的：

        1. 创建一个AnnotationConfigWebApplicationContext容器

        2. 解析MyApplication类，然后进行扫描

        3. 通过getWebServer方法从Spring容器中获取WebServer类型的Bean

        4. 调用WebServer对象的start方法

有了以上步骤，我们还差了一个关键步骤，就是Spring要能解析到WebServiceAutoConfiguration这 个自动配置类，因为不管这个类里写了什么代码，Spring不去解析它，那都是没用的，此时我们需要 SpringBoot在run方法中，能找到WebServiceAutoConfiguration这个配置类并添加到Spring容器 中。

        MyApplication是Spring的一个配置类，但是MyApplication是我们传递给SpringBoot，从而添加到 Spring容器中去的，而WebServiceAutoConfiguration就需要SpringBoot去自动发现，而不需要程 序员做任何配置才能把它添加到Spring容器中去，而且要注意的是，Spring容器扫描也是扫描不到 WebServiceAutoConfiguration这个类的，因为我们的扫描路径是"com.zhouyu.user"，而

WebServiceAutoConfiguration所在的包路径为"com.zhouyu.springboot"。

        那SpringBoot中是如何实现的呢？通过SPI，当然SpringBoot中自己实现了一套SPI机制，也就是我们 熟知的spring.factories文件，那么我们模拟就不搞复杂了，就直接用JDK自带的SPI机制。

发现自动配置类

        为了实现这个功能，以及为了最后的效果演示，我们需要把springboot源码和业务代码源码拆分两个 maven模块，也就相当于两个项目，最后的源码结构为

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan
@Import(ZhouyuImportSeclet.class)
public @interface ZhouyuSpringBootApplication {
}

public class ZhouyuImportSeclet implements DeferredImportSelector {@Overridepublic String[] selectImports(AnnotationMetadata importingClassMetadata) {// 自动配置ServiceLoader<AutoConfiguration> loader = ServiceLoader.load(AutoConfiguration.class);List<String> list = new ArrayList<>();for (AutoConfiguration configuration : loader) {list.add(configuration.getClass().getName());}return list.toArray(new String[0]);}
}

这就完成了从com.zhouyu.springboot.AutoConfiguration文件中获取自动配置类的名字，并导入到

Spring容器中，从而Spring容器就知道了这些配置类的存在，而对于user项目而言，是不需要修改代 码的。

此时运行MyApplication，就能看到启动了Tomcat：

因为SpringBoot默认在依赖中添加了Tomcat依赖，而如果在User模块中再添加jetty的依赖：