1. ¿Qué es la primavera?
Spring: un marco integral de código abierto para javaSE / EE que resuelve el problema del acoplamiento flexible entre la capa de lógica empresarial y otras capas.
1. Capas
2. javaSE / EE todo en uno
3. Código abierto
4. Resolver el problema del acoplamiento flojo entre la capa de lógica empresarial y otras capas, por lo que todo el marco de ideas de programación orientadas a la interfaz.
Problema de acoplamiento flojo-acoplamiento bajo, principio de alta cohesión
Acoplamiento-entendido simplemente como la conexión entre clases y
cohesión-entendido simplemente como la colección de programas que implementan una determinada función.
Beneficios: No es necesario mover todo el cuerpo. ¿Dónde hay errores y correcciones?
Finalidad: Mejorar la reutilización del código y facilitar el mantenimiento.
2. Estructura de resorte
Lo anterior es el diagrama de estructura proporcionado oficialmente por Spring.
De abajo hacia arriba prueba [prueba], contenedor central, aop [programación orientada a aspectos], web, acceso a datos
1. Solo hay un módulo en la sección de
prueba : prueba de primavera .jar: prueba de primavera, que proporciona la función de prueba junit y simulacro.
2. El contenedor central contiene 4 módulos
spring-core: inyección de dependencia de la implementación más básica de IoC y DI
spring-beans: fábrica de frijoles y ensamblaje de frijoles
contexto de primavera: spring's contexto, es decir, el contenedor de IoC
spring-expression: lenguaje de expresión Spring
3.aop parte [orientada a aspectos] contiene 4 módulos
spring-aop: programación orientada a
aspectos spring-areas: aspecto integrado
Spring-instrument: proporciona algunos niveles de clase soporte de herramientas e implementación a nivel de ClassLoader para servidores spring-instrument-tomcat: implementación de instrumentos para tomcat
4. El elemento
web contiene 4 módulos spring-web: funciones web básicas, como carga de archivos
spring-webmvc: implementación
de mvc spring-webmvc-portlet:
Spring-struts de implementación mvc basada en portlet : integración con struts, no recomendado, el resorte 4 ya no proporciona
5. La parte de acceso a datos contiene 5 módulos
spring-jdbc: soporte jdbc
spring-tx: control de transacciones
spring-orm: mapeo relacional de objetos, marco integrado de orm
spring-oxm: mapeo xml de objetos
spring-jms: servicio de mensajes java
3. Ventajas de Spring
1. Desacoplamiento y simplificación convenientes Desarrollo: Spring es una superfábrica (supercontenedor), que puede ceder la creación y las dependencias de objetos a la fábrica de Spring para administrar
2. Programación AOP: Spring proporciona programación orientada a aspectos, que puede realizar fácilmente el monitoreo de operaciones, la verificación de autorización y otras operaciones en el programa
3. Declarar transacción: solo es necesario configurar para completar la gestión de la transacción, sin programación manual
4. Pruebas convenientes: Spring admite junit4, puede probar el programa a través de anotaciones de Spring
5. Integración conveniente de varios marcos: Spring admite una variedad de integración de Framework de código abierto. Por ejemplo (struts, Hibernate, MyBaties, etc.)
6. Reduzca la dificultad de usar la API de JavaEE: Spring encapsula las API muy difíciles en el desarrollo de JavaEE para reducir la dificultad de desarrollar aplicaciones de API.
4. Tecnología central de Spring
1. IoC (Inverse of Control): el derecho a crear y mantener objetos Java se transfiere a la fábrica de Spring para su administración y mantenimiento.
2.DI (inyección de dependencia): agregue rápidamente objetos dependientes en una clase java a otra clase java.
3. AOP (Programación Orientada a Aspectos), un método de mejora de funciones basado en agentes dinámicos [agregue algunos procesos de requisitos del sistema a su propio programa [administración de registros, verificación de seguridad de datos ...]].
4. Operaciones relacionadas para la gestión de transacciones.
5. Spring integra / gestiona otras capas del marco [capa web integrada Spring SpringMVC / capa de acceso a datos integrada Spring MyBatis] {SSM}
5. Spring's IoC (Inverse of Control)
no usa IoC (Inverse of Control) Control)
public class Student{
public void getStuInfo(){
System.out.println(“Student类的实例方法”)；
}
}
Acceda a getStuInfo en la clase Student en la clase de prueba
public class TestMain{
public static void main(String args){
Student stu=new Student();
stu.getStuInfo();
}
}
El objeto Student en el programa anterior es creado por el mismo desarrollador y necesita mantener este objeto por sí mismo.
Cuando se usa IoC (Inverse of Control)
1. Cree el proyecto Mavne
2. Mejore la estructura del proyecto
3. Pom.xml import Spring dependency package
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
4. Crea una clase java
package com.wangxing.spring.bean;
public class Student {
public void getStuInfo(){
System.out.println("Student类的实例方法");
}
}
5. Cree un archivo de configuración de Spring [applicationcontext.xml] en el directorio de recursos
<?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 -->
<!-- 通知Sping容器创建类对象 -->
<!--class属性：指定创建对象的java类【包名+类名】-->
<!--id属性:指定对象名称-->
<bean id="stu" class="com.wangxing.spring.bean.Student"></bean>
</beans>
6. Prueba
package com.wangxing.spring.bean.test;
import com.wangxing.spring.bean.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestMain {
public static void main(String[] args) {
//得到Spring容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
//从Spring容器中得到创建Student类对象
Student student= (Student)ac.getBean("stu");
student.getStuInfo();
}
}
En el código de prueba anterior, no teníamos nuevo, lo que indica que no creamos el objeto nosotros mismos, pero aún así llamamos al método de instancia de la clase Student.
Entonces, ¿quién creó el objeto de la clase Student?
Respuesta: Spring nos ayudó a crear un objeto de la clase Student.
¿Cómo sabe Spring que es un objeto de la clase Student que se va a crear?
Respuesta: Lo configuramos en el archivo de configuración de Spring.
<bean id="stu" class="com.wangxing.spring.bean.Student"></bean>
El elemento le dice a Spring que cree un objeto de la clase Student.
¿Dónde se almacenan los objetos de clase Student creados por Spring?
Respuesta: Almacenado en el contenedor Spring, solo necesitamos obtener el objeto contenedor Spring y obtener el objeto que queremos a través del método getBean.
IoC (Inverse of Control): el proceso de transferir los derechos de creación y mantenimiento de objetos del propio desarrollador a Spring es IoC (Inverse of Control).
Análisis de archivos de configuración y objetos centrales en
Spring 1. Se
recomienda el nombre del archivo de configuración en Spring : applicationcontext.xml
Ubicación: generalmente en el directorio de recursos
Contenido:
<?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 -->
<!-- 通知Sping容器创建类对象 -->
<!--class属性：指定创建对象的java类【包名+类名】-->
<!--id属性:指定对象名称-->
<bean id="stu" class="com.wangxing.spring.bean.Student"></bean>
</beans>
<?xml version="1.0" encoding="UTF-8"?>-Representa un
<beans></beans>archivo xml -el elemento raíz del archivo de configuración de Spring
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
------- Espacio de nombres y dirección de otros elementos introducidos en el elemento raíz, un archivo de restricción -
<bean id="stu" class="com.wangxing.spring.bean.Student"></bean>notifique al contenedor Sping para crear un
atributo de clase de objeto de clase: especifique la clase java del objeto creado [nombre de paquete + nombre de clase]
id atributo: especificar El nombre del objeto, el objeto que necesita del contenedor Spring en el futuro depende de este valor de atributo.
¿Por qué el elemento raíz son beans y el elemento bean se utiliza para crear objetos?
El significado de bean es el significado de componente en el programa. Spting cree que el objeto / clase objeto con la interfaz que crea es un componente de Spring en sí mismo, por lo que usa el elemento bean para representar el elemento que crea. Porque Spring puede crear múltiples componentes, por lo que el elemento raíz son los frijoles.
2. Objeto contenedor Spting Objeto contenedor
Spting: se utiliza para almacenar y mantener objetos creados por Spting.
Spting container object
1.ApplicationContext sub-interfaces es la interfaz a BeanFactory
2.BeanFactory interfaces
creadas ApplicationContext interfaz objeto / objetos BeanFactory interfaz
1.new ClassPathXmlApplicationContext ("Spring Profile") mirando CLASSPATH ---- [{ruta de directorio de recursos el class}] Cree el objeto de interfaz ApplicationContext / objeto de interfaz BeanFactory en el archivo de configuración de Spring.
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
BeanFactory ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
2.nuevo FileSystemXmlApplicationContext ("Archivo de configuración de Spring"); - Cree un objeto de interfaz ApplicationContext / objeto de interfaz BeanFactory buscando el archivo de configuración de Spring en la ruta del sistema [entendido como una ruta absoluta]. [No recomendado]
ApplicationContext ac=new FileSystemXmlApplicationContext("F:\20200728\IdeaProjects\TestSpringDemo1\src\main\resources\applicationcontext.xml");
BeanFactory ac=new FileSystemXmlApplicationContext("F:\\20200728\\IdeaProjects\\TestSpringDemo1\\src\\main\\resources\\applicationcontext.xml");
¿Obtener el objeto de clase que necesita del objeto contenedor de Spting?
Obtenga el objeto que necesita a través del método getBean ("") proporcionado por este objeto contenedor de Spting.
6. Creación de instancias de Bean de 4 formas
1. Sin método de construcción de parámetros (el más utilizado en el desarrollo)
package com.wangxing.spring.bean;
public class Student {
public void getStuInfo(){
System.out.println("Student类的实例方法");
}
}
Archivo de configuración de Spring
<bean id="stu" class="com.wangxing.spring.bean.Student"></bean>
Código de prueba
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
//从Spring容器中得到创建Student类对象
Student student= (Student)ac.getBean("stu");
student.getStuInfo();
2. Método de fábrica estático para instanciar el bean: escriba un método estático en una clase, este método devuelve un objeto Bean (cree el objeto Bean en el método).
package com.wangxing.spring.bean;
public class Student {
public void getStuInfo(){
System.out.println("Student类的实例方法");
}
}
Fábrica estática
package com.wangxing.spring.bean;
public class StaticFactryMethodClass {
//创建静态方法
public static Student getStudentObj(){
return new Student();
}
}
Archivo de configuración de Spring
<bean id="stu" class="com.wangxing.spring.bean.StaticFactryMethodClass" factory-method="getStudentObj"></bean>
Código de prueba
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
Student student=(Student)ac.getBean("stu");
student.getStuInfo();
3. Método de fábrica de instancias para instanciar el bean: un método para escribir una instancia en una clase, este método devuelve un objeto Bean (el objeto Bean se crea en el método).
package com.wangxing.spring.bean;
public class Student {
public void getStuInfo(){
System.out.println("Student类的实例方法");
}
}
Fábrica de instancias
package com.wangxing.spring.bean;
public class FactoryMethodClass {
//创建实例方法
public Student getStudentObj(){
return new Student();
}
}
Archivo de configuración de Spring
<!-- 实例工厂方法配置 -->
<!-- 1.创建实例工厂对象 -->
<bean id="factoryMethodClass" class="com.wangxing.spring.bean.FactoryMethodClass"></bean>
<!-- 2.配置由实例工厂创建Student对象-->
<bean id="stu" factory-bean="factoryMethodClass" factory-method="getStudentObj"></bean>
Código de prueba
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
Student student=(Student)ac.getBean("stu");
student.getStuInfo();
4. Método de interfaz FactoryBean para instanciar el bean
package com.wangxing.spring.bean;
public class Student {
public void getStuInfo(){
System.out.println("Student类的实例方法");
}
}
Subclases que implementan la interfaz FactoryBean
package com.wangxing.spring.bean;
import org.springframework.beans.factory.FactoryBean;
public class FactoryBeanSunClass implements FactoryBean<Student> {
@Override
public Student getObject() throws Exception {
return new Student();
}
@Override
public Class<?> getObjectType() {
return Student.class;
}
}
Archivo de configuración de Spring
<!-- 配置FactoryBean接口实现 -->
<bean id="stu" class="com.wangxing.spring.bean.FactoryBeanSunClass"></bean>
测试代码
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
Student student=(Student)ac.getBean("stu");
student.getStuInfo();
7. La diferencia entre la interfaz FactoryBean y la interfaz
BeanFactory Interfaz BeanFactory — Contenedor Spting — usado para almacenar y mantener objetos creados por Spting [Administración]
Interfaz FactoryBean ------------------- usado Crear objeto java 【Crear】