SpringBoot の基礎となる原理は何ですか?

手書きの springboot

日々の開発では、次の依存関係を導入するだけでアクセス用のサーブレットを開発できます。

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

それでは、これはどのように行われるのでしょうか?今日は調べてみましょう

まず、新しい Maven プロジェクト rick-spring-boot を作成し、2 つのサブプロジェクト、つまり spring-boot と user を作成します。spring-boot プロジェクトは、単純な springboot と user の手書きをシミュレートすることです。手書きの Spring-Boot をテストするために使用されます。

ユーザー プロジェクト-テスト プロジェクト

ユーザー プロジェクトには、pom.xml、UserController、UserService

<dependencies>
    <dependency>
      <groupId>com.rick.spring.boot</groupId>
      <artifactId>spring-boot</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping("/user")
    public String getUser() {
        return userService.getUser();
    }
}
@Service
public class UserService {
    public String getUser() {
        return "rick";
    }
}

とスタートアップ クラスが含まれています。ユーザー プロジェクトの RickApplication と RickSpringApplication.run() には、手書きのスタートアップ クラスと @RickSpringBootApplication アノテーションが必要で、これらは Spring-Boot プロジェクトに実装する必要があります。

import com.rick.spring.boot.RickSpringApplication;
import com.rick.spring.boot.RickSpringBootApplication;
@RickSpringBootApplication
public class RickApplication {
    public static void main(String[] args) {
        RickSpringApplication.run(RickApplication.class);
    }
}

Springboot プロジェクト

まず、RickSpringApplication.run(RickApplication.class) メソッドが何をする必要があるかを見てみましょう:

(1) Spring コンテナを作成して渡します。クラスは Spring コンテナに登録されます

(2) Tomcat などの Web サービスを開始してリクエストを処理し、DispatchServlet を介してリクエストを処理するサーブレットに配布します。

public class RickSpringApplication {
    public static void run(Class clz) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(clz);
        context.refresh();
        start(context);
    }
    public static void start(WebApplicationContext applicationContext) {
        System.out.println("start tomcat");
        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();
        }
    }
}

RickApplication は @RickSpringBootApplication アノテーションによって変更されます。次のコードから、RickApplication が構成クラスであることがわかります。Spring コンテナーに登録された後、Spring はこのクラスを解析します。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Configuration
@ComponentScan
public @interface RickSpringBootApplication {
}

ユーザー プロジェクト RickApplication のメイン メソッドを開始し、

UserController にアクセスします

Thisシンプルな spring-boot プロジェクトが統合されています。

自動構成

Tomcat と Jetty 間の切り替えを実現する

SpringBoot を使用する場合、リクエスト処理サービスとして Tomcat を使用せず、jetty または他の Web サービスを使用する場合, 通常は、関連する Tomcat の依存関係を除外してから、jetty の依存関係を導入するだけで済みます。これが springboot の自動アセンブリのメカニズムです。次に、実装方法を見てみましょう

WebServer インターフェイスと 2 つの実装クラス (Tomcat と Jetty) を定義し、Tomcat と Jetty サービスを開始するコードを作成します

public interface WebServer {
    void start();
}
public class JettyServer implements WebServer{
    @Override
    public void start() {
        System.out.println("start jetty");
    }
}

public class TomcatServer implements WebServer, ApplicationContextAware {
    private WebApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = (WebApplicationContext) applicationContext;
    }
    @Override
    public void start() {
        System.out.println("start tomcat");
        ...
        tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(applicationContext));
        context.addServletMappingDecoded("/*", "dispatcher");
        try {
            tomcat.start();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }
    }
}

Define AutoConfiguration インターフェイス。自動的にアセンブルする必要があるクラスを識別するために使用されます。 Spring の構成クラスとして表される別の WebServerAutoConfiguration クラスを定義します。最後に、このクラスをインポートし、Spring に解析させる必要があります。その後、Spring は @Bean アノテーション メソッドを解析して Bean をロードします。次の 2 つのメソッドは、Bean を解析する必要があるかどうかを決定する @RickConditionalOnClass アノテーションも定義していることに注意してください。条件が満たされる場合、Bean は解析されます。つまり、Tomcat または Server に格納されているクラスが適用される場合、Bean は

public interface AutoConfiguration {
}
@Configuration
public class WebServerAutoConfiguration implements AutoConfiguration {
    @Bean
    @RickConditionalOnClass("org.apache.catalina.startup.Tomcat")
    public TomcatServer tomcatServer() {
        return new TomcatServer();
    }
    @Bean
    @RickConditionalOnClass("org.eclipse.jetty.server.Server")
    public JettyServer jettyWebServer() {
        return new JettyServer();
    }
}

@RickConditionalOnClass アノテーションを見てください: Spring が @RickConditionalOnClass アノテーションが付けられたメソッドを解析するとき、Spring はそれが @Conditional によって変更されていることを認識し、match() メソッドを実行します。解析中に RickOnClassConditional を取得して、Bean をロードするための条件が満たされているかどうかを判断します。 match() は、渡されたクラス パス名のロードを試行します。関連する jar がアプリケーションに導入されていれば、正常にロードされて true が返されます。それ以外の場合は、false が返されます。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Conditional(RickOnClassConditional.class)
public @interface RickConditionalOnClass {
    String value();
}
public class RickOnClassConditional implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> annotation = metadata.getAnnotationAttributes(RickConditionalOnClass.class.getName());
        try {
            context.getClassLoader().loadClass((String) annotation.get("value"));
        } catch (ClassNotFoundException e) {
            return false;
        }
        return true;
    }
}

WebServerAutoConfiguration を紹介します。最も単純かつ大雑把な方法は、@Import(WebServerAutoConfiguration.class) を通じてこのクラスをインポートすることです。しかし、Spring-Boot ではこれを行うことは不可能であり、コードに何百もの自動構成を記述するのは明らかに良くありません。 Spring は SPI メカニズムを使用して、リソース ディレクトリに次のディレクトリとファイルを作成します。

DeferredImportSelector インターフェイスを実装するクラスを定義し、selectImports() を実装し、上記をロードします。 JDK の ServiceLoader を介してファイルのタイプを決定します。 @Import(WebServerImportSelector.class) アノテーションを介してこのクラスをインポートすると、Spring は構成クラスを解析するときに selectImports() を実行し、それによって WebServerAutoConfiguration を Spring コンテナにインポートし、Spring はこの構成クラスを解析します。

public class WebServerImportSelector implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        ServiceLoader<AutoConfiguration> load = ServiceLoader.load(AutoConfiguration.class);
        List<String> list = new ArrayList<>();
        for (AutoConfiguration loader : load) {
            list.add(loader.getClass().getName());
        }
        return list.toArray(new String[list.size()]);
    }
}

この時点で、springboot はユーザー プロジェクトの Maven 依存関係を変更することによってのみ Tomcat サービスと Jetty サービスを切り替えることができます。 # #

以上がSpringBoot の基礎となる原理は何ですか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。