Frühling: Unterschied zwischen @Resource und @Autowired und empfohlene Verwendung

@Ressource

Die Verwendung ähnelt @Autowired. Es führt auch eine Abhängigkeitsinjektion durch. Es ruft automatisch Beans und Prozesse aus dem Container ab.

Wenn der Frühling beginnt, wird zuerst der Container gestartet.
Wenn der Spring-Container gestartet wird, sucht er standardmäßig nach ladbaren Beans innerhalb des Scanbereichs des Containers und findet dann heraus, welche Beans über @Resource-Annotationen für ihre Eigenschaften und Methoden verfügen. Nachdem Sie die @Resource-Annotation gefunden haben, gehen Sie zum dritten Schritt über.
Stellen Sie fest, ob das Namensattribut in den Klammern der @Resource-Annotation leer ist.
- Wenn es leer ist: Überprüfen Sie, ob die ID der Bean im Spring-Container mit dem Variablenattributnamen übereinstimmt, der mit @Resource annotiert werden soll
  - Wenn sie gleich sind, ist die Übereinstimmung erfolgreich;
  - Wenn sie nicht identisch sind, prüfen Sie, ob der Typ, der der Bean-ID im Spring-Container entspricht, mit dem Typ übereinstimmt, der dem Variablenattribut entspricht, das mit @Resource annotiert werden soll.
    - Wenn sie gleich sind, ist die Übereinstimmung erfolgreich.
    - Wenn sie nicht gleich sind, schlägt die Übereinstimmung fehl.
- Wenn es nicht leer ist, prüfen Sie, ob der Attributwert von name mit dem ID-Namen der Bean im Container übereinstimmt.
  - Bei Gleichheit ist die Übereinstimmung erfolgreich;
  - Wenn sie nicht gleich sind, schlägt die Übereinstimmung fehl.

Beispiel

/*纳入容器中后，bean的id名字为ps*/
@Component(value="ps")
public class Person {
    
    
}

Das Namensattribut der Anmerkung ist nicht leer

@Component
public class Man {
    
    
    /*
    从容器中取id名字为ps的bean，
    如果找不到该bean，spring启动过程中就会报错，表示把Man类型的bean注入到容器中不成功，
    	因为person的属性依赖注入的时候就出错了，
    	所以创建Man的bean的时候肯定不成功。
    */
    @Resource(name="ps")
    private Person person;

    /*
    依赖注入失败，
    	因为Person类型注入到容器中的bean的id指定为ps,
    	所以从容器中获取id为person的bean就会失败
    */
    //  @Resource(name="person")
    //  private Person ps;
}

Das Namensattribut der Anmerkung ist leer

Das mit Anmerkungen versehene Variablenattribut entspricht dem Namen der Bean-ID im Container

@Component
public class Man {
    
    

    /*
    @Resource注解的属性变量ps与容器中的bean的id名字ps相等，
    可以匹配
    */
    @Resource
    private Person ps;

}

Das mit Anmerkungen versehene Variablenattribut entspricht nicht dem Namen der Bean-ID im Container.

@Component
public class Man {
    
    

    /*
    @Resource注解的属性变量ps与容器中的bean的id名字ps不相等，然后通过bean的类型判断：
    	person变量属性的类型为Person类，
    	容器中的id为ps的bean的类型也为Person类型，
    	因此此种情况下也可以匹配
    */
    @Resource
    private Person person;

}

@Autowired

Wie folgt verwenden

@Autowire
private JdbcTemplate jdbcTemplate;

In der Idee wird eine Eingabeaufforderungsmeldung wie folgt angezeigt, was bedeutet:Die Methode der Attributfeldinjektion wird nicht empfohlen. Das erkannte Problem ist: Das Spring-Team empfiehlt: „Immer in der Bean. Verwenden Sie die konstruktorbasierte Abhängigkeitsinjektion und verwenden Sie immer Assertionen für obligatorische Abhängigkeiten.“

Field injection is not recommended Inspection info: Spring Team recommends: "Always use constructor based dependency injection in your beans. Always use assertions for mandatory dependencies".

Injektionsmethode

Die Dokumentation von Spring Framework (5.0.3) definiert nur zwei Hauptinjektionstypen. Ich werde sie im Folgenden weiter unterteilen:Setter-basierte Abhängigkeitsinjektion Unterteilt in < a i=2> und 基于Setter的依赖注入基于字段的依赖注入

Konstruktorbasierte Abhängigkeitsinjektion

public class AServiceImpl implents AService{
    
    
    private ADao aDao;
    
    @Autowire
    public AServiceImpl(ADao aDao){
    
    
        this.aDao = aDao;
    }
}

Setter-basierte Abhängigkeitsinjektion

public class AServiceImpl implents AService{
    
    
    private ADao aDao;
    
    @Autowire
    public setADao(ADao aDao){
    
    
        this.aDao = aDao;
    }
}

Feldbasierte Abhängigkeitsinjektion

Diese Injektionsmethode führt zu einer Warnung in der Idee. Der Grund ist oben erläutert.

public class AServiceImpl implents AService{
    
    
	@Autowire
    private ADao aDao;
}

Die Nachteile der feldbasierten Abhängigkeitsinjektion sind folgende:

对于有final修饰的变量不好使::
- Das IOC von Spring verwendet die festgelegte Form für die Eigenschaftsinjektion, die endgültigen Typvariablen müssen jedoch während des Aufrufs des Klassenkonstruktors initialisiert werden.
- Dies ist etwas, was die feldbasierte Abhängigkeitsinjektion nicht leisten kann. Nur konstruktorbasierte Abhängigkeitsinjektion kann verwendet werden

掩盖单一职责的设计思想: Es gibt eine einzige Verantwortungsidee im OOP-Design.

Wenn Sie Springs IOC mit konstruktorbasierter Abhängigkeitsinjektion verwenden und zu viele Parameter injizieren, sind die Parameter des Konstruktors sehr groß.
Durch die Verwendung der feldbasierten Abhängigkeitsinjektion werden Sie nicht darauf aufmerksam gemacht, Sie werden in @Autowire eintauchen

Der Beispielcode lautet wie folgt

public class VerifyServiceImpl implents VerifyService{
        
        
    
  private AccountService accountService;
  private UserService userService;
  private IDService idService;
  private RoleService roleService;
  private PermissionService permissionService;
  private EnterpriseService enterpriseService;
  private EmployeeService employService;
  private TaskService taskService;
  private RedisService redisService;
  private MQService mqService;

  public SystemLogDto(AccountService accountService, 
                      UserService userService, 
                      IDService idService, 
                      RoleService roleService, 
                      PermissionService permissionService, 
                      EnterpriseService enterpriseService, 
                      EmployeeService employService, 
                      TaskService taskService, 
                      RedisService redisService, 
                      MQService mqService) {
        
        
      this.accountService = accountService;
      this.userService = userService;
      this.idService = idService;
      this.roleService = roleService;
      this.permissionService = permissionService;
      this.enterpriseService = enterpriseService;
      this.employService = employService;
      this.taskService = taskService;
      this.redisService = redisService;
      this.mqService = mqService;
  }
}

与Spring的IOC机制紧密耦合
- Geben die gesamte Kontrolle an Springs IOC. Andere Klassen möchten eine Ihrer Injektionseigenschaften zurücksetzen, können damit aber nicht umgehen. (Natürlich kann es durch Reflexion erfolgen)
- Der Zweck von Spring ist die Entkopplung und Abhängigkeitsumkehr. Dadurch geht durch die erneute Kopplung mit dem Klasseninjektor (in diesem Fall Spring) die Fähigkeit zur automatischen Verdrahtung von Klassenfeldern verloren verloren. Entkopplung von Klassen implementiert, wodurch sie außerhalb des Spring-Containers ungültig werden.
隐藏依赖性
- Wenn Sie das IOC von Spring verwenden,被注入的类应当使用一些public类型(构造方法，和setter类型方法)的方法来向外界表达：我需要什么依赖
- Feldbasierte Abhängigkeitsinjektionsmethode,基本都是private形式的，private把属性都给封印到class当中
无法对注入的属性进行安检
- Mit der feldbasierten Abhängigkeitsinjektionsmethode können Sie diese Klasse beim Start des Programms nicht abrufen. Sie erhalten sie nur, wenn sie im realen Geschäft verwendet wird. Unter normalen Umständen ist diese injizierte Klasse ungleich Null.
- Was ist, wenn es null ist? Der Fehler tritt erst während der Geschäftsverarbeitung auf, was etwas spät ist. Wenn er beim Start aufgedeckt wird, kann der Fehler schnell behoben werden (natürlich können Sie Anmerkungen zur Überprüfung hinzufügen).

der Unterschied

Eins: Sowohl @Autowired als auch @Resource können zum Zusammenstellen von Beans verwendet werden. Beide können in Felder oder Setter-Methoden geschrieben werden.

Zwei: @Autowired默认按类型装配 (diese Anmerkung gehört zu 属于spring), 默认情况下必须要求依赖对象必须存在

Wenn Sie möchten允许null 值, können Sie das erforderliche Attribut auf „false“ setzen
```
@Autowired(required=false)
```
Wenn wir möchten使用名称装配 können wir结合@Qualifier es mit Anmerkungen versehen und verwenden
```
@Autowired
@Qualifier("baseDao")     
private BaseDao baseDao;  
```

Drei @Resource (diese Annotation 属于J2EE), 默认安照名称装配, der Name kann 通过name属性进行指定, sein

Wenn没有指定name属性, wenn die Anmerkung in das Feld geschrieben wird, 默认取字段名进行按照名称查找,
Wenn die Anmerkung geschrieben wird在setter方法上默认取属性名, wird die Montage durchgeführt.
Berühren Sie找不到与名称匹配的bean时才按照类型进行装配.
Aber es sollte beachtet werden, dass wennname属性一旦指定，就只会按照名称进行装配.

Zusammenfassen

用 @Resource注解在字段上，且这个注解是属于J2EE的，减少了与spring的耦合，这样代码看起就比较优雅

Wenn Sie @Autowired weiterhin verwenden möchten:

推荐使用基于构造函数和基于setter的依赖注入.
für必需的依赖项，建议使用基于构造函数的注入 um sie unveränderlich zu machen und zu verhindern, dass sie null sind.
für可选的依赖项，建议使用基于Setter的注入