¡El núcleo de Spring es una inversión ligera de control (IOC) y un marco de programación orientada a aspectos (AOP)!
La inversión de control es para reducir el acoplamiento entre códigos, la forma más común es la inyección de dependencia
¿Qué es la inyección de dependencia?
Primero veamos qué es la dependencia. En la vida, depender de otros u otras cosas sin poder ser independiente o independiente se llama dependencia.
Entonces, ¿qué es la dependencia en la aplicación? La dependencia se refiere a la relación entre dos instancias. Una instancia es independiente y la otra instancia es dependiente (dependiente) y depende de otra instancia. Por ejemplo, el objeto de computadora, que contiene el objeto de host y el objeto de visualización. Si no hay un objeto host o un objeto de visualización, el objeto de la computadora está incompleto y no se puede usar normalmente. Decimos que el objeto de la computadora depende del objeto del host y del objeto de la visualización.
Entonces, ¿qué es la inyección? Los objetos de la computadora son inseparables del objeto del host y el objeto de visualización. Cuando el programa se está ejecutando, debemos proporcionar al objeto de la computadora el objeto del host y el objeto de la pantalla que necesita, y proporcionar el objeto del host y el objeto de la pantalla al objeto de la computadora como una "inyección" El proceso se llama inyección. En otras palabras, si un objeto necesita que otro objeto se utilice normalmente, le proporcionamos al objeto el objeto que necesita cuando el programa se está ejecutando, lo que se denomina "inyección de dependencia".
Sabemos que Spring administrará casi todos los objetos Bean, y puede haber dependencias entre objetos. Durante la ejecución del programa, Spring ensambla todos los objetos que necesitamos. Esta es la inyección de dependencias de Spring. En el diseño tradicional de Java, cuando una persona que llama a una instancia de Java crea una instancia llamada Java, se requiere que la clase llamada Java aparezca en el código de la persona que llama, y no se puede lograr un acoplamiento flexible entre las dos. En términos sencillos, el modelo de fábrica ha mejorado esto para que la persona que llama no tenga que preocuparse por el proceso de implementación específico del destinatario y pueda usarlo siempre que obtenga una instancia que cumpla con un cierto estándar (interfaz). El código de llamada está orientado a la programación de la interfaz, que admite el desacoplamiento de la persona que llama y la persona que llama, por lo que el patrón de fábrica se puede utilizar ampliamente. Pero en el modelo de fábrica, la persona que llama debe ubicar la fábrica por sí mismo y estar acoplada con la fábrica específica, por lo que la disociación de la persona que llama y la persona que llama solo se logra hasta cierto punto. La aparición de Spring elimina la necesidad de que los llamantes ubiquen la fábrica por sí mismos. Cuando el programa se ejecuta en el destinatario de la llamada, el sistema proporcionará automáticamente la instancia del destinatario de la llamada. De hecho, tanto la persona que llama como la persona que llama son administradas por Spring, y Spring proporciona la dependencia entre los dos.
En términos sencillos: el objeto de clase B se usa en la clase A. En circunstancias normales, se debe usar un nuevo objeto B en la clase A. La inyección de dependencia solo necesita definir un objeto B privado en la clase A.
La inyección de dependencia, un aspecto de la COI, es un concepto común y tiene muchas explicaciones. El concepto es que no necesita crear un objeto, solo necesita describir cómo se crea. No ensambla sus componentes y servicios directamente en el código, pero necesita describir qué componentes necesitan qué servicios en el archivo de configuración, y luego un contenedor (contenedor IOC) es responsable de ensamblarlos.
Caso completo de inyección de dependencia
- Cómo desarrollar una impresora
Puede configurarse de manera flexible para usar cartuchos de tinta de color o cartuchos de tinta negra
Puede configurar de manera flexible el tamaño de la página impresa (A4, B5)
La realización de la función de impresora depende del cartucho de tinta y del papel - Paso
1. Defina los estándares de interfaz para cartuchos de tinta y papel.
2. Utilice los estándares de interfaz para desarrollar la impresora.
3. Ensamble la impresora.
4. Ejecute la impresora.
1. Defina el estándar de interfaz del cartucho de tinta y el papel
//定义墨盒接口
public interface InkBox {
//提供获取颜色的方法
String getColor();
}
============== 为了阅读方便放在了一起 标准做法应该要分开写 ==============
//定义纸张大小接口
public interface PaperSize {
//提供获取纸张大小的方法
String getPaper();
}
2. La clase de implementación de la interfaz.
//A4纸张
public class A4Paper implements PaperSize {
public String getPaper() {
return "A4";
}
}
//B5纸张
public class B5Paper implements PaperSize {
public String getPaper() {
return "B5";
}
}
//黑色墨盒
public class BlackInkBox implements InkBox {
public String getColor() {
return "黑色墨盒";
}
}
//彩色墨盒
public class ColourInkBox implements InkBox {
public String getColor() {
return "彩色墨盒";
}
}
3. Clase de impresora (la clase se define aquí, si desea ensamblar diferentes impresoras, debe usar la interfaz y las diferentes clases de impresora implementan un método de impresora común)
Inyección del método Setter: la inyección del método Setter significa que después de que el contenedor instancia el bean llamando al constructor sin parámetros o al método de fábrica estática sin parámetros, se llama al método setter del bean, que realiza la inyección de dependencia basada en el setter.
public class Printer {
private InkBox inkBox;
private PaperSize paperSize;
//通过set注入必须要提供无参构造
public Printer() {
}
//提供setter方法对应xml文件中标签<property name="paperSize" ref="a4Paper"/>
public void setInkBox(InkBox inkBox) {
this.inkBox = inkBox;
}
//提供setter方法对应xml文件中标签<property name="inkBox" ref="colourInkBox"/>
public void setPaperSize(PaperSize paperSize) {
this.paperSize = paperSize;
}
//组装打印机的方法
public void print(){
System.out.println("使用"+inkBox.getColor()+"打印出了"+paperSize.getPaper()+"大小的纸张");
}
}
4. Configure el archivo 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">
<!-- 创建A4Paper的对象 -->
<bean id="a4Paper" class="com.li.bean.Impl.A4Paper"/>
<!-- 创建ColourInkBox的对象 -->
<bean id="colourInkBox" class="com.li.bean.Impl.ColourInkBox"/>
<!-- 创建Printer对象 Printer中用到了PaperSize InkBox 两个接口的引用 所以需要接口的实现类-->
<bean id="printer" class="com.li.bean.Printer">
<property name="paperSize" ref="a4Paper"/>
<property name="inkBox" ref="colourInkBox"/>
</bean>
<bean id="b5Paper" class="com.li.bean.Impl.B5Paper"/>
<bean id="blackInkBox" class="com.li.bean.Impl.BlackInkBox"/>
<bean id="printer2" class="com.li.bean.Printer">
<property name="paperSize" ref="b5Paper"/>
<property name="inkBox" ref="blackInkBox"/>
</bean>
</beans>
5. Prueba
public class TestPrinter {
/**
* 一般情况下:new 对象
*/
@Test
public void printerOut() {
A4Paper a4Paper = new A4Paper();
ColourInkBox colourInkBox = new ColourInkBox();
Printer printer = new Printer();
printer.setPaperSize(a4Paper);
printer.setInkBox(colourInkBox);
printer.print();
//使用黑色墨盒打印出了A4大小的纸张
}
/**
* 创建对象由配置文件管理
*/
@Test
public void printerOut2(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Printer printer = context.getBean("printer", Printer.class);
printer.print();
//使用彩色墨盒打印出了A4大小的纸张
}
@Test
public void printerOut3() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Printer printer = context.getBean("printer2", Printer.class);
printer.print();
//使用黑色墨盒打印出了B5大小的纸张
}
}
Resumen: Spring IOC es responsable de crear objetos, administrar objetos (a través de la inyección de dependencia (DI), ensamblar objetos, configurar objetos y administrar todo el ciclo de vida de estos objetos).