Wie funktioniert die Selbstverdrahtung im Frühjahr?

Question

Ich bin ein wenig verwirrt, wie die Umkehrung der Steuerschuldnerschaft ( IoC ) arbeitet in Spring .

Angenommen, ich habe eine Dienstklasse namens UserServiceImpl die Folgendes implementiert UserService Schnittstelle.

Wie wäre dies @Autowired ?

Und in meinem Controllers wie würde ich instantiate eine instance dieses Dienstes?

Würde ich einfach das Folgende tun?

UserService userService = new UserServiceImpl();

Answer 1

Spring Dependency Inject hilft Ihnen, die Kopplung Ihrer Klassen zu beseitigen. Anstatt ein Objekt wie dieses zu erstellen:

UserService userService = new UserServiceImpl();

Sie werden dies nach der Einführung von DI verwenden:

@Autowired
private UserService userService;

Um dies zu erreichen, müssen Sie eine Bean Ihres Dienstes in Ihrem ServiceConfiguration Akte. Danach müssen Sie diese Datei importieren ServiceConfiguration Klasse zu Ihrer WebApplicationConfiguration Klasse, so dass Sie diese Bean wie folgt in Ihren Controller einbinden können:

public class AccController {

    @Autowired
    private UserService userService;
} 

Eine auf Java-Konfiguration basierende POC finden Sie hier Beispiel .

Answer 2

Es gibt 3 Möglichkeiten, wie Sie eine Instanz erstellen können @Autowired .

1. @Autowired auf Eigenschaften

Die Anmerkung kann direkt auf Eigenschaften angewendet werden, wodurch Getter und Setter überflüssig werden:

    @Component("userService")
    public class UserService {

        public String getName() {
            return "service name";
        }
    }

    @Component
    public class UserController {

        @Autowired
        UserService userService

    }

In dem obigen Beispiel sucht Spring nach und injiziert userService cuando UserController erstellt wird.

2. @Autowired über Einrichter

El @Autowired Annotation kann für Setter-Methoden verwendet werden. Im folgenden Beispiel wird die Setter-Methode bei Verwendung der Annotation auf die Setter-Methode mit der Instanz von userService cuando UserController erstellt wird:

public class UserController {

    private UserService userService;

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

3. @Autowired über Konstrukteure

El @Autowired Annotation kann auch für Konstruktoren verwendet werden. Im folgenden Beispiel wird bei Verwendung der Anmerkung auf einen Konstruktor eine Instanz von userService wird als Argument in den Konstruktor injiziert, wenn UserController erstellt wird:

public class UserController {

    private UserService userService;

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

Answer 3

In einfachen Worten: Autowiring, also die automatische Verkabelung von Verbindungen, nun stellt sich die Frage, wer das macht und welche Art von Verkabelung. Die Antwort ist: Der Container macht das und die sekundäre Art der Verdrahtung wird unterstützt, die Primitive müssen manuell gemacht werden.

Frage: Wie Container wissen, welche Art von Verkabelung?

Antwort: Wir definieren es als byType,byName,constructor.

Frage: Gibt es eine Möglichkeit, die Art der automatischen Verdrahtung nicht zu definieren?

Antwort: Ja, es ist da, indem man eine Anmerkung macht, @Autowired.

Frage: Aber woher weiß das System, dass ich diese Art von Sekundärdaten auswählen muss?

Antwort: Sie stellen diese Daten in Ihrer spring.xml-Datei oder durch die Verwendung von Sterotyp-Annotationen zu Ihrer Klasse bereit, so dass der Container die Objekte selbst für Sie erstellen kann.

Answer 4

Standardmethode:

@RestController
public class Main {
    UserService userService;

    public Main(){
        userService = new UserServiceImpl();
    }

    @GetMapping("/")
    public String index(){
        return userService.print("Example test");
    }
}

Schnittstelle für Benutzerdienste:

public interface UserService {
    String print(String text);
}

UserServiceImpl-Klasse:

public class UserServiceImpl implements UserService {
    @Override
    public String print(String text) {
        return text + " UserServiceImpl";
    }
}

Sortie : Example test UserServiceImpl

Das ist ein großartiges Beispiel für eng gekoppelte Klassen, ein schlechtes Designbeispiel und es wird Probleme beim Testen geben (PowerMockito ist auch schlecht).

Werfen wir nun einen Blick auf SpringBoot Dependency Injection, ein schönes Beispiel für lose Kopplung:

Die Schnittstelle bleibt unverändert,

Hauptklasse:

@RestController
public class Main {
    UserService userService;

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

    @GetMapping("/")
    public String index(){
        return userService.print("Example test");
    }
}

ServiceUserImpl-Klasse:

@Component
public class UserServiceImpl implements UserService {
    @Override
    public String print(String text) {
        return text + " UserServiceImpl";
    }
}

Sortie : Example test UserServiceImpl

und jetzt ist es einfach, Tests zu schreiben:

@RunWith(MockitoJUnitRunner.class)
public class MainTest {
    @Mock
    UserService userService;

    @Test
    public void indexTest() {
        when(userService.print("Example test")).thenReturn("Example test UserServiceImpl");

        String result = new Main(userService).index();

        assertEquals(result, "Example test UserServiceImpl");
    }
}

Ich zeigte @Autowired Annotation auf Konstruktor, aber es kann auch auf Setter oder Feld verwendet werden.

Answer 5

Das gesamte Konzept der Inversion der Kontrolle bedeutet, dass Sie keine Objekte mehr manuell instanziieren und alle erforderlichen Abhängigkeiten bereitstellen müssen. Wenn Sie eine Klasse mit einer geeigneten Annotation versehen (z.B. @Service ) Spring instanziert das Objekt automatisch für Sie. Wenn Sie mit Annotationen nicht vertraut sind, können Sie stattdessen auch eine XML-Datei verwenden. Es ist jedoch keine schlechte Idee, Klassen manuell zu instanziieren (mit der new Schlüsselwort) in Unit-Tests, wenn Sie nicht den gesamten Spring-Kontext laden wollen.