Tabla de contenido
Cree un proyecto de primavera:
2. Agregue soporte de Spring Framework:
3. Configure los archivos de recursos:
1.2 Guarde Bean en el contenedor:
2.2 Obtenga el objeto Bean especificado:
La diferencia entre ApplicationContext y BeanFactory:
Adquisición de tipo de objeto:
Cree un proyecto de primavera:
La creación de un proyecto Spring se divide en cuatro pasos:
- Cree un proyecto Maven normal;
- Agregar soporte de marco Spring;
- archivo de recursos de configuración;
- Agregar clase de inicio;
1. Cree un proyecto Maven:
Declaración de la premisa: las personas intentan usar idea2021 tanto como sea posible, porque los complementos relacionados después de la versión 2022 se cobran;
2. Agregue soporte de Spring Framework:
Agregue esta dependencia de configuración al archivo pom.xml del proyecto Spring: actualice y descargue en el almacén local
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.24</version>
</dependency>
</dependencies>3. Configure los archivos de recursos:
Cree un archivo xxx.xml en el paquete de recursos y luego agregue el archivo de configuración de Spring:
<?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:content="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 https://www.springframework.org/schema/context/spring-context.xsd">
<content:component-scan base-package="com.spring.demo"></content:component-scan>
</beans>4. Agregar clase de inicio:
Cree una clase en el archivo java específicamente para iniciar la prueba:
public class School {
public static void main(String[] args) {
}
}Uso de objetos Bean:
1. Guarde el objeto Bean:
Principio: el marco Spring tiene contexto de primavera para administrar el contexto de primavera y frijoles de primavera para administrar módulos de objetos;
¿Qué es un objeto Bean? Los objetos reutilizados en el proyecto se pueden considerar como objetos Bean, y almacenar objetos Bean significa colocar los objetos requeridos por el proyecto en el contenedor Spring;
1.1 Crear frijol:
Ahora cree una clase de estudiante ordinaria, que viene con un método sayHi(). Dado que usaré esta clase con frecuencia en el futuro, puede considerarse como un Bean:
public class Student {
public void sayHi() {
System.out.println("hi student");
}
}1.2 Guarde Bean en el contenedor:
El bean de almacenamiento también es equivalente a la función de "declaración". Primero, abra el archivo de configuración spring-config.xml que acaba de crear en el paquete de recursos:
El formato del bean de almacenamiento:
<bean id="" class=""><bean>
Si el bean está en un paquete de varios niveles, preste atención a la ruta cuando establezca el atributo de clase;
Ahora agregue la clase Student como un bean: preste atención a la ruta
<!-- 将Bean对象（com.spring.demo.com.spring.demo.Student）
存到 Spring容器中，它的 id 为 student-->
<bean id="student" class="com.spring.demo.Student"></bean>2. Obtenga el objeto Bean:
La obtención del objeto bean se divide en tres pasos:
- Obtenga el objeto de contexto Spring: debido a que el objeto Bean se entrega a Spring para su administración, primero debe obtener Spring antes de tener permiso para operar el contenedor;
- Obtenga el objeto Bean en el contenedor a través del contexto Spring;
- Usa el objeto Bean;
2.1 Crear un contexto Spring:
Aquí debe comprender dos interfaces: ApplicationContext y BeanFactory ;
gramática:
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml"); BeanFactory beanFactory =
new XmlBeanFactory(new ClassPathResource("spring-config.xml"));2.2 Obtenga el objeto Bean especificado:
Aquí se demuestra con la ayuda de ApplicationContext:
public class School {
public static void main(String[] args) {
// 1.得到 Spring 上下文
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
// 2.获取指定 Bean 对象
Student student = (Student) context.getBean("student");
// 3.使用 Bean 对象
student.sayHi();
}
}
Hasta ahora, básicamente se ha introducido la creación de Spring, el almacenamiento y la adquisición de frijoles;
La diferencia entre ApplicationContext y BeanFactory:
En el código anterior, agregue otra clase de Profesor como un Bean nuevo y agréguelo al contenedor:
public class Teacher {
public Teacher() {
System.out.println("do teacher init");
}
public void sayHi() {
System.out.println("hi teacher");
}
}
<bean id="student" class="com.spring.demo.Student"></bean>
<bean id="teacher" class="com.spring.demo.Teacher"></bean>En este punto, hay dos beans en nuestro contenedor: uno es Student y el otro es Teacher;
Use ApplicationContext y BeanFactory para operar respectivamente: ambos solo intentan colocar el Student Bean en el contenedor para ver la diferencia en sus efectos.
Contexto de la aplicación:
El código original permanece sin cambios:
public class School {
public static void main(String[] args) {
// 1.得到 Spring 上下文
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
// 2.获取指定 Bean 对象
Student student = (Student) context.getBean("student");
// 3.使用 Bean 对象
student.sayHi();
}
}fábrica de frijoles:
Cree una nueva clase de inicio: School2, obtenga el contexto Spring y ApplicationContext no es lo mismo, el otro no necesita cambiar.
public class School2 {
public static void main(String[] args) {
// 1.使用 BeanFactory 来获取 Spring 上下文
BeanFactory beanFactory =
new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
// 2. 从 Spring 容器中获取 bean 对象
Student student = (Student) beanFactory.getBean("student");
student.sayHi();
}
}
Comparando los resultados de ejecución, es obvio que ambos obtienen y usan el objeto Bean con el id "estudiante" al mismo tiempo, pero ApplicationContext también saca al Profesor para el contexto, y BeanFactory solo obtiene el Estudiante;
Resumir:
Mismo punto:
- Tanto ApplicationContext como BeanFactory obtienen el objeto Bean en el contenedor;
diferencia:
- ApplicationContext carga e inicializa todos los objetos Bean en el contenedor a la vez (modo de hombre hambriento), y BeanFactory carga cuál se necesita (modo de hombre perezoso);
- ApplicationContext es en realidad una subclase de BeanFactory. La subclase no solo hereda todas las funciones de la clase padre, sino que también tiene sus propias funciones únicas, y ClassPathXmlApplicationContext pertenece a la subclase de ApplicationContext;
- BeanFactory también fue el primero en ser diseñado. Al comienzo del diseño, debido al alto costo del hardware de la máquina, solo se cargaron los objetos requeridos; mientras que ApplicationContext se diseñó más tarde. Para mejorar la eficiencia tanto como sea posible, la gente pensó de cargar todos los objetos Bean a la vez;
Tres getBean de uso común:
El método getBean() tiene muchas sobrecargas, compare los siguientes tres de uso común:
- Obtener según id;
- adquisición de tipos de objetos;
- id, adquisición de tipo de objeto;
Obtener por identificación:
<bean id="student" class="com.spring.demo.Student"></bean>
<bean id="teacher" class="com.spring.demo.Teacher"></bean> // 2.获取指定 Bean 对象
Student student = (Student) context.getBean("student");
Teacher teacher = (Teacher) context.getBean("teacher");Este método obviamente es grosero e indeseable, y hay una transferencia forzada, además, si el objeto obtenido a través del id es nulo, también ocurrirá una excepción;
Adquisición de tipo de objeto:
<bean id="student" class="com.spring.demo.Student"></bean>
<bean id="teacher" class="com.spring.demo.Teacher"></bean> // 2.获取指定 Bean 对象
Student student = context.getBean(Student.class);
Teacher teacher = context.getBean(Teacher.class);Aunque este método no es de mala educación, hay un problema:
Cuando el mismo tipo de Bean se registra dos veces en el contenedor, el compilador informará NoUniqueBeanDefinitionException;
id + tipo de objeto obtener:
Este método es más seguro;
<bean id="student" class="com.spring.demo.Student"></bean>
<bean id="student2" class="com.spring.demo.Student"></bean>
<bean id="teacher" class="com.spring.demo.Teacher"></bean> // 2.获取指定 Bean 对象
Student student = context.getBean("student2",Student.class);
Teacher teacher = context.getBean("teacher",Teacher.class);Pensando:
Dado que se mencionó que el mismo tipo puede registrarse varias veces en el contenedor, aunque solo tengan diferentes ID, ¿apuntan al mismo espacio?
Verificación de código:
<bean id="student" class="com.spring.demo.Student"></bean>
<bean id="student2" class="com.spring.demo.Student"></bean>
<bean id="teacher" class="com.spring.demo.Teacher"></bean>public class School {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
Student student1 = context.getBean("student", Student.class);
Student student2 = context.getBean("student2", Student.class);
System.out.println(student1 == student2);
System.out.println(student1.equals(student2));
}
}
Luego prueba que son referencias a diferentes objetos;
Resumir:
La creación del proyecto Spring y el proceso de uso básico de Bean:
