IoC es la abreviatura de Inversión de Control, traducida como "Inversión de Control", no es una tecnología, sino una idea de diseño y una importante regla de programación orientada a objetos.
Spring gestiona la creación de instancias e inicialización de todos los objetos Java a través del contenedor IoC y controla las dependencias entre objetos. A los objetos Java administrados por el contenedor IoC los llamamos Spring Beans y no hay diferencia entre ellos y los objetos Java creados con la palabra clave new. El contenedor de IoC es uno de los componentes centrales más importantes del marco de Spring y recorre todo el proceso de Spring desde su nacimiento hasta su crecimiento.
Inversión de control (IoC)
En las aplicaciones Java tradicionales, si una clase quiere llamar a una propiedad o método en otra clase, generalmente crea este último objeto a través de un nuevo Objeto () en su código y luego implementa la propiedad o método. Para facilitar la comprensión y la descripción, podemos llamar al primero el "llamante" y al segundo el "llamado". En otras palabras, la persona que llama tiene control sobre la creación del objeto llamado.
Pero en las aplicaciones Spring, el control de la creación de objetos Java está en manos del contenedor IoC. Los pasos generales son los siguientes.
- Los desarrolladores definen objetos Java a través de archivos de configuración XML, anotaciones, clases de configuración Java, etc., como el uso de etiquetas <bean> en archivos de configuración XML, el uso de anotaciones @Component en clases Java, etc.
- Cuando comience Spring, el contenedor IOC creará y administrará automáticamente estos objetos en función de las definiciones de objetos. Estos objetos creados y administrados por el contenedor IOC se denominan Spring Beans.
- Cuando queremos usar un Bean, podemos obtenerlo directamente del contenedor IOC (por ejemplo, a través del método getBean() de ApplicationContext) sin crearlo manualmente mediante código (por ejemplo, new Obejct()).
El mayor cambio provocado por IoC no es a nivel de código, sino a nivel ideológico, el cambio de "transposición maestro-esclavo". Originalmente, la persona que llama era la parte activa y tomaba la iniciativa y creaba cualquier recurso que quisiera usar. Sin embargo, en las aplicaciones Spring, el contenedor de IoC tiene la iniciativa y la persona que llama se convierte en la parte pasiva, esperando pasivamente el contenedor de IoC. .Crear los objetos (Beans) que requiera.
Este proceso tiene una inversión de control en el nivel de responsabilidad, invirtiendo la creación de objetos originalmente implementados por la persona que llama a través del código al contenedor IoC para ayudar a implementarlo, por lo que llamamos a este proceso la "inversión de control" de Spring.
Inyección de dependencia (DI)
Después de comprender IoC, también debemos comprender otro concepto muy importante: la inyección de dependencia.
Martin Fowler propuso la inyección de dependencia (DI) en 2004 al explicar la "inversión de control". Martin Fowler cree que el término "inversión de control" es muy confuso y no permite que las personas comprendan directamente "dónde está la inversión", por lo que sugirió utilizar "inyección de dependencia" en lugar de "inversión de control".
En la orientación a objetos, existe una relación llamada "dependencia" entre objetos. En pocas palabras, una relación de dependencia significa que un objeto necesita usar otro objeto, es decir, hay un atributo en el objeto y el atributo es un objeto de otra clase.
Por ejemplo, hay una clase Java denominada B con el siguiente código.
public class B {
String bid;
A a;
}Como se puede ver en el código, hay un atributo de objeto a de tipo A en B. En este momento, podemos decir que el objeto de B depende del objeto a. La inyección de dependencia se basa en esta "relación de dependencia".
La idea central de la inversión de control es que Spring es responsable de la creación de objetos. Durante el proceso de creación del objeto, Spring inyectará automáticamente los objetos de los que depende en el objeto actual en función de las relaciones de dependencia, lo que se denomina "inyección de dependencia".
Cómo funciona el COI
En el proceso de desarrollo de software Java, existen más o menos relaciones de acoplamiento entre varios objetos del sistema, entre varios módulos y entre sistemas de software y sistemas de hardware.
Si el acoplamiento de un sistema es demasiado alto, causará problemas que son difíciles de mantener, pero el código sin ningún acoplamiento difícilmente puede completar ningún trabajo, porque casi todas las funciones requieren cooperación e interdependencia entre códigos para completarse. Por tanto, cuando diseñamos programas, la idea a la que nos adherimos generalmente es reducir al máximo el grado de acoplamiento sin afectar el funcionamiento del sistema.
La capa inferior de IoC utiliza el modo de fábrica, el mecanismo de reflexión de Java, el análisis XML y otras tecnologías para reducir el acoplamiento del código al mínimo. Los pasos principales son los siguientes.
- En el archivo de configuración (como Bean.xml), configure cada objeto y las dependencias entre ellos;
- Podemos pensar en el contenedor del COI como una fábrica, y el producto de esta fábrica es Spring Bean;
- Cuando se inicia el contenedor, cargará y analizará estos archivos de configuración para obtener información básica sobre los objetos y las dependencias entre ellos;
- COI utiliza el mecanismo de reflexión de Java para generar un objeto correspondiente (es decir, Spring Bean) según el nombre de la clase e inyecta este objeto en objetos que dependen de él según las dependencias.
Dado que la información básica del objeto y las dependencias entre objetos están definidas en el archivo de configuración y no están estrechamente acopladas en el código, incluso si el objeto cambia, solo necesitamos modificarlo en el archivo de configuración sin modificar el código Java, esto es el principio de desacoplamiento del COI de primavera.
Dos implementaciones de contenedores IoC
La idea de IoC se implementa en base al contenedor de IoC. La capa inferior del contenedor de IoC es en realidad una fábrica de Bean. El marco Spring nos proporciona dos tipos diferentes de contenedores IoC, a saber, BeanFactory y ApplicationContext.
fábrica de frijoles
BeanFactory es la implementación básica del contenedor IoC y el contenedor IoC más simple proporcionado por Spring, proporciona las funciones más básicas del contenedor IoC y está definido por la interfaz org.springframework.beans.factory.BeanFactory.
BeanFactory utiliza un mecanismo de carga diferida. El contenedor no crea un objeto Java inmediatamente cuando se carga el archivo de configuración. Solo se creará cuando el objeto se obtenga (use) en el programa.
Ejemplo 1
Uso de BeanFactory.
En el proyecto HelloSpring, modifique el código de MainApp para usar BeanFactory para obtener el objeto HelloWorld, el código específico es el siguiente.
public static void main(String[] args) {
BeanFactory context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = context.getBean("helloWorld", HelloWorld.class);
obj.getMessage();
}2Ejecute MainApp.java, la salida de la consola es la siguiente.
mensaje: ¡Hola mundo!
BeanFactory es la interfaz interna de Spring y normalmente no está disponible para los desarrolladores.
Contexto de aplicación
ApplicationContext es una subinterfaz de la interfaz BeanFactory y una extensión de BeanFactory. ApplicationContext agrega muchas funciones de nivel empresarial basadas en BeanFactory, como AOP (programación orientada a aspectos), internacionalización, soporte de transacciones, etc.
La interfaz ApplicationContext tiene dos clases de implementación de uso común, como se detalla en la siguiente tabla.
| Clase de implementación | describir | Código de muestra |
|---|---|---|
| ClassPathXmlApplicationContext | Cargue el archivo de configuración XML especificado en la ruta de clase ClassPath y complete la creación de instancias de ApplicationContext | ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation); |
| FileSystemXmlApplicationContext | Cargue el archivo de configuración XML especificado en la ruta del sistema de archivos especificada y complete la creación de instancias de ApplicationContext | ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation); |
El parámetro configLocation se utiliza para especificar el nombre y la ubicación del archivo de configuración de Spring, como Beans.xml.
Demostrar el uso de ApplicationContext
Modifique el código del método main () en la clase MainApp del proyecto HelloSpring, el código específico es el siguiente.
public static void main(String[] args) {
//使用 FileSystemXmlApplicationContext 加载指定路径下的配置文件 Bean.xml
BeanFactory context = new FileSystemXmlApplicationContext("D:\\springworkspace\\
HelloSpring\\src\\Beans.xml");
HelloWorld obj = context.getBean("helloWorld", HelloWorld.class);
obj.getMessage();
}Ejecute MainApp.java, la salida de la consola es la siguiente:
mensaje: ¡Hola mundo!