Prima di tutto, parliamo di DI.
Nota del Spring Doc,
gestione delle dipendenze e l'iniezione di dipendenza sono cose diverse.
- La gestione delle dipendenze è "assemblare tutte le librerie necessarie (file JAR) e farli sul vostro percorso di classe in fase di esecuzione, e, eventualmente, al momento della compilazione".
- L'iniezione di dipendenza è, supponiamo che tu voglia un oggetto
Service nella classe, invece di crearlo usando service = new Service();, lasci che il framework di primavera gestisca il ciclo di vita di quel bean.
esempio di gestione Dipendenza:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.2.5.RELEASE</version>
</dependency>
</dependencies>
Per avere tutti questi file jar nel progetto.
spring-context-4.2.5.RELEASE.jar
spring-aop-4.2.5.RELEASE.jar
spring-beans-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
Esempio di Dependency Injection:
Nel vostro quick-start esempio, si inietta MessageService in MessagePrinter utilizzando iniezione costruttore. Non hai creato uno MessageService ovunque. Il contenitore Spring lo crea per te.
@Component
public class MessagePrinter {
final private MessageService service;
@Autowired
public MessagePrinter(MessageService service) {
this.service = service;
}
public void printMessage() {
System.out.println(this.service.getMessage());
}
}
@Configuration
@ComponentScan
public class Application {
@Bean
MessageService mockMessageService() {
return new MessageService() {
public String getMessage() {
return "Hello World!";
}
};
}
...
}
Ora parliamo di transitive dependency and run-time dependency.
transitiva dipendenza
Significa scoprire le librerie che le proprie dipendenze richiedono e tra di loro automaticamente.
Ad esempio, se sono state specificate le dipendenze A e B in pom.xml. E A dipende da C, D. B dipende da E. Non è necessario includere C, D, E nella configurazione. A causa della dipendenza transitiva, C, D, E saranno inclusi automaticamente.
dipendenza runtime
Si tratta di un tipo di oscilloscopi dipendenza per limitare la dipendenza transitiva.
"di tale scopo indica che la dipendenza non è richiesto per compilazione, ma è per l'esecuzione. È nel runtime e prova percorsi di classe, ma non il percorso di classe di compilazione."
Ora la domanda è: esiste un caso che per DI "non è necessario compilare contro Primavera API", invece è possibile impostare il campo di applicazione runtime? Domanda simile here.
Sì, un esempio che posso pensare è l'applicazione web. Supponiamo che io stia usando Strtuts con il plugin Spring.(sotto l'esempio viene da "Struts 2 in Action" di Manning)
Voglio dire a Spring di creare un'istanza della classe Login da utilizzare come oggetto azione per la richiesta.
aggiungere un listener primavera contesto web per web.xml
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
definire un fagiolo Login chiamato come springManagedLoginAction in applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<bean id="portfolioService" class="manning.chapterNine.utils.PortfolioServiceJPAImpl"/>
<bean id="springManagedLoginAction" class="manning.chapterNine.Login" scope="prototype">
<property name="portfolioService" ref="portfolioService"/>
</bean>
</beans>
uso questo fagiolo nella classe azione struts-config-login.xml
<action name="Login" class="springManagedLoginAction">
<result type="redirectAction">
<param name="actionName">AdminPortfolio</param>
<param name="namespace">/chapterEight/secure</param>
</result>
<result name="input">/chapterEight/Login.jsp</result>
</action>
'; tldr' Spazzatura legacy. La configurazione XML crea dipendenza implicita dalla primavera. 'ApplicationContext' può essere istanziato dall'ambiente di esecuzione a molla. – user2418306