Was ist das Grundprinzip von SpringBoot?

Handschriftlicher Springboot

In der täglichen Entwicklung müssen Sie nur die folgenden Abhängigkeiten einführen, um Servlet für den Zugriff zu entwickeln.

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

Wie geht das? Lassen Sie es uns heute herausfinden

Erstellen Sie zunächst ein neues Maven-Projekt Rick-Spring-Boot und erstellen Sie zwei Unterprojekte, Spring-Boot und User. Das Spring-Boot-Projekt dient dazu, die Handschrift eines einfachen Springboots zu simulieren . Der Benutzer wird zum Testen des handgeschriebenen Springboots verwendet.

Benutzerprojekt-Testprojekt

Das Benutzerprojekt enthält pom.xml, UserController und UserService

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

rrree# 🎜 🎜# und die Startklasse RickApplication des Benutzerprojekts, und RickSpringApplication.run() ist eine Startklasse, die handgeschrieben werden muss, und die Annotation @RickSpringBootApplication, die im Spring-Boot-Projekt implementiert werden muss.

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

Springboot-Projekt

Schauen wir uns zunächst an, was die Methode RickSpringApplication.run(RickApplication.class) tun muss:

(1) Erstellen einen Spring-Container und registrieren Sie die eingehende Klasse im Spring-Container

(2) Starten Sie einen Webdienst wie Tomcat, um die Anfrage zu verarbeiten, und verteilen Sie die Anfrage an das Servlet zur Verarbeitung über DispatchServlet.

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

RickApplication wird durch die Annotation @RickSpringBootApplication geändert. Aus dem folgenden Code können wir ersehen, dass RickApplication eine Konfigurationsklasse ist. Nach der Registrierung im Spring-Container analysiert Spring diese Klasse.

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

Starten Sie die Hauptmethode des Benutzerprojekts RickApplication,

Access UserController

#🎜 🎜 #

Jetzt wurde ein einfaches Spring-Boot-Projekt integriert.

Automatische Konfiguration

Wechsel zwischen Tomcat und Jetty realisieren

Bei Verwendung von Springboot, wenn wir Tomcat nicht als Anforderungsverarbeitungsdienst verwenden möchten , aber jetty Oder andere Webdienste, normalerweise müssen Sie nur die relevanten Tomcat-Abhängigkeiten ausschließen und dann die Jetty-Abhängigkeiten einführen. Dies ist der automatische Assemblierungsmechanismus von Springboot. Schauen wir uns als nächstes an, wie es implementiert wird

Definieren Sie eine WebServer-Schnittstelle und zwei Implementierungsklassen (Tomcat und Jetty) und schreiben Sie den Code zum Starten der Tomcat- und Jetty-Dienste

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

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

Definieren Sie die AutoConfiguration-Schnittstelle, um Klassen zu identifizieren, die automatisch zusammengestellt werden müssen. Definieren Sie eine weitere WebServerAutoConfiguration-Klasse, die als Konfigurationsklasse von Spring dargestellt wird. Anschließend müssen wir diese Klasse importieren und von Spring analysieren lassen. Anschließend analysiert Spring die @Bean-Annotationsmethode, um die Bean zu laden. Beachten Sie, dass die folgenden beiden Methoden auch die Annotation @RickConditionalOnClass definieren, um zu bestimmen, ob die Bean analysiert werden muss. Wenn die Bedingungen erfüllt sind, wird die Bean analysiert, wenn die in Tomcat oder Server gespeicherte Klasse angewendet wird der entsprechenden Methode wird analysiert,

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

# 🎜🎜# Schauen wir uns die Annotation @RickConditionalOnClass an: Wenn Spring eine mit @RickConditionalOnClass annotierte Methode analysiert, weiß Spring, dass sie durch @Conditional geändert wurde, und führt die Übereinstimmung aus ()-Methode von RickOnClassConditional beim Parsen, um festzustellen, ob die Bedingungen zum Laden der Bean erfüllt sind. match() versucht, den übergebenen Klassenpfadnamen zu laden. Wenn das entsprechende JAR in die Anwendung eingeführt wird, wird es erfolgreich geladen und gibt „true“ zurück.

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

Wir stellen WebServerAutoConfiguration vor. Der einfachste und gröbste Weg besteht darin, diese Klasse über @Import(WebServerAutoConfiguration.class) zu importieren. Für Spring-Boot ist dies jedoch nicht möglich. Es ist definitiv nicht gut, Hunderte von automatischen Konfigurationen in den Code zu schreiben. Spring verwendet den SPI-Mechanismus, um die folgenden Verzeichnisse und Dateien im Ressourcenverzeichnis zu erstellen Der JDK ServiceLoader lädt die Klassen in den oben genannten Dateien. Beim Importieren dieser Klasse über die Annotation @Import(WebServerImportSelector.class) führt Spring beim Parsen der Konfigurationsklasse selectImports() aus, wodurch WebServerAutoConfiguration in den Spring-Container importiert wird, und Spring analysiert die Konfigurationsklasse.

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

An diesem Punkt kann Springboot Tomcat- und Jetty-Dienste wechseln, indem es einfach die Maven-Abhängigkeit des Benutzerprojekts ändert

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

Benutzerprojekt neu starten

#🎜🎜 #

Das obige ist der detaillierte Inhalt vonWas ist das Grundprinzip von SpringBoot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!