SpringIOC-Lektion 2, Verwendung von @Bean, detaillierte Erklärung von DI, häufige Interviewfragen Autowired VS-Ressource

1. Rezension

Aber warum haben wir, als wir zuvor MVC verwendet haben, nur Controller und nicht andere auf der Seite verwendet?

Ist es einfacher, etwas anderes zu verwenden? (Wir können hier sehen, dass das Wort 404 erscheint)
@Service
@ResponseBody
public class TestController {
    @RequestMapping("/test")
    public String test(){
        return "测试Controller和其他注解的区别";
    }
}
Controller ist jedoch einfach zu verwenden. Tatsächlich hat Spring mehr Autorität über Controller.

2. Verwendung von @Bean

Die fünf Hauptanmerkungen können nur zu Klassen und nur zu Ihrem eigenen Code hinzugefügt werden.

Wenn ich ein JAR-Paket eines Drittanbieters einführe und möchte, dass es von Spring verwaltet wird, gibt es keine Möglichkeit, die fünf Hauptanmerkungen hinzuzufügen.

Das erste Anwendungsszenario: Sie können @Bean verwenden, @Bean ist eine Methodenanmerkung

Hier können wir ein Problem erkennen, das heißt, die beiden Referenzen verweisen auf dasselbe Objekt (siehe die folgenden Abbildungen, die darauf hinweisen, dass die Adressen identisch sind).

Zweites Anwendungsszenario: Wenn es sich bei der Anforderung also um eine Klasse handelt, definieren Sie mehrere Objekte, z. B. Datenbankoperationen, und definieren Sie mithilfe von @Bean mehrere Datenquellen

@Bean entspricht einem Prozess der Abgabe von Hausaufgaben. Nach der Abgabe der Hausaufgaben müssen Sie dem Lehrer mitteilen, dass die Hausaufgaben erledigt sind.

Mit anderen Worten: @Bean muss mit den fünf Hauptannotationen verwendet werden. Wenn ein Typ in mehreren Beans vorhanden ist und mehrere Beans verwendet werden, können wir den Typ nicht zum Abrufen des Objekts verwenden.

Notizen, die wir in der vorherigen Lektion gelernt haben

Es ist getBean + Methodenname (Kleinschreibung, Sonderfall (beide Anfangsbuchstaben sind Großbuchstaben, dann wird es zu Kleinbuchstaben)

Was zu @Bean hinzugefügt werden muss, ist der Methodenname (der Methodenname folgt nicht dem Camel-Case-Format).

So übergeben Sie Parameter entsprechend

Deshalb schreiben wir in unseren Bewerbungen grundsätzlich nicht zu Tode

Wenn Sie Parameter an den Inhalt der Bean-Methode übergeben, definieren Sie eine Methode wie diese. Natürlich ist diese Methode jetzt tot, aber Sie können diese Methode verwenden, um in Zukunft „lebendig“ zu werden.
@Configuration
public class BeanConfig {
    @Bean
    public String name(){
        return "zhangsan";
    }
    @Bean
    public UserInfo UserInfo(String string){
        UserInfo userInfo=new UserInfo();

        userInfo.setName(string);
        return  userInfo;
    }
Frühlingskonvention zum Scannen von Dateien

SpringBoot ist unser Entwicklungsframework (eigentlich Entwicklungsframework genannt, es fühlt sich eher wie die Struktur an, die nach dem Öffnen einer Idee präsentiert wird).

SpringBoot-Funktionen: Vereinbarung ist wichtiger als Konfiguration. Nach der Vereinbarung werden alle Dateien im aktuellen Ordner gescannt, egal wo sie abgelegt sind. Wenn Sie jedoch darauf bestehen, es in einem kleinen Verzeichnis auszuführen (es gibt auch eine Methode, fügen Sie hinzu der Pfad) ( Eine der Ausführungsformen der Vereinbarung ist der Scan-Pfad. Der Standard-Scan-Pfad ist: das Verzeichnis, in dem sich die Startklasse befindet, und ihre untergeordneten Verzeichnisse)

Wenn Sie es in diesen Ordner legen, wird ein Fehler gemeldet.

Die Lösung ist
//Standardmäßig das Verzeichnis und die Unterverzeichnisse der aktuellen Klasse scannen
Fügen Sie diese Anmerkung voran (füllen Sie den Pfad selbst aus) @ComponentScan("com.example")
@ComponentScan("com.example")
@SpringBootApplication
public class IoCtryApplication {

    public static void main(String[] args) {
        //启动类是帮助我们启动spring,这个命令可以返回一个spring

Ausführliche Erklärung von DI

DI-Abhängigkeitsinjektion, Attributassembly „Abhängigkeitsassembly“,

Fügen Sie einfach diese Abhängigkeitsinjektionen hinzu (genau wie unser importiertes Paket kann es nicht ohne das importierte Paket verwendet werden).

1. Attributinjektion @Autowired

(Entspricht einem Reiseführer, der Sie auf die Suche nach diesem Ding bringt.) Es stimmt mit dem obigen überein und ist mit den Übergabeparametern von @Bean identisch.
@Controller
public class UserController {
//⚠️假如没有下面的这个Autowired注释，那么就会报空指针异常
@Autowired
private UserService userService;

public void prin(){
    userService.doService();
    System.out.println("春节快乐");
}
}
UserController userController=context.getBean(UserController.class);
        userController.prin();
2.Injektion der Konstruktormethode

Wie nachfolgend dargestellt
@Controller
public class UserController {
//@Autowired
private UserService userService;
    private UserInfo userInfo;
//⚠️注意此时加完构造函数之后，还要把无参数的也写一遍，因为无参数的构造函数，有很多东西在用，所以一旦经过修改，就会让使用无参数的报错。

public UserController(){
}
@Autowired
public  UserController(UserService userService){
    this.userService=userService;
}

    public  UserController(UserInfo userInfo,UserService userService){
        this.userService=userService;
        this.userInfo=userInfo;
    }
public void prin(){
    userService.doService();
    System.out.println("春节快乐");
}
3.Injektion mit der Setter-Methode

Vor- und Nachteile von drei Injektionen

1. Attributinjektion:

Vorteile: einfach und bequem

Nachteile: Es kann nur für IOC-Container verwendet werden. Wenn Nicht-IOC-Container nicht verwendet werden können, tritt NPE (Null Pointer Exception) nur bei Verwendung auf und Final kann nicht geändert werden.

2. Konstruktorinjektion:

Vorteil:

(1). Endgültige Attribute können eingefügt werden (in Form von Konstruktormethoden).

(2). Das injizierte Objekt wird nicht geändert (da der Konstruktor nicht erneut aufgerufen werden kann, es sei denn, Sie verwenden new). Das abhängige Objekt muss vor der Verwendung initialisiert werden, da die Abhängigkeit im Konstruktor der Klasse ausgeführt wird und der Konstruktor dies tut Methoden, die während der Klassenladephase ausgeführt werden

(3) Der universelle Typ ist gut: Die Konstruktionsmethode wird von JDK unterstützt

Mangel:

Der Code wird umständlicher sein

Setter-Injektion

Vorteile: Es ist praktisch, das Objekt nach der Instanziierung der Klasse neu zu konfigurieren oder einzufügen.

Nachteile: Final kann nicht geändert werden, und das injizierte Objekt kann geändert werden, da die Setter-Methode möglicherweise mehrmals aufgerufen wird und das Risiko einer Änderung besteht.

Wenn das Programm über mehrere Objekte desselben Typs verfügt, wird bei Verwendung von @AutoWired ein Fehler gemeldet

Die hier erwähnte Situation ist ein solcher Code
package com.example.IOCtry;

import com.example.IOCtry.config.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
@Autowired                //⚠️
private UserService userService;
@Autowired                //⚠️
private UserInfo userInfo;
//注意此时加完构造函数之后，还要把无参数的也写一遍，因为无参数的构造函数，有很多东西在用，所以一旦经过修改，就会让使用无参数的报错。

//public UserController(){
//}
//
//public  UserController(UserService userService){
//    this.userService=userService;
//}
//
//    public  UserController(UserInfo userInfo,UserService userService){
//        this.userService=userService;
//        this.userInfo=userInfo;
//    }
//   @Autowired
//    public  void setUserController(UserService userService){
//        this.userService=userService;
//    }
public void prin(){
    userService.doService();
    System.out.println(userInfo);
    System.out.println("春节快乐");
}
}

Methode 1 erfordert eine Änderung des Attributnamens: Stellen Sie sicher, dass der Attributname mit dem Methodennamen konsistent ist

package com.example.IOCtry;

import com.example.IOCtry.config.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
@Autowired
private UserService userService;
@Autowired
private UserInfo UserInfo1;       //⚠️这个名字改成和方法名字一摸一样
//注意此时加完构造函数之后，还要把无参数的也写一遍，因为无参数的构造函数，有很多东西在用，所以一旦经过修改，就会让使用无参数的报错。

//public UserController(){
//}
//
//public  UserController(UserService userService){
//    this.userService=userService;
//}
//
//    public  UserController(UserInfo userInfo,UserService userService){
//        this.userService=userService;
//        this.userInfo=userInfo;
//    }
//   @Autowired
//    public  void setUserController(UserService userService){
//        this.userService=userService;
//    }
public void prin(){
    userService.doService();
    System.out.println(UserInfo1);
    System.out.println("春节快乐");
}
}

Die zweite Methode, wenn Sie den Namen nicht ändern möchten: @Primary hinzufügen

//这个是在另一个类中搞的方法
package com.example.IOCtry.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class BeanConfig {
    @Bean
    public String name(){
        return "zhangsan";
    }
    @Bean
    public String name2(){
        return "wangwu";
    }

   // ⚠️@Primary这个只有加上，程序才会不发生错误，会执行这个Setter方法
    @Bean
    public UserInfo UserInfo1(String name2){
        UserInfo userInfo=new UserInfo();
        userInfo.setName(name2);
        return  userInfo;
    }
    @Bean
    public UserInfo userInfo2(){
        UserInfo userInfo=new UserInfo();
        userInfo.setId(2);
        userInfo.setAge(22);
        userInfo.setName("lclyr");
        return  userInfo;
    }

}

Änderung 3 (Priorität): Verwenden Sie @Qualifier

package com.example.IOCtry;

import com.example.IOCtry.config.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
@Autowired
private UserService userService;
@Qualifier("userInfo2")            //⚠️
@Autowired
private UserInfo userInfo;
//注意此时加完构造函数之后，还要把无参数的也写一遍，因为无参数的构造函数，有很多东西在用，所以一旦经过修改，就会让使用无参数的报错。

//public UserController(){
//}
//
//public  UserController(UserService userService){
//    this.userService=userService;
//}
//
//    public  UserController(UserInfo userInfo,UserService userService){
//        this.userService=userService;
//        this.userInfo=userInfo;
//    }
//   @Autowired
//    public  void setUserController(UserService userService){
//        this.userService=userService;
//    }
public void prin(){
    userService.doService();
    System.out.println(userInfo);
    System.out.println("春节快乐");
}
}

Änderung 4 (Priorität): Verwenden Sie @Resource(name="userInfo2")

package com.example.IOCtry;

import com.example.IOCtry.config.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller
public class UserController {
@Autowired
private UserService userService;
//@Qualifier("userInfo2")
    @Resource(name="userInfo2")
@Autowired
private UserInfo userInfo;
//注意此时加完构造函数之后，还要把无参数的也写一遍，因为无参数的构造函数，有很多东西在用，所以一旦经过修改，就会让使用无参数的报错。

//public UserController(){
//}
//
//public  UserController(UserService userService){
//    this.userService=userService;
//}
//
//    public  UserController(UserInfo userInfo,UserService userService){
//        this.userService=userService;
//        this.userInfo=userInfo;
//    }
//   @Autowired
//    public  void setUserController(UserService userService){
//        this.userService=userService;
//    }
public void prin(){
    userService.doService();
    System.out.println(userInfo);
    System.out.println("春节快乐");
}
}

3. Häufige Fragen im Vorstellungsgespräch Autowired VS-Ressource

@Autowired: ist ein von Spring entwickeltes Framework, @Resource ist ein von JDK bereitgestelltes Framework

@Autowired: Standardmäßig wird nach Typ eingefügt. Wenn mehrere Objekte desselben Typs vorhanden sind, werden sie nach Namen abgeglichen. Wenn die Namen nicht übereinstimmen, wird ein Fehler gemeldet. Im Vergleich zu Autowired unterstützt @Resource Weitere Parametereinstellungen, wie z. B. Namenseinstellungen, erhalten Bean basierend auf dem Namen

SpringIOC-Lektion 2, Verwendung von @Bean, detaillierte Erklärung von DI, häufige Interviewfragen Autowired VS-Ressource

1. Rezension

2. Verwendung von @Bean

Das erste Anwendungsszenario: Sie können @Bean verwenden, @Bean ist eine Methodenanmerkung

Zweites Anwendungsszenario: Wenn es sich bei der Anforderung also um eine Klasse handelt, definieren Sie mehrere Objekte, z. B. Datenbankoperationen, und definieren Sie mithilfe von @Bean mehrere Datenquellen

So übergeben Sie Parameter entsprechend

Frühlingskonvention zum Scannen von Dateien

Ausführliche Erklärung von DI

1. Attributinjektion @Autowired

2.Injektion der Konstruktormethode

3.Injektion mit der Setter-Methode

Vor- und Nachteile von drei Injektionen

3. Häufige Fragen im Vorstellungsgespräch Autowired VS-Ressource

おすすめ