SpringBoot의 기본 원리는 무엇입니까?

손으로 쓴 springboot

일상 개발에서는 액세스용 서블릿을 개발하려면 다음 종속성만 도입하면 됩니다.

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

그럼 이건 어떻게 하는 걸까요? 오늘 알아봅시다

먼저 새로운 Maven 프로젝트인 rick-spring-boot를 생성하고, spring-boot와 user라는 두 개의 하위 프로젝트를 생성합니다. spring-boot 프로젝트는 간단한 springboot로 손글씨를 시뮬레이션하는 것으로, 사용자가 사용합니다. 스프링 부트를 테스트합니다.

사용자 프로젝트 - 테스트 프로젝트

사용자 프로젝트에는 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) 스프링 컨테이너를 만들고 수신 클래스를 스프링 컨테이너에 등록합니다.

(2) 시작 Tomcat과 같은 웹 서비스는 요청을 처리하고 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이 스프링 컨테이너에 등록된 후 이 클래스를 구문 분석한다는 것을 알 수 있습니다.

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

사용자 프로젝트 RickApplication의 기본 메소드를 시작하고

UserController에 액세스

이 시점에서 간단한 스프링 부트 프로젝트가 통합되었습니다.

자동 구성

Tomcat과 jetty 사이를 전환하려면

springboot를 사용할 때 요청 처리 서비스로 tomcat을 사용하지 않고 jetty나 기타 웹 서비스를 사용하려면 일반적으로 관련 tomcat 종속성만 제외하면 됩니다. , 그런 다음 jetty의 종속성을 소개합니다. 이것은 springboot의 자동 조립 메커니즘입니다. 다음으로 구현 방법을 살펴보겠습니다

WebServer 인터페이스와 두 개의 구현 클래스(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();
        }
    }
}

자동 구성 인터페이스를 정의하여 필요한 클래스를 식별합니다. 자동으로 조립됩니다. Spring의 구성 클래스로 표시되는 또 다른 WebServerAutoConfiguration 클래스를 정의합니다. 마지막으로 이 클래스를 가져와서 Spring이 이를 구문 분석하도록 해야 합니다. 그러면 Spring이 Bean을 로드하기 위해 @Bean 주석 메서드를 구문 분석합니다. 다음 두 가지 메소드는 Bean을 구문 분석해야 하는지 여부를 결정하기 위해 @RickConditionalOnClass 주석도 정의합니다. 조건이 충족되면 Bean이 구문 분석됩니다. 즉, Tomcat 또는 Server에 저장된 클래스가 적용됩니다.

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에 의해 수정되었음을 알고 구문 분석 중에 RickOnClassConditional의 match() 메서드를 실행하여 여부를 결정합니다. Bean을 로드하기 위한 조건이 충족되었습니다. match()는 전달된 클래스 경로 이름을 로드하려고 시도합니다. 관련 jar이 애플리케이션에 도입되면 성공적으로 로드되고 그렇지 않으면 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 서비스를 전환할 수 있습니다.

<dependency>
      <groupId>com.rick.spring.boot</groupId>
      <artifactId>spring-boot</artifactId>
      <version>1.0-SNAPSHOT</version>
      <exclusions>
        <exclusion>
          <groupId>org.apache.tomcat.embed</groupId>
          <artifactId>tomcat-embed-core</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>9.4.43.v20210629</version>
    </dependency>

사용자 프로젝트를 다시 시작하세요

위 내용은 SpringBoot의 기본 원리는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!