bean - ¿Puede Spring Framework anular la configuración basada en anotaciones con una configuración basada en XML?

spring configuration annotation example

Question

¿Puede Spring Framework anular la configuración basada en anotaciones con una configuración basada en XML? Necesito cambiar la dependencia de un bean que ya está definido mediante anotaciones y no soy el autor del bean.

Answer 1

Esto debería estar bien. Un contexto Spring Bean le permite redefinir los frijoles, con definiciones "posteriores" que reemplazan a las anteriores. Esto debería aplicarse a los beans definidos por XML, así como a los beans definidos por anotación, incluso si están mezclados.

Por ejemplo, si tiene

@Configuration
public class MyAnnotatedConfig {
@Bean
public Object beanA() {
...
}
}

<bean class="com.xyz.MyAnnotatedConfig"/>
<bean id="beanA" class="com.xyz.BeanA"/>

En este caso, la definición XML de beanA debe tener prioridad.

Answer 2

No sabía que la primavera puede mezclar configuraciones. Aquí está el ejemplo detallado y muy útil.

Bean1 es el bean real que estamos configurando.

package spring;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component
public class Bean1 {
private String naber;
@Autowired
@Qualifier("FireImpl1")
private Fire fire;
@PostConstruct
public void init() {
System.out.println("init");
getFire().fire();
}
@PreDestroy
public void destroy() {
System.out.println("destroy");
}
public void setNaber(String naber) {
this.naber = naber;
}
public String getNaber() {
return naber;
}
public void setFire(Fire fire) {
this.fire = fire;
}
public Fire getFire() {
return fire;
}
}

El fuego es interfaz de dependencia.

package spring;
public interface Fire {
public void fire();
}

y la aplicación ficticia 1

package spring;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component
@Qualifier("FireImpl1")
public class FireImpl1 implements Fire {
public void fire() {
System.out.println(getClass());
}
}

y dummy implementacion 2

package spring;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component
@Qualifier("FireImpl2")
public class FireImpl2 implements Fire {
public void fire() {
System.out.println(getClass());
}
}

config.xml

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<context:component-scan base-package="spring" />
<bean id="bean1" class="spring.Bean1">
<property name="naber" value="nice" />
<property name="fire" ref="fireImpl2" />
</bean>
</beans>

y clase principal

package spring;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Spring {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring/config.xml");
applicationContext.registerShutdownHook();
Bean1 bean = (Bean1) applicationContext.getBean("bean1");
System.out.println(bean.getNaber());
}
}

aquí está la salida

init
class spring.FireImpl2
nice
destroy

Aunque la anotación resuelve la dependencia de FireImpl1, la configuración xml se anuló con FireImpl2. muy agradable.