Quelles sont les différences et les scénarios d'utilisation des différentes annotations Bean dans SpringBoot ?

Différences et scénarios d'utilisation des différentes annotations Bean

Qu'est-ce qu'un Bean ?

Le sous-texte de parler de Bean est de parler de Bean in Spring Nous connaissons tous la BeanFactory in Spring, et le concept de Bean vient de là. Au Spring, tant qu'une classe peut être instanciée et gérée par le conteneur Spring, cette classe est appelée Bean, ou SpringBean.

En plus, nous avons aussi entendu d'autres mots：

JavaBean, POJO, VO, DTO

Que signifient ces noms ? Quel est le scénario d’utilisation ?

JavaBean

Un JavaBean est une classe qui suit la spécification JavaBean de Sun. JavaBean peut être compris comme un composant réutilisable en Java, qui remplit les conditions suivantes :

• a un constructeur public par défaut

# 🎜🎜#
• Les propriétés de cette classe sont accessibles à l'aide de getters et de setters, et la dénomination suit la convention standard

• Cette classe peut être sérialisée

  # 🎜 🎜#

POJO(Plain Ordinary Object)

POJO est un nom historique. Pourquoi dis-tu cela ? Parce que POJO est utilisé pour indiquer que l'objet est différent des Entity Beans

EntityBeans est un concept dans EJB, et EJB a progressivement disparu de la scène de l'histoire après l'émergence de Spring. Par conséquent, lorsque POJO a été proposé par Martin Fowler, il faisait référence à des classes Java ordinaires qui n'implémentaient aucune interface EJB. Comme elles continuent d'être utilisées aujourd'hui, à proprement parler, toutes les classes Java sont des POJO, car plus personne n'utilise de vieilles antiquités comme ejb. Mais parfois afin de distinguer les Spring Beans, on peut appeler des classes qui ne sont pas gérées par Spring POJO.

VO (Value Object)

VO fait référence à un objet tel que java.lang.Integer qui contient des données, ou un objet de données . Ce concept est un concept proposé par Martin Fowler dans Enterprise Application Architecture.

DTO (Data Transfer Object)

DTO est aussi un concept proposé par EJB Le but est de transférer directement des objets lors de la transmission de données. , transmettre des données dans le réseau.

Résumé :

Donc pour nous, il n'y a pas de différence entre VO et DTO (mais Martin Fowler les a peut-être utilisés pour désigner différents segments concept), et la plupart du temps, ils suivent la spécification JavaBean, ce sont donc aussi des JavaBeans. Bien sûr, ce sont tous des POJO.

On voit qu'ils font essentiellement référence à un objet java Afin de distinguer les scénarios et les fonctions, ils portent des noms différents. Entité, domaine, etc. apparaissent parfois au cours du développement. Utilisé pour représenter le mappage d’entités ou de tables. Généralement, vous pouvez faire cela pour standardiser le développement :

Pour les objets gérés par Spring, cela s'appelle Bean

• #🎜 🎜# mapping La classe d'entité objet vers la table de données est appelée entité et est placée dans le répertoire d'entités

• Pour l'interface, elle est utilisée pour encapsuler des données, telles que accepter un paramètre d'entrée json. Pour plus de commodité, définissez Un objet encapsule des paramètres, qui peuvent être appelés dto (ou pojo) et placés dans le package pojo pour indiquer qu'il ne s'agit pas d'une classe de mappage d'une certaine table.

• Quelle est la différence entre les annotations @Bean @Component …

Lors du développement d'applications avec SpringBoot, nous utiliserons des annotations pour transmettre les objets au conteneur Spring pour la gestion. Ces annotations incluent :

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

Essentiellement, ces annotations sont des identifiants Spring, utilisés pour la détection automatique des Beans. Les classes marquées avec ces annotations seront gérées par le conteneur Spring.

Alors pourquoi y a-t-il ces catégories ? Pourquoi ne pas utiliser une annotation pour faire tout le travail ?

Tout d'abord, ces annotations sont utilisées à différents niveaux selon la sémantique

@ComponetComposants généraux# 🎜🎜#

• @Service est un composant de la couche Service@Componet一般的组件

• @Service是Service层组件

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

• @Controller是用在SpringMVC控制层

• @Repository

@Bean Ceci doit être utilisé avec @Configuration, qui sera discuté plus tard<p></p> <p></p> <code>@Controller est utilisé dans la couche de contrôle SpringMVC

#🎜 🎜#

@Repository est la couche d'accès aux données

Spring est conçu pour cela manière car ces annotations ne sont pas seulement destinées à faire une détection automatique. Dans le même temps, il existe différentes fonctions, telles que l'annotation @Repository, Spring ajoutera un traitement amélioré et la gestion des exceptions associées.

@Le bean du contrôleur gérera la logique liée aux requêtes réseau. Donc si vous annotez tous les beans avec la même annotation, ils seront bel et bien injectés dans le conteneur Spring, mais la fonction risque de ne pas fonctionner.

Et à mesure que la version Spring est mise à niveau, des traitements plus différenciés peuvent être ajoutés. Il faut donc annoter selon les spécifications.

En parlant de @Bean, nous savons qu'au début du printemps, les Beans étaient encore configurés via XML. Par exemple :

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

Maintenant, vous pouvez comprendre que la classe. annoté par @Configuration est un fichier de configuration XML. L'annotation @Bean du milieu est le nœud du bean dans XML

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

Les deux méthodes injectent la valeur de retour de l'annotation @Bean dans le conteneur Spring. Lorsque SpringBoot démarre, il analysera l'annotation @Configuration et l'injectera.

#🎜🎜#Comment résoudre les conflits d'objets d'injection SpringBoot ? #🎜🎜##🎜🎜#D'accord, maintenant nous remettons enfin les composants souhaités à la gestion des conteneurs Spring. Comment devrions-nous l’utiliser ? #🎜🎜##🎜🎜#Nous pouvons utiliser le contexte Spring pour obtenir les objets requis#🎜🎜#

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

#🎜🎜#Généralement, nous utilisons l'annotation @Autowire pour obtenir les beans dans le conteneur#🎜🎜#

@Autowire
private Employee employee;

#🎜🎜#Parfois Nous devons injecter plusieurs instances d'une classe dans le conteneur pour répondre aux exigences. #🎜🎜#

比如一个接口的实现类有两个，如果直接通过@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这个注解

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!