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

Erstens, und das ist das Wichtigste, werden alle Spring Beans verwaltet - sie "leben" in einem Container, der als "Anwendungskontext" bezeichnet wird.

Zweitens hat jede Anwendung einen Einstiegspunkt in diesen Kontext. Webanwendungen haben ein Servlet, JSF einen El-Resolver verwendet, usw. Außerdem gibt es einen Ort, an dem der Anwendungskontext gebootstrappt wird und alle Beans - autowired. In Webanwendungen kann dies ein Startup-Listener sein.

Autowiring geschieht, indem eine Instanz einer Bean in das gewünschte Feld in einer Instanz einer anderen Bean gesetzt wird. Beide Klassen sollten Beans sein, d.h. sie sollten so definiert sein, dass sie im Anwendungskontext leben.

Was bedeutet "lebendig" im Zusammenhang mit der Anwendung? Dies bedeutet, dass die Kontext instanziiert die Objekte, nicht Sie. D.h. - Sie machen niemals new UserServiceImpl() - findet der Container jeden Injektionspunkt und setzt dort eine Instanz.

In Ihren Controllern haben Sie nur das Folgende:

@Controller // Defines that this class is a spring bean
@RequestMapping("/users")
public class SomeController {

    // Tells the application context to inject an instance of UserService here
    @Autowired
    private UserService userService;

    @RequestMapping("/login")
    public void login(@RequestParam("username") String username,
           @RequestParam("password") String password) {

        // The UserServiceImpl is already injected and you can use it
        userService.login(username, password);

    }
}

Ein paar Anmerkungen:

• In Ihrem applicationContext.xml sollten Sie die Option <context:component-scan> so dass die Klassen nach dem @Controller , @Service usw. Anmerkungen.
• Der Einstiegspunkt für eine Spring-MVC-Anwendung ist das DispatcherServlet, das jedoch vor Ihnen verborgen ist, so dass die direkte Interaktion und das Bootstrapping des Anwendungskontexts hinter der Szene stattfinden.
• UserServiceImpl sollte ebenfalls als Bohne definiert werden - entweder mit <bean id=".." class=".."> oder über die @Service Bemerkung. Da es sich um den einzigen Implementierer von UserService wird es injiziert.
• Neben der @Autowired Annotation kann Spring XML-konfigurierbares Autowiring verwenden. In diesem Fall wird allen Feldern, deren Name oder Typ mit einer bestehenden Bean übereinstimmt, automatisch eine Bean injiziert. Das war eigentlich die ursprüngliche Idee von Autowiring - Felder mit Abhängigkeiten ohne jegliche Konfiguration zu injizieren. Andere Annotationen wie @Inject , @Resource kann ebenfalls verwendet werden.

Answer 2

Hängt davon ab, ob Sie die Annotations-Route oder die Bean-XML-Definitions-Route wählen.

Angenommen, Sie haben die Beans in Ihrer applicationContext.xml :

<beans ...>

    <bean id="userService" class="com.foo.UserServiceImpl"/>

    <bean id="fooController" class="com.foo.FooController"/>

</beans>

Die automatische Verdrahtung erfolgt beim Starten der Anwendung. Also, in fooController die aus Gründen der Argumentation die UserServiceImpl Klasse, würden Sie sie wie folgt kommentieren:

public class FooController {

    // You could also annotate the setUserService method instead of this
    @Autowired
    private UserService userService;

    // rest of class goes here
}

Wenn er sieht @Autowired wird Spring nach einer Klasse suchen, die mit der Eigenschaft in der applicationContext und injizieren ihn automatisch. Wenn Sie mehr als eine UserService Bohne, dann müssen Sie festlegen, welche davon verwendet werden soll.

Wenn Sie das Folgende tun:

UserService service = new UserServiceImpl();

Es wird nicht die @Autowired es sei denn, Sie stellen sie selbst ein.

Answer 3

@Autowired ist eine in Spring 2.5 eingeführte Annotation, die nur für Injektionen verwendet wird.

Zum Beispiel:

class A {

    private int id;

    // With setter and getter method
}

class B {

    private String name;

    @Autowired // Here we are injecting instance of Class A into class B so that you can use 'a' for accessing A's instance variables and methods.
    A a;

    // With setter and getter method

    public void showDetail() {
        System.out.println("Value of id form A class" + a.getId(););
    }
}

Answer 4

Wie funktioniert @Autowired intern arbeiten?

Ejemplo:

class EnglishGreeting {
   private Greeting greeting;
   //setter and getter
}

class Greeting {
   private String message;
   //setter and getter
}

.xml-Datei wird es ähnlich aussehen, wenn nicht @Autowired :

<bean id="englishGreeting" class="com.bean.EnglishGreeting">
   <property name="greeting" ref="greeting"/>
</bean>

<bean id="greeting" class="com.bean.Greeting">
   <property name="message" value="Hello World"/>
</bean>

Wenn Sie Folgendes verwenden @Autowired dann:

class EnglishGreeting {
   @Autowired //so automatically based on the name it will identify the bean and inject.
   private Greeting greeting;
   //setter and getter
}

.xml-Datei wird es ähnlich aussehen, wenn nicht @Autowired :

<bean id="englishGreeting" class="com.bean.EnglishGreeting"></bean>

<bean id="greeting" class="com.bean.Greeting">
   <property name="message" value="Hello World"/>
</bean>

Wenn Sie noch Zweifel haben, gehen Sie durch die Live-Demo unten

Wie arbeitet @Autowired intern?

Answer 5

Sie müssen lediglich Ihre Dienstklasse mit Anmerkungen versehen UserServiceImpl mit Vermerk:

@Service("userService")

Der Spring-Container kümmert sich um den Lebenszyklus dieser Klasse, wenn sie sich als Dienst registriert.

Dann können Sie es in Ihrem Controller automatisch verdrahten (instanziieren) und seine Funktionalität nutzen:

@Autowired
UserService userService;