En el subproceso múltiple, encontrará que la inyección automática de Spring falla. La razón es que Spring cree que es peligroso hacerlo en el subproceso múltiple. Si está acostumbrado a usar el marco, entonces todos sabemos que el valor predeterminado es singleton, es decir, en subprocesos múltiples. ¿Cómo inyectar Mapper para que lo usemos?
En un proyecto de subprocesos múltiples, también encontré este problema, y la instanciación de las clases sobre mi interfaz de mapeador fue creada por mí mismo a través de la reflexión de Java. Solo agregué la anotación @Mapper cuando se usó la interfaz de Mapeador. El problema inmediato es que si escribo el @Resouce habitual en la clase empresarial para inyectar el mapeador, el mapeador es nulo, lo cual es completamente comprensible, porque mi clase empresarial no está anotada y no se entrega a Spring para su gestión. Se instancia por sí mismo. Sí, esto hace que el mapeador no se pueda inyectar, entonces, ¿cómo llamo al mapeador? ¡Oh rugido! Puede declarar una variable de asignador en la clase empresarial y luego agregar un método de inicialización durante la inicialización de reflexión
Nota: La situación que discutí es que la clase de negocios general se crea una instancia por sí misma, y algunas clases se administran en Spring
Podrías decir: ¿Está enfermo el cartel original? Algunos se instancian por sí mismos y otros se administran en primavera. ¿No es complicado?
No, la reflexión de Java es la primera forma de obtener e instanciar clases dinámicamente;
El segundo es el proyecto springmvc ordinario en el pasado. Recordamos que habrá muchos archivos de configuración. Una configuración de bean puede agregar la configuración de atributos que desee durante la inicialización.
Hemos desarrollado el método de archivos de configuración;
Muchos frameworks actuales, como springboot, springcloud, etc., manejan estas tareas por sí mismos. No tenemos que preocuparnos por eso, y escribir más negocios;
En el análisis final, todos se basan en la reflexión de Java.
Los beneficios de la reflexión de Java: puede crear una instancia de su clase específica a nivel de código, como crear una instancia de acuerdo con el nombre de la clase difusa, etc., y puede hacer cualquier cosa durante la instancia.
No hay mucho que decir, mi situación es:
He creado una instancia de la clase de interfaz correspondiente en el paquete com.skxx.work.busi. Al mismo tiempo, observe que agregué un método initMapper () aquí. Este método es para configurar el asignador para mi clase de negocio.
Mira mi clase ejecutiva:
Mi UserLogic no agregó ninguna anotación. Como dije antes, esta clase fue creada por mí mismo a través de la reflexión anterior y no fue administrada por Spring
Pero mi interfaz Mapper está administrada por Spring, entonces, ¿cómo la obtenemos ahora? A través del contexto de primavera, aquí hay un método de herramienta para obtener cualquier bean en su contexto. El código anterior no tiene mucho que ver con usted, solo para que todos comprendan la situación, el siguiente código de herramienta no es una imagen
Este es mi mapeador, que es administrado por Spring:
Clase de herramienta: obtenga cualquier bean que haya sido instanciado a través del contexto
package com.skxx.config.spring;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* @program: coalpreparation
* @description: 解决在多线程情况下，非注解实例化类时，无法注入mapper的问题
* 因为类的实例化并不没有交给spring，所以要自己手动去获取mapper
* @author: Mr.MYR(ClearLoveQ)
* @create: 2020-04-21 14:24
**/
@Component
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (SpringContextUtil.applicationContext == null) {
SpringContextUtil.applicationContext = applicationContext;
}
}
/**
* 获取applicationContext
*
* @return
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 通过name获取 Bean.
*
* @param name
* Bean's name
* @return
*/
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
*
* @param clazz
* @return
*/
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
*
* @param name
* @param clazz
* @return
*/
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
}
En este punto, creo que puede tener una comprensión más profunda de la primavera y deseo que todos sigan avanzando en el camino del código.