Apakah prinsip asas SpringBoot?

Springboot tulisan tangan

Dalam pembangunan harian, anda hanya perlu memperkenalkan kebergantungan berikut untuk membangunkan Servlet untuk akses.

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

Jadi bagaimana ini dilakukan? Mari ketahui hari ini

Mula-mula buat projek maven rick-spring-boot baharu, dan cipta dua sub-projek: spring-boot dan pengguna Projek spring-boot mensimulasikan tulisan tangan springboot yang ringkas, dan pengguna Digunakan untuk menguji but spring tulisan tangan.

projek ujian projek pengguna

Projek pengguna mengandungi pom.xml, UserController dan 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";
    }
}

serta kelas permulaan RickApplication of the user project , dan RickSpringApplication.run() memerlukan kelas permulaan tulisan tangan dan anotasi @RickSpringBootApplication, yang perlu dilaksanakan dalam projek 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);
    }
}

Projek Springboot

Mula-mula mari kita lihat apa kaedah RickSpringApplication.run(RickApplication.class) perlu lakukan:

(1) Buat bekas spring dan masukkan kelas didaftarkan dalam bekas spring

(2) Mulakan perkhidmatan web, seperti tomcat, untuk memproses permintaan, dan mengedarkan permintaan kepada Servlet untuk diproses melalui 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 diubah suai oleh anotasi @RickSpringBootApplication Seperti yang dapat dilihat daripada kod berikut, RickApplication ialah kelas konfigurasi Selepas didaftarkan ke bekas spring, spring akan menghuraikan kelas ini.

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

Mulakan kaedah utama projek pengguna RickApplication,

Access UserController

Ini adalah mudah Projek but spring disepadukan.

Konfigurasi automatik

Untuk bertukar antara tomcat dan jeti

Apabila menggunakan springboot, jika kita tidak mahu menggunakan tomcat sebagai perkhidmatan pemprosesan permintaan, tetapi jeti atau web lain services, Biasanya anda hanya perlu mengecualikan kebergantungan tomcat yang berkaitan, dan kemudian memperkenalkan kebergantungan jeti Ini ialah mekanisme pemasangan automatik springboot. Seterusnya, mari lihat bagaimana ia dilaksanakan

Tentukan antara muka WebServer dan dua kelas pelaksanaan (tomcat dan jeti), dan tulis kod untuk memulakan perkhidmatan tomcat dan jeti

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

Tentukan antara muka AutoConfiguration , Digunakan untuk mengenal pasti kelas yang perlu dipasang secara automatik. Tentukan kelas WebServerAutoConfiguration yang lain, yang diwakili sebagai kelas konfigurasi spring Akhir sekali, kita perlu mengimport kelas ini dan biarkan spring menghuraikannya Kemudian spring akan menghuraikan kaedah anotasi @Bean untuk memuatkan Bean. Ambil perhatian bahawa dua kaedah berikut juga mentakrifkan anotasi @RickConditionalOnClass untuk menentukan sama ada kacang perlu dihuraikan Jika syarat dipenuhi, kacang akan dihuraikan Iaitu, jika Kelas yang disimpan dalam Tomcat atau Pelayan digunakan, kacang daripada kaedah yang sepadan akan dihuraikan,

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

Lihat anotasi @RickConditionalOnClass: Apabila spring menghuraikan kaedah yang dianotasi dengan @RickConditionalOnClass, spring mengetahui bahawa ia diubah suai oleh @Conditional, dan akan melaksanakan kaedah padanan() daripada RickOnClassConditional semasa penghuraian untuk menentukan sama ada syarat untuk memuatkan kacang dipenuhi. match() akan cuba memuatkan nama laluan kelas yang diluluskan Jika balang yang berkaitan dimasukkan ke dalam aplikasi, ia akan berjaya dimuatkan dan kembali benar.

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

Memperkenalkan WebServerAutoConfiguration, cara paling mudah dan kasar ialah mengimport kelas ini melalui @Import(WebServerAutoConfiguration.class). Tetapi adalah mustahil untuk melakukan ini dengan spring-boot Sudah pasti tidak baik untuk menulis ratusan konfigurasi automatik dalam kod. Spring menggunakan mekanisme SPI untuk mencipta direktori dan fail berikut dalam direktori sumber

Tentukan kelas untuk melaksanakan antara muka DeferredImportSelector dan melaksanakan selectImports(), dan memuatkan fail di atas melalui kelas ServiceLoader JDK. Apabila mengimport kelas ini melalui anotasi @Import(WebServerImportSelector.class), spring akan melaksanakan selectImports() apabila menghuraikan kelas konfigurasi, dengan itu mengimport WebServerAutoConfiguration ke dalam bekas spring dan spring akan menghuraikan kelas konfigurasi ini.

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

Pada ketika ini, springboot boleh menukar perkhidmatan tomcat dan jeti hanya dengan mengubah suai kebergantungan maven projek pengguna

<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>

Mulakan semula projek pengguna

Atas ialah kandungan terperinci Apakah prinsip asas SpringBoot?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!