1. Alcance del frijol
Cuando el contenedor Spring IOC crea una instancia de Bean, puede especificar el alcance del Bean, incluido singleton (modo singleton, opción predeterminada, solo uno para todo el proyecto), prototipo (modo prototipo), solicitud (solicitud Http), sesión ( session), global-session (sesión global) [los tres últimos solo son válidos en proyectos web].
（1） Singleton
Solo hay una clase de entidad correspondiente a la identificación del bean en todo el contenedor Spring IOC, que generalmente se aplica a Service y DAO.
<bean id="dog" class="com.zt.entity.Dog" scope="singleton">
<constructor-arg index="0" value="汪汪"/>
<constructor-arg index="1" value="2"/>
</bean>El valor predeterminado es Singleton y el alcance también se puede mostrar y escribir.
Vale la pena señalar que el modo singleton del que estamos hablando se refiere a que la clase de entidad obtenida usando el mismo ID de bean es la misma, pero si dos tipos de bean son iguales pero el ID de bean es diferente, entonces todavía son dos diferentes. Clase de entidad.
[Nota]: En Java, el tipo de referencia == compara la dirección de memoria del almacenamiento del objeto.
<bean id="dog" class="com.zt.entity.Dog">
<constructor-arg index="0" value="汪汪"/>
<constructor-arg index="1" value="2"/>
</bean>
<bean id="dog2" class="com.zt.entity.Dog">
<constructor-arg index="0" value="汪汪"/>
<constructor-arg index="1" value="2"/>
</bean>
（2） Prototipo
En el modo de prototipo, los beans obtenidos mediante el uso del contenedor IOC no son los mismos cada vez, incluso si su ID de bean es el mismo.
<bean id="dog" class="com.zt.entity.Dog" scope="prototype">
<constructor-arg index="0" value="汪汪"/>
<constructor-arg index="1" value="2"/>
</bean>
（3） Solicitar
En una solicitud Http, un bean id corresponde a una sola instancia; se puede entender que en cada solicitud, el bean es un modo singleton (limitado al mismo bean id).
（4） Sesión
En una sesión, una identificación de bean corresponde a una sola instancia.
（5）sesión global
Sesión global (no lo entiendo temporalmente, lo agregaré después de entenderlo).
2. Montaje automático
Spring proporciona una función de ensamblaje automático, solo una configuración simple, ni siquiera necesitamos configurarnos para la inyección.
Palabra clave Autowire: Se utiliza para especificar las reglas del contenedor Spring para ayudarnos a inyectar.
byName: cuando el id de un bean es el mismo que el nombre de un atributo de una clase de entidad que espera ser inyectada, se puede inyectar
byType: cuando el tipo de un bean es el mismo que el tipo de un atributo de una clase de entidad esperando ser inyectado, se puede inyectar
Si los Beans registrados en el contenedor tienen el mismo tipo (o todos se ajustan a la categoría de las propiedades inyectadas por la generación, incluida la clase padre hijo y la interfaz), entonces se informará un error al usar byType.
Por supuesto, podemos inyectar este atributo manualmente, y después de que Spring detecta que el atributo está inyectado, no lo inyectará automáticamente por nosotros.
3. Desarrollo de anotaciones
El archivo de configuración tiene un defecto obvio: se deben escribir una gran cantidad de reglas en el archivo de configuración. Cuando la integración del sistema se vuelve alta, la confusión de una gran cantidad de archivos de configuración causará confusión en el proyecto, por lo que usamos anotaciones para reemplazar archivos de configuración en muchos lugares, lo que puede simplificar enormemente el archivo de configuración o incluso eliminar el archivo de configuración. Pero esto no significa que la escritura del archivo de configuración esté desactualizada, porque el archivo de configuración tiene una flexibilidad que no se puede lograr con anotaciones. Anteriormente, en Mybatis, teníamos <sql> con <include> para extraer SQL repetido, y podíamos También personalice el resultMap personalizado. Es imposible para las anotaciones. La práctica común actual es escribir en el archivo de configuración donde la flexibilidad es necesaria, y usar anotaciones tanto como sea posible para reemplazar las otras.
Para que la anotación surta efecto, es diferente del archivo de configuración, el archivo de configuración puede especificar directamente cómo configurar y dónde hay configuración, pero la anotación debe realizarse después de escanear para saber. ¿Te acuerdas? En Mybatis, cuando usamos el desarrollo de anotaciones, necesitamos cambiar el registro del mapeador a clase y apuntar a DAO.
1. El uso de anotaciones de ensamblaje automáticas
1. Para usar anotaciones, debemos introducir contexto y modificar el archivo de configuración de la siguiente manera:
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
</beans>2. Configure el escáner
<context:component-scan base-package="com.zt"/>3. Agregue anotaciones Autowired a los atributos correspondientes de las clases que deben ensamblarse
@Autowired
private Stu stu;4. Prueba
Hay una identificación de bean con el mismo nombre que la propiedad que se va a inyectar:
No hay ningún ID de bean con el mismo nombre que la propiedad que se va a inyectar, y hay un bean del mismo tipo:
Por supuesto, Spring también proporciona anotaciones de calificador para usar con Autowried, que se pueden inyectar especificando el bean por el ID del bean, lo que también es conveniente para la inspección del programa.
¡pero! Java en sí mismo proporciona anotaciones de recursos y también puede realizar el ensamblaje automático.
Explique la diferencia y la conexión en detalle:
Contacto: tanto @Autowired como @Resouce se pueden usar para el ensamblaje automático, y ambos se pueden escribir en campos de atributos o definidores.
Diferencia: @Autowired se empareja por tipo por defecto. Por defecto, el objeto a inyectar debe existir, y no se permite que sea nulo. También puede establecer su propiedad required = false para permitir que el ensamblado sea nulo. Con la anotación @Qualifier, puede usar el ensamblado por nombre.
@Resource según el nombre predeterminado especificado por el nombre del atributo nombre del ensamblaje. Si no se especifica el nombre, si la anotación está en el campo, la búsqueda se realiza por nombre por defecto según el nombre del campo; si la anotación está en el establecedor, se busca según el nombre del atributo correspondiente al método del establecedor. . Cuando no se pueda encontrar el mismo nombre, se ensamblará según el tipo. Sin embargo, si se ha especificado el nombre, solo se ensamblará de acuerdo con el nombre. Es decir, nombre -> byName -> byType.
2. Anotación de componentes
Después de introducir las anotaciones, no necesitamos configurar beans en el archivo de configuración, sino que usamos anotaciones de componentes para indicarle a Spring qué clases deben ser administradas por el contenedor Spring como beans.
@Component: puede declarar las clases que Spring necesita administrar como beans; @Component + valor reemplaza <bean id = "" class = ""> </bean>
Puede usar el ensamblado @Resource.
También puede usar el ensamblaje @ Autowired + @ Qualifier.
1) Utilice @Value para la inyección de tipo básico.
2) Utilice @ Autowired + @ Qualifier para ensamblar automáticamente tipos de referencia.
3) Los objetos complejos como matrices, listas y mapas no son fáciles de usar directamente para las anotaciones de inyección, lo que también destaca la flexibilidad de los archivos de configuración.
3. Notas de desarrollo en capas
De hecho, en el desarrollo del proyecto, colocaremos el proyecto en capas: Controllr-Service-DAO
@Repository: se utiliza para marcar la capa DAO.
@Service: se utiliza para marcar la capa de servicio.
@Controller: se utiliza para marcar la capa del controlador.
Las clases con las anotaciones anteriores también serán administradas como beans por el contenedor Spring después de ser escaneadas por el escáner.
4. Clase de configuración (podemos usar la clase de configuración Java en lugar del archivo de configuración)
@Bean: pasa los objetos existentes en el contenedor como parámetros y guarda los objetos devueltos en el contenedor para su administración.
@Configurable: Declara que la clase actual es una clase de configuración.
Cuando usamos anotaciones para la configuración, es posible que debamos hacer referencia a las clases en el paquete jar. En este momento, no tenemos forma de modificar esas clases directamente. Para obtener sus objetos y almacenarlos en el contenedor, solo podemos usar el arriba anotaciones. Por ejemplo, los gatos comen ratones y los ratones se usan como alimento para gatos, ahora no podemos modificar gatos y ratones, pero queremos devolver un gato que tenga ratones como alimento.
Mouse.java
package com.zt.config;
public class Mouse {
private String name;
public Mouse() {
}
public Mouse(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Mouse{" +
"name='" + name + '\'' +
'}';
}
}Cat.java
package com.zt.config;
public class Cat {
private String name;
private Mouse mouse;
public Cat() {
}
public Cat(String name, Mouse mouse) {
this.name = name;
this.mouse = mouse;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Mouse getMouse() {
return mouse;
}
public void setMouse(Mouse mouse) {
this.mouse = mouse;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", mouse=" + mouse +
'}';
}
}TestConfig.java
package com.zt.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TestConfig {
@Bean
public Mouse mouse(){
return new Mouse("jerry");
}
@Bean
public Cat cat(Mouse mouse){
return new Cat("Tom",mouse);
}
}prueba:
import com.zt.config.Cat;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.zt.config.TestConfig;
public class TestClassConfig {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestConfig.class);
Cat cat = context.getBean(Cat.class);
System.out.println(cat);
}
}
Hable sobre anotaciones y archivos de configuración xml: Hace muchos años, la industria generalmente creía que el uso de archivos de configuración puede completar el desacoplamiento del programa, y dado que nuestro proyecto finalmente se empaqueta en un archivo de configuración de clase +, es muy importante modificar directamente el código fuente Cosas poco realistas, por lo que puede modificar el proyecto modificando el archivo de configuración (como reemplazar el grupo de conexiones, etc.); pero el método del archivo de configuración hará que todo el proyecto se vea abrumado por una gran cantidad de archivos de configuración, por lo que la corriente principal actual es configurar Documentado, es decir, para algunas anotaciones de uso casi fijo, para algunas que pueden cambiar con frecuencia o son más flexibles, se sigue utilizando el archivo de configuración, lo que simplifica el archivo de configuración.