Was sind die Unterschiede und Verwendungsszenarien verschiedener Bean-Annotationen in SpringBoot?

Unterschiede und Verwendungsszenarien verschiedener Bean-Annotationen

Was ist ein Bean?

Der Untertext von Bean ist, über Bean im Frühling zu sprechen. Wir alle kennen die BeanFactory im Frühling, und daraus ergibt sich das Konzept von Bean. Solange eine Klasse im Frühling vom Spring-Container instanziiert und verwaltet werden kann, wird diese Klasse Bean oder SpringBean genannt.

Darüber hinaus haben wir auch einige andere Wörter gehört:

JavaBean, POJO, VO, DTO

Was bedeuten diese Namen? Was ist das Nutzungsszenario?

JavaBean

Eine JavaBean ist eine Klasse, die der JavaBean-Spezifikation von Sun folgt. JavaBean kann als wiederverwendbare Komponente in Java verstanden werden, die die folgenden Bedingungen erfüllt:

• hat einen öffentlichen Standardkonstruktor

• Der Zugriff auf die Eigenschaften dieser Klasse erfolgt über Getter und Setter, und die Benennung folgt Standardspezifikationen

• Diese Klasse kann serialisiert werden

POJO (Plain Ordinary Object)

POJO ist ein historischer Name, warum sagen Sie das? Weil POJO verwendet wird, um anzuzeigen, dass sich das Objekt von Entity Beans unterscheidet.

EntityBeans ist ein Konzept in EJB, und EJB verschwand nach dem Aufkommen von Spring allmählich aus der historischen Phase. Als POJO von Martin Fowler vorgeschlagen wurde, bezog es sich daher auf gewöhnliche Java-Klassen, die keine EJB-Schnittstelle implementierten. So wie es auch heute noch verwendet wird, sind streng genommen alle Java-Klassen POJOs, da niemand mehr alte Antiquitäten wie ejb verwendet. Aber manchmal können wir zur Unterscheidung von Spring Beans Klassen aufrufen, die nicht von Spring POJO verwaltet werden.

VO (Wertobjekt)

VO bezieht sich auf ein Objekt wie java.lang.Integer, das einige Daten oder ein Datenobjekt enthält. Dieses Konzept wurde von Martin Fowler in Enterprise Application Architecture vorgeschlagen.

DTO (Data Transfer Object)

DTO ist ebenfalls ein von EJB vorgeschlagenes Konzept. Der Zweck besteht darin, Daten im Netzwerk durch direkte Übertragung von Objekten während der Datenübertragung zu übertragen.

Zusammenfassung:

Für uns gibt es also keinen Unterschied zwischen VO und DTO (aber Martin Fowler hat sie möglicherweise verwendet, um unterschiedliche Unterteilungskonzepte zu bedeuten), und meistens folgen sie der JavaBean-Spezifikation, also sind sie es beides auch JavaBeans. Natürlich sind das alles POJOs.

Es ist ersichtlich, dass sie sich im Wesentlichen auf ein Java-Objekt beziehen, um zwischen Szenarien und Funktionen zu unterscheiden. Entität, Domäne usw. erscheinen manchmal während der Entwicklung. Wird zur Darstellung der Zuordnung von Entitäten oder Tabellen verwendet. Im Allgemeinen können Sie dies tun, um die Entwicklung zu standardisieren:

• Für von Spring verwaltete Objekte heißt es Bean

• Die der Datentabelle zugeordnete Objekt-Entitätsklasse heißt Entity und wird im Entitätsverzeichnis abgelegt

• Für Schnittstellen kapseln Sie Daten, z. B. das Akzeptieren eines JSON-Eingabeparameters. Definieren Sie der Einfachheit halber ein Objekt, um den Parameter zu kapseln. Sie können es dto (oder pojo) nennen und es in das Pojo-Paket einfügen, um anzugeben, dass es sich nicht um eine Zuordnungsklasse handelt ein bestimmter Tisch.

Annotations @Bean @Component …Was sind die Unterschiede?

Bei der Entwicklung von Anwendungen mit SpringBoot verwenden wir Annotationen, um Objekte zur Verwaltung an den Spring-Container zu übergeben. Zu diesen Annotationen gehören:

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

Im Wesentlichen handelt es sich bei diesen Annotationen um Spring-Identifikatoren, die zur automatischen Erkennung von Beans verwendet werden. Mit diesen Anmerkungen gekennzeichnete Klassen werden vom Spring-Container verwaltet.

Warum gibt es dann diese Kategorien? Warum nicht eine Anmerkung verwenden, um die ganze Arbeit zu erledigen?

Zuallererst werden diese Annotationen auf verschiedenen Ebenen basierend auf der Semantik verwendet

• @ComponetAllgemeine Komponenten@Componet一般的组件

• @Service是Service层组件

• @Bean这个要和@Configuration一块使用，后边再说

• @Controller是用在SpringMVC控制层

• @Repository

@Service ist eine Service-Layer-Komponente

@Bean Dies sollte zusammen mit @Configuration verwendet werden, was später besprochen wird

@Controller wird in der SpringMVC-Steuerungsschicht verwendet

@Repository ist die Datenzugriffsschicht <h4></h4> <p></p>Spring ist auf diese Weise konzipiert, da diese Annotationen nicht nur der automatischen Erkennung dienen. Gleichzeitig gibt es verschiedene Funktionen, wie z. B. die @Repository-Annotation, und Spring fügt eine verbesserte Verarbeitung und die damit verbundene Ausnahmebehandlung hinzu. <p></p>@Controllers Bean verarbeitet die Logik für Netzwerkanfragen. Wenn Sie also für alle Beans dieselbe Annotation markieren, werden diese zwar in den Spring-Container eingefügt, die Funktion funktioniert jedoch möglicherweise nicht. <p></p>Und wenn die Spring-Version aktualisiert wird, kann eine differenziertere Verarbeitung hinzugefügt werden. Wir sollten also gemäß den Spezifikationen kommentieren. <p></p>Apropos @Bean: Wir wissen, dass Beans in den frühen Frühlingstagen noch über XML konfiguriert wurden. Zum Beispiel: 🎜<pre class="brush:xml;">&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt; &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot; xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xmlns:context=&quot;http://www.springframework.org/schema/context&quot; xsi:schemaLocation=&quot;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&quot;&gt; &lt;bean id=&quot;operations&quot; class=&quot;com.howtodoinjava.spring.beans.Operations&quot;&gt;&lt;/bean&gt; &lt;bean id=&quot;employee&quot; class=&quot;com.howtodoinjava.spring.beans.Employee&quot;&gt;&lt;/bean&gt; &lt;/beans&gt;</pre>🎜Jetzt können Sie verstehen, dass die mit @Configuration annotierte Klasse eine XML-Konfigurationsdatei ist Die @Bean-Annotation in der Mitte ist der Bean-Knoten in XML🎜<pre class="brush:java;">@Configuration public class BeanConfiguration { @Bean public Operations operation(){ return new Operations(); } @Bean public Employee employee(){ return new Employee(); } }</pre> 🎜Beide Methoden bestehen darin, den Rückgabewert der @Bean-Annotation in den Spring-Container einzufügen. Wenn SpringBoot startet, scannt es die @Configuration-Annotation und fügt sie ein. 🎜🎜Wie löse ich SpringBoot-injizierte Objektkonflikte? 🎜🎜Okay, jetzt übergeben wir endlich die gewünschten Komponenten an die Spring-Container-Verwaltung. Wie sollen wir es nutzen? 🎜🎜Wir können den Spring-Kontext verwenden, um die erforderlichen Objekte abzurufen🎜<pre class="brush:java;">public static void main(String[] args) { ApplicationContext application = SpringApplication.run(ConsumerApplication.class, args); application.getBean(Employee.class); }</pre>🎜Im Allgemeinen verwenden wir die @Autowire-Annotation, um die Beans im Container abzurufen🎜<pre class="brush:java;">@Autowire private Employee employee;</pre>🎜Manchmal müssen wir mehrere Instanzen einer Klasse in den Container einfügen, um die Anforderungen zu erfüllen. 🎜<p>比如一个接口的实现类有两个，如果直接通过@Component注入容器，则会报错。</p> <p><strong>如何区分？</strong></p><pre class="brush:java;">@Component(&quot;bean01&quot;) public class Bean01 implement AA{ } @Component(&quot;bean02&quot;) public class Bean02 implement AA{ }</pre><p>没错，通过在注解中标识一个名称，来区分该对象的不同实例。</p> <p>获取时：最终会初始化一个Bean01</p><pre class="brush:java;">@Autowire @Qualifier(&quot;bean01&quot;) private AA a;</pre><p>这样有个问题，就是每次使用都需要显示声明@Qualifier来指定。有的场景下，我们可能想默认使用一个，其他情况再显式指定。这就涉及到@Primary</p> <p>在注解时，标注了@Primary的Bean在没有指定的情况下，会默认加载。</p> <p>比如：</p><pre class="brush:java;">@Component @Primary public class Bean01 implement AA{ } @Component(&quot;bean02&quot;) public class Bean02 implement AA{ }</pre><p>使用时： 默认初始化的就是Bean01</p><pre class="brush:java;">@Autowire private AA a;</pre><h3>SpringBoot的各种注解</h3> <h4>@Configuration</h4> <p>表示当前类可以用作配置文件使用</p> <p>可以在这个类中使用@bean注解来创建对象（类似于单例模式的饿汉式）。</p> <p>方法中需要有返回值+使用new这个关键字</p> <p>spring会把这个返回值放入spring容器中；</p> <p>在后面的方法中如果要调用这个方法（@bean中有个属性name，命名name的值，在后面的@resource中使用使用按照名称注入）没有使用name这个属性的话，默认情况下@bean方法的方法名；</p> <ul class=" list-paddingleft-2"> <li><p><code>@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这个注解

Das obige ist der detaillierte Inhalt vonWas sind die Unterschiede und Verwendungsszenarien verschiedener Bean-Annotationen in SpringBoot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!