Spring es un marco de desarrollo ligero de Java que surgió en 2003. Fue creado para resolver la complejidad del desarrollo de aplicaciones empresariales. El núcleo de Spring es la inversión de control (IoC) y la programación orientada a aspectos (AOP) . Spring es un marco ligero de código abierto que se puede utilizar en Java SE / EE. La función principal de Spring es "desacoplar" el código y reducir el acoplamiento entre códigos. Se trata de dejar que la relación entre objetos y objetos (módulos y módulos) no utilice asociaciones de código, sino que se explique a través de la configuración, es decir, la relación entre objetos (módulos) se explica en Spring. De acuerdo con las características funcionales del código, Spring usa Ioc para reducir el acoplamiento entre objetos comerciales. IoC convierte el negocio principal en el proceso de invocación mutua, ya no es necesario mantener la relación, es decir, ya no es necesario crear los objetos a utilizar, sino que se asigna una gestión unificada por parte del contenedor Spring, "inyección" automática, inyección. AOP permite la reutilización máxima de los servicios a nivel del sistema y los programadores ya no necesitan "mezclar" manualmente los servicios a nivel del sistema en la lógica comercial principal, sino que el contenedor Spring completa el "tejido".

Sitio web oficial de Spring : https://spring.io/

1.2 Ventajas de la primavera

Spring es un framework, un software semiacabado. Hay más de 20 módulos. Es un objeto gestionado por un contenedor. El contenedor contiene cosas. El contenedor Spring no contiene texto o números, sino objetos. Spring es un contenedor para almacenar objetos.

1.2.1 Ligero

Los frascos utilizados por Spring son relativamente pequeños, generalmente por debajo de 1 M o varios cientos de kb. Los frascos necesarios para las funciones principales de Spring son aproximadamente 3 millones en total. El marco de Spring consume menos recursos para ejecutarse, tiene una alta eficiencia operativa y no depende de otros jar.

1.2.2 Para programación de interfaz, desacoplamiento

Spring proporciona inversión de control de Ioc, el contenedor administra objetos y dependencias de objetos. El método de creación de objeto original en el código del programa ahora lo completa el contenedor. Desacoplamiento de dependencia entre objetos.

1.2.3 Soporte de programación AOP

A través de la función AOP proporcionada por Spring, es conveniente llevar a cabo una programación orientada a aspectos. Muchas funciones que no son fáciles de implementar con OOP tradicional se pueden manejar fácilmente a través de AOP. En Spring, los desarrolladores pueden liberarse del complicado código de administración de transacciones y ser flexibles de manera declarativa Realizar la gestión empresarial de manera oportuna para mejorar la eficiencia y calidad del desarrollo.

1.2.4 Facilitar la integración de varios marcos excelentes

Spring no excluye varios marcos excelentes de código abierto. Por el contrario, Spring puede reducir la dificultad de usar varios marcos. Spring proporciona soporte directo para varios marcos excelentes (como Struts, Hibernate, MyBatis). Simplifique el uso del marco. El resorte es como un panel de conexión, otros marcos son enchufes, que se pueden ensamblar fácilmente. Qué marco necesita usar, coloque el enchufe en el panel de conexión. No es necesario quitarlo fácilmente.

1.3 Arquitectura de primavera

Spring está compuesto por más de 20 módulos, que se pueden dividir en acceso / integración de datos (Acceso / Integración de datos), Web, programación orientada a aspectos (AOP, Aspects), proxy JVM (Instrumentación), mensajería (Mensajería), contenedor central (Contenedor central) y prueba (Prueba).

2. Inversión de control de IoC

La Inversión de Control (IoC, Inversión de Control) es un concepto y una idea que se refiere a la transferencia de los derechos de llamada de objetos tradicionalmente controlados directamente por código de programa al contenedor, y el ensamblaje automático y la gestión automática de los objetos se realizan a través del contenedor. La inversión de control es la transferencia de control sobre el objeto, desde el propio código del programa al contenedor externo. Realice la creación de objetos, la asignación de atributos y la gestión de dependencias a través del contenedor.

IoC, que significa inversión de control, es un concepto y un tipo de pensamiento. Se puede implementar de varias formas. La implementación popular actual es [Dependency Injection].

¿Qué es la dependencia? Dependencia: classA contiene una instancia de classB, y el método de classB se llama en classA para completar la función, es decir, classA depende de classB.

La realización de Ioc: Dependency Injection DI (Dependency Injection), el código del programa no hace consulta de posicionamiento, estas tareas son completadas por el propio contenedor.

La inyección de dependencia DI significa que cuando el programa se está ejecutando, si se necesita llamar a otro objeto para obtener ayuda, no es necesario crear el destinatario de la llamada en el código, sino confiar en el contenedor externo, que se crea y se pasa al programa.

La inyección de dependencias de Spring casi no tiene requisitos para el llamador y el destinatario de la llamada, y es totalmente compatible con la gestión de dependencias entre objetos.

El marco de Spring usa la inyección de dependencia (DI) para implementar IoC.

El contenedor Spring es una superfábrica, responsable de crear y administrar todos los objetos Java, estos objetos Java se denominan Beans. El contenedor Spring administra las dependencias entre los beans en el contenedor. Spring usa "inyección de dependencia" para administrar las dependencias entre los beans y usa IoC para lograr el desacoplamiento y la integración entre objetos.

2.1 Preparación de la herramienta de desarrollo

Herramientas de desarrollo: idea2017 y superior. Gestión de dependencias: maven3 y superior. jdk: 1.8 o más.

2.2 El primer programa de Spring

2.2.1 Cree un proyecto de proyecto vacío con idea y agregue un módulo: proyecto Spring basado en Maven

2.2.2 El diagrama de estructura del proyecto después de la creación es el siguiente

[En este momento, cree un directorio de recursos de recursos usted mismo y márquelo como ...]

2.2.3 Los pasos para crear objetos por Spring usando IOC son los siguientes

2.2.4 (1) Introduzca la dependencia de maven en el archivo pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wind</groupId>
    <artifactId>ch01-hello-spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>

        <!--Spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.2</version>
        </dependency>

        <!--单元测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.2.4 (2) Definir interfaces y clases de entidad

public interface SomeService { 
    void doSome();
}

public class SomeServiceImpl implements SomeService { 
    public SomeServiceImpl() {
        super();
        System.out.println("SomeServiceImpl无参数构造方法");
    }

    @Override
    public void doSome() { 
        System.out.println("====业务方法doSome()===");
    } 

}

2.2.4 (3) Crear 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. Se debe agregar un archivo de restricción a la configuración del resorte para que se use normalmente. El archivo de restricción es la extensión xsd.

<bean />: se utiliza para definir un objeto de instancia. Una instancia corresponde a un elemento bean.

id: Este atributo es el identificador único de la instancia de Bean, el programa accede al Bean a través del atributo id, y la dependencia entre el Bean y el Bean también está relacionada a través del atributo id.

clase: especifique la clase a la que pertenece el Bean. Tenga en cuenta que esto solo puede ser una clase, no una interfaz.

2.2.4 (4) Use los beans creados por el contenedor Spring para ayudarnos a probar en la clase de prueba myTest.java

2.2.5 Use spring para crear objetos de clase no personalizados

(1) Por ejemplo: agregue la definición java.util.Date al archivo de configuración de Spring: <bean id = "myDate" class = "java.util.Date" />

(2) En la clase de prueba MyTest: llame a getBean ("myDate"); para obtener el objeto de la clase de fecha.

2.3 Interfaz del contenedor ApplicationContext y otras clases de implementación

2.3.0 Interfaz ApplicationContext (contenedor)

ApplicationContext se utiliza para cargar archivos de configuración de Spring y actuar como un "contenedor" en el programa. Hay dos clases de implementación.

2.3.1 El archivo de configuración está en classpath

Si el archivo de configuración de Spring está almacenado en la ruta de clases del proyecto, use la clase de implementación ClassPathXmlApplicationContext para cargar.

2.3.2 Cuándo ensamblar objetos en el contenedor ApplicationContext

El contenedor ApplicationContext ensamblará todos los objetos en él a la vez cuando se inicialice el objeto contenedor. 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.

2.3.4 Objetos Java creados usando Spring Container

2.3.5 Cómo verificar cuántos objetos java hay en el contenedor Spring y la salida de estos detalles del objeto java

Spring config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
int nums = ac.getBeanDefinitionCount();
String names [] = ac.getBeanDefinitionNames();

Spring-1: comprender el marco de Spring y los objetos ApplicationContext

1. Resumen de primavera

1.1 ¿Qué es el marco Spring?