Uno, ¿qué es el marco de Spring?
1. Resumen de primavera:
Es para facilitar la gestión entre módulos de proyecto, la gestión entre clases y clases, para ayudar a los desarrolladores a crear objetos y gestionar las relaciones entre objetos.
2. Tecnología de núcleo de resorte:
(1) Inversión de control (IoC)
IoC : Puede realizar el desacoplamiento entre módulos y clases, es decir, no es necesario crear los objetos para ser utilizados por usted mismo. En cambio, es administrado por el contenedor Spring, que automáticamente "inyecta", y la inyección significa asignación.
(2) Programación orientada a aspectos (AOP)
AOP : Maximice la reutilización de los servicios a nivel del sistema, y los programadores ya no necesitarán "mezclar" manualmente los servicios a nivel del sistema en la lógica comercial principal. En su lugar, el contenedor Spring completa el "tejido".
3. Ventajas:
- 1. Ligero
- 2. Desacoplamiento para programación de interfaz
- 3. Soporte de programación AOP
Dos, inversión de control de IoC
1. IoC (inversión de control): la inversión de control es una teoría, un concepto y una idea.
(1) Inversión del control : la creación de objetos, la asignación de atributos y la gestión de dependencias son todas implementadas por contenedores fuera del código, es decir, la creación de objetos se completa con otros recursos externos.
(2) Control : creación de objetos, asignación de atributos de objetos y gestión de relaciones entre objetos.
(3) Reversión : transfiera la autoridad de creación de objetos y administración del desarrollador original a un contenedor fuera del código. El contenedor gestiona los objetos en lugar del desarrollador. Crea objetos y asigna valores a los atributos.
(4) Rotación hacia adelante : el desarrollador utiliza el nuevo método de construcción para crear el objeto en el código, y el desarrollador gestiona activamente el objeto.
public static void main(String args[ ]){
Student student = new Student( ); // 在代码中， 创建对象。
}
(5) Contenedor : es un software de servidor, un marco (primavera)
2. ¿Cuáles son las formas de crear objetos en java?
- 1. Método de construcción, nuevo objeto
- 2. Reflexión
- 3. Serialización
- 4. Clonar
- 5. ioc: objeto de creación de contenedor
- 6. Proxy dinámico
Aquí también hemos aprendido la idea de ioc antes, como servlet:
1. Cree una clase para heredar HttpServelt
2. Registre el servlet en web.xml y use
< servlet-name> myservlet < /servlet-name>
< servelt-class>com.hcz.controller.MyServlet< /servlet-class >
3. No hay ningún objeto Servlet creado aquí, es decir, hay no MyServlet myservlet = new MyServlet ()
4. Este objeto Servlet es creado por el servidor Tomcat. Tomcat también se denomina contenedor
5. Tomcat como contenedor: los objetos Servlet, Listener y Filter se almacenan en su interior.
3. ¿Por qué utilizar IoC?
El propósito es reducir los cambios en el código y lograr diferentes funciones. Darse cuenta del desacoplamiento.
4. Implementación de IoC
- Inyección de dependencia DI (inyección de dependencia):
Si necesita llamar a otro objeto para obtener ayuda, no necesita crear un destinatario en el código, solo proporcione el nombre del objeto que se usará en el programa. En cuanto a cómo se crea el objeto en el contenedor, asignación, y la búsqueda se implementan dentro del contenedor, y el contenedor lo pasa al programa.
- El marco de Spring usa la inyección de dependencia para implementar IoC:
1. Spring es un contenedor que administra objetos y asigna valores a las propiedades. La capa inferior es la reflexión para crear objetos.
2. El contenedor Spring es una súper fábrica responsable de crear y administrar todos los objetos Java. Estos objetos Java se llaman Bean
3. Gestión de contenedores de Spring Con respecto a las dependencias entre Beans en el contenedor, Spring usa "inyección de dependencia" para administrar las dependencias entre Beans
Tres, crea el primer programa de primavera
(1) Cree un proyecto maven primero
(2) Introducir la dependencia de maven pom.xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
(3) Definir interfaces y clases de entidad.
public interface SomeService {
public void doSome();
}
public class SomeServiceImpl implements SomeService {
public SomeServiceImpl(){
System.out.println("无参构造方法");
}
@Override
public void doSome() {
System.out.println("执行了SomeService的doSome方法");
}
}
(4) Cree un archivo de configuración de Spring
Ahora cree un archivo xml en el directorio src / main / resources /. El nombre del archivo puede ser arbitrario, pero Spring recomienda el nombre applicationContext.xml.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="someService" class="com.hcz.service.impl.SomeServiceImpl"/>
<bean id="someService1" class="com.hcz.service.impl.SomeServiceImpl"/>
<!--创建一个非定义类的对象-->
<bean id="myDate" class="java.util.Date"/>
</beans>
Análisis :
1. <bean>: se utiliza para crear un objeto de instancia, un objeto de instancia corresponde a una etiqueta de bean
2. atributo id: el nombre personalizado del objeto, es un valor único, Spring encuentra el objeto de instancia a través de este valor de id.
3. Atributo de clase: el nombre completo de la clase (nota: no puede ser una interfaz, porque Spring es un mecanismo de reflexión para crear objetos, debe usar una clase)
El principio de implementación subyacente de Spring :
SomeService someService = new SomeServiceImpl();
Spring coloca los objetos creados en el mapa. El marco de Spring tiene un mapa para almacenar los objetos, springMap.put (valor de identificación, objeto);
por ejemplo:
springMap.put("someService",new SomeSerivceImp());
(5) Definir la clase de prueba
/**
* 1、不使用spring容器创建对象
*/
@Test
public void testSomeServiceOne(){
SomeService service = new SomeServiceImpl();
service.doSome();
}
/**
* 2、使用spring容器创建对象
*/
@Test
public void testSomeServiceTwo(){
//1.指定spring的配置文件
String config = "bean.xml";
//2.创建spring容器的【所有对象】，因为调用了它们各自的无参构造方法
ApplicationContext context = new ClassPathXmlApplicationContext(config);
//3.从容器中获取某个对象
SomeService someService = (SomeService) context.getBean("someService");
someService.doSome();
}
Análisis :
1. ApplicationContext: Representa el punto de entrada del contenedor IOC. Cuando se inicializa el objeto contenedor, todos los objetos que contiene se ensamblarán a la vez. Si desea utilizar estos objetos en el código en el futuro, solo necesita obtenerlos directamente de la memoria. La eficiencia de ejecución es mayor. Pero ocupa memoria.
Esta clase tiene dos clases de implementación para leer archivos de configuración:
- ClassPathXmlApplicationContext: significa leer datos de la ruta de clases>
- FileSystemXmlApplicationContext: significa leer datos del sistema de archivos actual
2. ¿Cuándo se creó el objeto de instancia en el
contenedor ? El objeto en el contenedor ya está creado cuando se crea el contenedor de resorte.
3. Diagrama esquemático del uso del contenedor Spring para crear objetos
4. El contenedor de resorte no solo define el método para obtener un objeto, sino que también define la cantidad de objetos de instancia en el contenedor de resorte y sus respectivos nombres de objeto.
//3.从容器中获取容器中定义的对象的数量
int num = context.getBeanDefinitionCount();
//4.获取容器中每个定义的对象的名称
String[] names = context.getBeanDefinitionNames();
5. El contenedor de resorte también puede obtener clases no personalizadas, como Fecha
Definido en el archivo de configuración
<bean id="myDate" class="java.util.Date"/>
Definir el método de prueba
@Test
public void testSomeServiceFour(){
//1.指定spring的配置文件
String config = "bean.xml";
//2.创建spring容器中的所有对象
ApplicationContext context = new ClassPathXmlApplicationContext(config);
//3.从容器中获取某个对象
Date myDate = (Date) context.getBean("myDate");
System.out.println(myDate);
}
Si hay alguna deficiencia, ¡corríjame!