Apakah perbezaan dan senario penggunaan anotasi Bean berbeza dalam SpringBoot?

Perbezaan dan senario penggunaan anotasi Bean yang berbeza

Apakah itu Bean?

Subteks bercakap tentang Bean ialah bercakap tentang Bean pada Musim Bunga Kita semua tahu BeanFactory pada Musim Bunga, dan konsep Bean berasal dari ini. Pada Musim Bunga, selagi kelas boleh dijadikan instantiated dan diuruskan oleh bekas Spring, kelas ini dipanggil Bean, atau SpringBean.

Selain itu, kami juga mendengar beberapa perkataan lain:

JavaBean, POJO, VO, DTO

Apakah maksud nama ini? Apakah senario penggunaan?

JavaBean

JavaBean ialah kelas yang mengikut spesifikasi JavaBean Sun. JavaBean boleh difahami sebagai komponen boleh guna semula dalam Java, yang memenuhi syarat berikut:

• mempunyai kaedah pembinaan lalai awam

• ini Atribut daripada kelas itu diakses menggunakan getter dan setter, dan penamaan mengikut konvensyen standard

• Kelas ini boleh bersiri

POJO ( Objek Biasa Biasa )

POJO ialah nama sejarah Kenapa dikatakan begini? Kerana POJO digunakan untuk menunjukkan bahawa objek itu berbeza daripada Entity Beans

EntityBeans ialah konsep dalam EJB, dan EJB beransur-ansur pudar daripada peringkat sejarah selepas kemunculan Spring. Oleh itu, apabila POJO dicadangkan oleh Martin Fowler, ia merujuk kepada kelas Java biasa yang tidak melaksanakan sebarang antara muka EJB. Memandangkan ia terus digunakan hari ini, secara tegasnya, semua kelas Java adalah POJO, kerana tiada siapa yang menggunakan barangan antik lama seperti ejb lagi. Tetapi kadang-kadang untuk membezakan Spring Beans, kita boleh memanggil kelas yang tidak diuruskan oleh Spring POJO.

VO (Objek Nilai)

VO merujuk kepada objek seperti java.lang.Integer yang memegang beberapa data atau objek data. Konsep ini adalah konsep yang dicadangkan oleh Martin Fowler dalam Seni Bina Aplikasi Perusahaan.

DTO (Data Transfer Object)

DTO juga merupakan konsep yang dicadangkan oleh EJB Tujuannya adalah untuk menghantar data dalam rangkaian dengan menghantar terus objek semasa penghantaran data. .

Ringkasan:

Jadi bagi kami, tiada perbezaan antara VO dan DTO (tetapi Martin Fowler mungkin telah menggunakannya untuk mewakili konsep segmentasi yang berbeza), manakala kebanyakan At pada masa yang sama, mereka mengikuti spesifikasi JavaBean, jadi mereka juga JavaBeans. Sudah tentu, mereka semua adalah POJO.

Ia boleh dilihat bahawa mereka pada dasarnya merujuk kepada objek java Untuk membezakan senario dan fungsi, mereka mempunyai nama yang berbeza. Entiti, Domain, dsb. kadangkala muncul semasa pembangunan. Digunakan untuk mewakili pemetaan entiti atau jadual. Secara umumnya, anda boleh melakukan ini untuk menyeragamkan pembangunan:

• Untuk objek diurus Spring, dipanggil Bean

• dipetakan ke kelas entiti objek bagi jadual data, Entiti yang dipanggil, diletakkan dalam direktori entiti

• Untuk antara muka yang digunakan untuk merangkum data, seperti menerima parameter input json, untuk kemudahan, tentukan parameter pengkapsulan objek, yang boleh dipanggil dto (atau pojo) Letakkannya dalam pakej pojo untuk menunjukkan bahawa ia bukan kelas pemetaan untuk jadual tertentu.

Anotasi @Bean @Component …

Apabila membangunkan aplikasi dengan SpringBoot, kami akan menggunakan anotasi untuk menyerahkan objek kepada bekas Spring untuk pengurusan. Anotasi ini termasuk:

@Component, @Service, @Bean, @Controller, @Repository

Pada asasnya, anotasi ini ialah pengecam Spring dan digunakan untuk pengesanan automatik kacang. Kelas yang ditandai dengan anotasi ini akan diuruskan oleh bekas Spring.

Lalu mengapa terdapat kategori ini Mengapa tidak menggunakan anotasi untuk melakukan semua kerja?

Pertama sekali, anotasi ini digunakan pada tahap yang berbeza mengikut semantik

• @ComponetKomponen umum

• @Service ialah komponen lapisan Perkhidmatan

• @Bean Ini harus digunakan bersama-sama dengan @Configuration saya akan membincangkannya kemudian

• @Controller digunakan dalam SpringMVC Lapisan kawalan

• @Repository ialah lapisan akses data

Spring direka bentuk seperti ini kerana anotasi ini bukan sahaja untuk pengesanan automatik. Pada masa yang sama, terdapat fungsi yang berbeza, seperti anotasi @Repository, Spring akan menambah pemprosesan yang dipertingkatkan dan pengendalian pengecualian yang berkaitan.

@Controller’s bean akan mengendalikan logik berkaitan permintaan rangkaian. Oleh itu, jika anda menandakan anotasi yang sama pada semua kacang, ia sememangnya akan disuntik ke dalam bekas Spring, tetapi fungsi itu mungkin tidak berfungsi.

Dan apabila versi Spring dinaik taraf, pemprosesan yang lebih berbeza boleh ditambah. Oleh itu, kita harus membuat anotasi mengikut spesifikasi.

Bercakap tentang @Bean, kami tahu bahawa pada masa awal Spring, Beans masih dikonfigurasikan melalui xml Contohnya:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">
     
    <bean id="operations"    class="com.howtodoinjava.spring.beans.Operations"></bean>
    <bean id="employee"  class="com.howtodoinjava.spring.beans.Employee"></bean>
     
</beans>

Kini, anda boleh memahami bahawa kelas diberi penjelasan dengan @Configuration. ialah fail konfigurasi xml, dan anotasi @Bean di tengah Ia ialah nod kacang

@Configuration
public class BeanConfiguration {
     @Bean
     public Operations operation(){
         return new Operations();
     }
     @Bean
     public Employee employee(){
         return new Employee();
     }
    
}

dalam xml Kedua-dua kaedah menyuntik nilai pulangan anotasi @Bean ke dalam bekas Spring. Apabila SpringBoot bermula, ia akan mengimbas anotasi @Configuration dan menyuntiknya.

Bagaimana untuk menyelesaikan konflik objek suntikan SpringBoot?

Baiklah, kini kami akhirnya menyerahkan komponen yang dikehendaki kepada pengurusan bekas Spring. Bagaimana kita harus menggunakannya?

Kami boleh menggunakan konteks Spring untuk mendapatkan objek yang diperlukan

public static void main(String[] args) {
        ApplicationContext application = SpringApplication.run(ConsumerApplication.class, args);
        application.getBean(Employee.class);
}

Secara amnya kami menggunakan anotasi @Autowire untuk mendapatkan kacang dalam bekas

@Autowire
private Employee employee;

Kadang-kadang kita perlu menyuntik Berbilang contoh kelas yang sesuai dengan keperluan.

比如一个接口的实现类有两个，如果直接通过@Component注入容器，则会报错。

如何区分？

@Component("bean01")
public class Bean01 implement AA{
    
}

@Component("bean02")
public class Bean02 implement AA{
    
}

没错，通过在注解中标识一个名称，来区分该对象的不同实例。

获取时：最终会初始化一个Bean01

@Autowire
@Qualifier("bean01")
private AA a;

这样有个问题，就是每次使用都需要显示声明@Qualifier来指定。有的场景下，我们可能想默认使用一个，其他情况再显式指定。这就涉及到@Primary

在注解时，标注了@Primary的Bean在没有指定的情况下，会默认加载。

比如：

@Component
@Primary
public class Bean01 implement AA{
    
}

@Component("bean02")
public class Bean02 implement AA{
    
}

使用时： 默认初始化的就是Bean01

@Autowire
private AA a;

SpringBoot的各种注解

@Configuration

表示当前类可以用作配置文件使用

可以在这个类中使用@bean注解来创建对象（类似于单例模式的饿汉式）。

方法中需要有返回值+使用new这个关键字

spring会把这个返回值放入spring容器中；

在后面的方法中如果要调用这个方法（@bean中有个属性name，命名name的值，在后面的@resource中使用使用按照名称注入）没有使用name这个属性的话，默认情况下@bean方法的方法名；

• @importResource：用来导入xml文件，xml文件里面也是声明java对象，同样也是导入到spring容器中

• @propertySource：用来导入property文件

可以和@value一起使用，@value来用读取property文件的内容；

• @componentScan：用来指定扫描注解的位置，扫描把扫描到的注解生成对象放入spring容器中，

属性：basePackage：指定扫描到包的位置

默认情况下是扫描当前包和子包的位置

• @SpringBootApplication

由三个主要注解组合而成：@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan

• @SpringBootCOnfiguration：表示这个类可以作为配置类使用；

• @EnableAutoConfiguration：启动自动注入，把java文件配置好，直接注入到Spring容器中；

• @ComponentScan：表示文件下的注解，用来创建对象

• @ConfigurationProperties：使用在java类上，表示使用K-V自动注入到对应的java属性上，

参数prefix：把properties文件中对应的前缀.后面的属性对应到properties文件的属性中（使用在类上，所以在属性上可以自动赋值）

和@value是两种用法

@controller、@service、@Repository、@component

这些注解使用在java类上，componentScan会扫描这些完成对象的创建

• @controller使用在控制层，完成接收请求参数，调用service层完成用户的请求，返回视图层给用户；

• @Service：业务层的逻辑，调用dao层完成用户对数据库的操作，将处理结果返回给controller；

• @Repository：使用对数据库进行持久化操作（保证用户的数据可以写入到数据库中），将处理结果返回给service层

##在SpringBoot中使用@mapper代替这个注解。用来告诉mybatis创建这个对象的动态代理对象

##@mapperScan（basePackage：指定的mapper文件的路径），使用在主启动类上，省的一个一个dao层都要使用到@mapper

• @component：用来创建对象，但是对象没有前面三个有特殊的功能

• @transaction：表示开启事务（一般使用在service层）有五个参数

1、传播行为 2、隔离级别 3、超时行为 4、回滚规则 5、是否只读

@RestController   = @responseBody+@controller

使用在类上：表示这个类是控制层，而且类中的所有方法加上@responseBody这个注解

Atas ialah kandungan terperinci Apakah perbezaan dan senario penggunaan anotasi Bean berbeza dalam SpringBoot?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!