Este blog es principalmente para la corrección de errores de ensamblaje springbean de spring-ioc core de la columna de primavera
https://blog.csdn.net/qq_38108719/article/details/99674379
Corregido de la siguiente manera
@Autowired y @Resource no pertenecen a ninguno de los modelos de montaje automático. Este blog estará cubierto y habrá una verificación del código fuente más adelante.
Los amigos que estén interesados pueden echar un vistazo a los procesadores integrados de Spring. Dos de ellos están dedicados a analizar las dos anotaciones @Autowired y @Resource.
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
En primer lugar, de acuerdo con el método de inyección de inversión de control en el marco de resorte mencionado en el sitio web oficial de primavera, solo existen métodos de establecimiento y métodos de construcción.
Mira el modelo de inyección mencionado (4 tipos)
Entonces, ¿cómo usamos estos cuatro? La configuración del formulario xml proporcionada por la versión Spring 1.0 es la siguiente para todos los beans en el archivo
O para un solo frijol de la siguiente manera
Entonces podemos saber que solo el método de configuración xml puede usar el modelo de ensamblaje automático
Entonces, ¿por qué @Autowired y @Resource no?
Cuando busquemos la diferencia entre @Autowired y @Resource en Internet, mencionaremos que @Autowired es por tipo primero y luego por nombre (establecer el nombre del método)
Y @Resource es por nombre primero y luego por tipo, y se informará un error si no se encuentra.
Entonces ahora veremos a continuación si se basa en el nombre y el tipo del modelo de ensamblaje, o se basa en una tecnología para buscar por nombre y tipo.
En primer lugar, sabemos que estas anotaciones proporcionadas por el marco de primavera se actualizan después de la primavera 2.5.
Y la web oficial de primavera no menciona que estas dos anotaciones utilicen cualquier punto en el modelo de montaje automático, como se muestra en la figura, podemos entrar y ver
El problema que ahora usamos código para explicar es que las dos anotaciones @Autowired y @Resource no usan ninguno de los modelos de inyección automática.
El entorno es una forma xml tradicional de primavera para probar un bytype en el modelo de inyección automática
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
" default-autowire="byType">
<context:component-scan base-package="org.springframework.work2"></context:component-scan>
<bean id="uService" class="org.springframework.work2.service.UService" >
</bean>
<bean id="tService" class="org.springframework.work2.service.TService">
</bean>
</beans>
public class TService{
UService uService;
public UService getUService() {
return this.uService;
}
public void setUService(UService uService) {
this.uService = uService;
}
}
public class UService {
}
public class Main {
public static void main(String[] args) {
//AnnotationConfigApplicationContext cxc = new AnnotationConfigApplicationContext(AppConfig.class);
ClassPathXmlApplicationContext cxc = new ClassPathXmlApplicationContext("classpath:spring2.xml");
TService tService = (TService) cxc.getBean("tService");
System.out.println(tService.getUService());
}
}Lo que necesitamos no es el resultado impreso, sin duda se puede inyectar con normalidad. Hacemos clic en el código fuente para ver, la cadena de llamadas es
org.springframework.context.support.AbstractApplicationContext # refresh
org.springframework.context.support.AbstractApplicationContext # finishBeanFactoryInitialization
org.springframework.beans.factory.config.ConfigurableListableBeanFactory # preInstantiateSingletons
org.springframework.beans.factory.support.AbstractBeanFactory # getBean (java.lang.String)
org.springframework.beans.factory.support.AbstractBeanFactory # doGetBean
org.springframework.beans.factory.support.AbstractBeanFactory # createBean
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory # doCreateBean
Primero establezcamos el punto de interrupción y luego volvamos a romper el punto para entrar
Echemos un vistazo al modelo de inyección de este bean a través del postprocesador.
Y sucede que configuramos el modelo de ensamblaje automático en xml es bytype.
Veamos ahora la anotación de prueba del segundo entorno @Autowired y @Resource
El entorno 2 utiliza la forma de anotaciones.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">
<context:component-scan base-package="org.springframework.work2"></context:component-scan>
<bean id="uService" class="org.springframework.work2.service.UService" >
</bean>
<bean id="tService" class="org.springframework.work2.service.TService">
</bean>
</beans>
package org.springframework.work2.service;
import org.springframework.stereotype.Component;
public class UService {
}
package org.springframework.work2.service;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
public class TService{
@Autowired
UService uService;
public UService getUService() {
return this.uService;
}
public void setUService(UService uService) {
this.uService = uService;
}
}
package org.springframework.work2;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.work2.app.AppConfig;
import org.springframework.work2.service.TService;
import org.springframework.work2.service.UService;
public class Main {
public static void main(String[] args) {
//AnnotationConfigApplicationContext cxc = new AnnotationConfigApplicationContext(AppConfig.class);
ClassPathXmlApplicationContext cxc = new ClassPathXmlApplicationContext("classpath:spring2.xml");
TService tService = (TService) cxc.getBean("tService");
System.out.println(tService.getUService());
}
}
El mismo punto de interrupción y la misma cadena de llamadas, solo miramos el método de última llamada de estas dos anotaciones
Imprimamos y veamos el modelo de ensamblaje de este bean.
Por supuesto, también podemos configurar manualmente este modelo de ensamblaje por tipo o por nombre en este postprocesador.
beanDefinition.setAutowireMode (0); 0-1-2-3-4 ...
Los dos procesadores aquí son los procesadores que analizan las dos anotaciones @Autowired y @Resource mencionadas anteriormente.
Obviamente, no existe un método bytype o byname. El siguiente blog también demostrará que la tecnología de inyección utilizada por las dos anotaciones @Autowired y @Resource es que el tipo y el nombre no tienen nada que ver con el modelo de inyección automática.