Spring es un marco de desarrollo de Java muy popular, en el que IoC y AOP son los conceptos centrales de Spring. En este blog, detallaré los principios de Spring IoC y AOP y cómo se implementan en el marco Spring.
¿Qué es Spring IoC?
IoC (Inversion of Control) es una inversión de control, que es un patrón de diseño de software. En el modelo de programación tradicional, los programadores suelen instanciar objetos manualmente y luego utilizar estos objetos en el programa. Sin embargo, en el patrón IoC, la creación y gestión de objetos se transfieren al contenedor y los programadores solo necesitan definir las dependencias de los objetos. La ventaja de este modo es que reduce la carga de trabajo del programador y facilita el mantenimiento y la expansión del código.
En Spring, un contenedor IoC es un objeto que se encarga de gestionar todos los objetos de la aplicación. Estos objetos se denominan beans y, por lo general, representan un componente de la aplicación, como DAO (objeto de acceso a datos), servicio, controlador, etc. El contenedor IoC se encargará de crear estos objetos bean e inyectar otros objetos bean que necesiten según las dependencias entre ellos.
El contenedor IoC de Spring implementa la interfaz BeanFactory, que es una clase de fábrica abstracta que proporciona métodos para crear y administrar objetos de frijol. Spring también proporciona una interfaz ApplicationContext de nivel superior, que es una subinterfaz de la interfaz BeanFactory y proporciona más funciones, como la internacionalización, la entrega de eventos, etc.
Principios de Spring IoC
La implementación del contenedor Spring IoC se basa en archivos de reflexión y configuración. En Spring, necesitamos definir objetos de bean y sus dependencias a través de archivos de configuración, y luego, cuando el programa se está ejecutando, el contenedor IoC creará y administrará estos objetos de bean de acuerdo con estos archivos de configuración.
Los archivos de configuración suelen tener formato XML o anotaciones. En el archivo de configuración XML, necesitamos definir información como el tipo, la ID y los atributos del bean. Por ejemplo:
<bean id="userDao" class="com.example.UserDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="userService" class="com.example.UserServiceImpl">
<property name="userDao" ref="userDao"/>
</bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
En este archivo de configuración, definimos tres objetos de bean: userDao, userService y dataSource. Existe una dependencia entre userDao y userService, y userService depende de userDao. dataSource, como un objeto de frijol independiente, depende de userDao.
Cuando se inicia el contenedor IoC, analizará este archivo de configuración y creará los objetos de bean correspondientes. Para cada objeto de bean, el contenedor IoC creará una instancia de objeto y establecerá sus propiedades de acuerdo con la información del archivo de configuración. Por ejemplo, en el archivo de configuración anterior, el contenedor IoC primero creará el objeto dataSource y establecerá sus propiedades. Luego crea el objeto userDao e inyecta el objeto dataSource como una propiedad de userDao. Finalmente, crea el objeto userService e inyecta el objeto userDao como propiedad de userService.
Este enfoque basado en archivos de configuración permite a los programadores definir de manera flexible los objetos de bean y sus dependencias. Si necesita modificar la configuración del objeto bean, solo necesita modificar el archivo de configuración sin modificar el código. Al mismo tiempo, este método también puede permitir a los programadores comprender con mayor claridad las dependencias entre los objetos de bean, lo cual es conveniente para la depuración y el mantenimiento.
**
¿Qué es Primavera AOP?
**
AOP (Programación Orientada a Aspectos) es programación orientada a aspectos, que es un paradigma de programación. En el modo de programación tradicional, la lógica comercial del programa y las preocupaciones transversales a nivel del sistema (como registros, transacciones, seguridad, etc.) se mezclan, lo que es difícil de mantener y expandir. Y AOP nació para resolver este problema. AOP nos permite abstraer estas preocupaciones transversales por separado y entretejerlas dinámicamente en la lógica comercial en tiempo de ejecución.
En Spring, la implementación de AOP se basa en el concepto de proxy dinámico y aspecto (Aspect). Un aspecto es una clase que contiene métodos (llamados consejos) que se pueden ejecutar en un punto específico del programa (llamado punto de unión). Normalmente, un punto de unión es el punto de ejecución de un método. Cuando el programa ejecuta este método, se llamará a la notificación del aspecto, para realizar la función de preocupaciones transversales.
El principio de Spring AOP
La implementación de Spring AOP se basa en dos tecnologías: proxy dinámico JDK y proxy dinámico CGLIB. Cuando el objeto de destino implemente la interfaz, Spring usará el proxy dinámico JDK para generar el objeto proxy. Cuando el objeto de destino no implementa la interfaz, Spring usará el proxy dinámico CGLIB para generar el objeto proxy.
En Spring AOP, necesitamos definir aspectos y puntos de corte. Los aspectos contienen métodos de asesoramiento que se ejecutarán en puntos específicos del programa. Un punto de corte es una expresión que define qué puntos de unión son interceptados por el aspecto. Por lo general, un punto de corte es una expresión regular que coincide con nombres de métodos, parámetros, valores devueltos, etc. en el objeto de destino.
Por ejemplo, en el siguiente código, definimos un aspecto LoggingAspect, que contiene un método de notificación beforeMethod, que se ejecutará antes de que se ejecuten todos los métodos en UserDao.
public class LoggingAspect {
public void beforeMethod(JoinPoint joinPoint) {
System.out.println("before method: " + joinPoint.getSignature().getName());
}
}
}
En este ejemplo, usamos un objeto JoinPoint para representar el punto de unión. Este objeto contiene la firma del método, los parámetros y otra información que se puede utilizar en el método de notificación.
Para entrelazar aspectos en objetos de destino, necesitamos usar archivos de configuración de Spring AOP. En este archivo de configuración, necesitamos definir facetas y puntos de corte. Por ejemplo, el siguiente archivo de configuración define un aspecto LoggingAspect, que intercepta todos los métodos en UserDao y ejecuta el método beforeMethod antes de que se ejecute el método.
<aop:config>
<aop:aspect id="loggingAspect" ref="loggingAspectBean">
<aop:pointcut id="userDaoPointcut" expression="execution(* com.example.UserDao.*(..))" />
<aop:before pointcut-ref="userDaoPointcut" method="beforeMethod" />
</aop:aspect>
</aop:config>
En este archivo de configuración, usamos el atributo de expresión para definir el punto de corte, lo que significa interceptar todos los métodos en UserDao. Luego usamos la etiqueta before para especificar el método de notificación beforeMethod. En esta etiqueta, usamos el atributo pointcut-ref para referirnos al pointcut que acabamos de definir.
Cuando se inicia el programa, Spring AOP analizará este archivo de configuración y generará objetos proxy basados en aspectos y puntos. Cuando se llama al método en UserDao, el objeto proxy juzgará si el método coincide con el punto de corte y, si coincide, llamará al método de notificación del aspecto. En el método de notificación, podemos implementar las funciones de preocupaciones transversales, como registrar registros, verificar permisos, manejar excepciones, etc.
Resumir
Spring IoC y AOP son las características principales del marco Spring, que permiten a los programadores administrar las dependencias entre objetos de manera más flexible y, al mismo tiempo, abstraer las preocupaciones transversales por separado y entrelazarlas dinámicamente en la lógica comercial. En este artículo, presentamos los principios básicos de Spring IoC y AOP, e ilustramos su uso a través de un código de ejemplo. Espero que este artículo lo ayude a comprender el marco Spring.