Esta página se tradujo automáticamente con la API de traducción de Google Cloud.
Algunas páginas se pueden leer mejor en su totalidad.
La programación orientada a aspectos (AOP) es un paradigma de programación que tiene como objetivo aumentar la modularidad al permitir la separación de preocupaciones transversales. AOP forma el núcleo de Spring AOP, que se utiliza para implementar aplicaciones empresariales.
La programación orientada a aspectos es un paradigma que permite a los desarrolladores modularizar aspectos transversales, como el registro, la seguridad y la gestión de transacciones. Esto se hace encapsulando estas preocupaciones en módulos separados, llamados aspectos. Luego, los aspectos se pueden entretejer en el código de la aplicación principal en tiempo de compilación, tiempo de carga o incluso tiempo de ejecución.
AOP es ortogonal y se puede utilizar junto con la programación orientada a objetos (OOP). De hecho, muchos de los beneficios de AOP se pueden lograr mediante el uso de técnicas de programación orientada a objetos, como la herencia y la composición. Sin embargo, AOP ofrece una serie de beneficios sobre OOP, que discutiremos más adelante.
Como dijimos anteriormente, uno de los principales beneficios de AOP es una mayor modularidad. Al modularizar las preocupaciones transversales en aspectos separados, podemos hacer que nuestro código sea más modular y más fácil de entender.
Otro beneficio de AOP es la reducción de la duplicación de código. Las preocupaciones transversales a menudo se implementan en varios lugares a lo largo de una aplicación. Por ejemplo, considere un aspecto de registro. Es posible que queramos registrar llamadas a métodos en varios puntos de nuestro código. Sin AOP, tendríamos que duplicar nuestro código de registro en cada uno de estos lugares. Con AOP, podemos encapsular nuestro código de registro en un solo aspecto y reutilizarlo en toda nuestra aplicación.
AOP también puede mejorar la legibilidad y el mantenimiento de nuestro código. Considere el siguiente ejemplo:
public void foo() {
// do something
bar();
// do something else
}
public void bar() {
// do something
}
En este ejemplo, el método foo() llama al método bar(). Si quisiéramos agregar algún código de registro a foo(), tendríamos que agregarlo antes y después de la llamada a bar(). Con AOP, podemos encapsular este código de registro en un aspecto y aplicarlo tanto a foo() como a bar(). Esto daría como resultado el siguiente código:
public void foo() {
// do something
// logging code
bar();
// logging code
// do something else
}
public void bar() {
// logging code
// do something
// logging code
}
Como puede ver, el código de registro ahora está centralizado en el aspecto, lo que hace que los métodos foo() y bar() sean más fáciles de leer y mantener.
AOP también puede mejorar la capacidad de prueba de nuestro código al permitirnos simular aspectos. Por ejemplo, considere un sistema que utiliza una base de datos. Es posible que queramos escribir algunas pruebas unitarias para nuestro sistema, pero no queremos llegar a la base de datos. Con AOP, podemos simular el aspecto de acceso a la base de datos y escribir nuestras pruebas unitarias sin tocar la base de datos.
Si bien AOP ofrece muchos beneficios, también tiene algunos inconvenientes.
Uno de los principales inconvenientes de AOP es su mayor complejidad. AOP introduce un nivel adicional de abstracción, que puede hacer que nuestro código sea más difícil de entender.
Otro inconveniente de AOP es la sobrecarga del tiempo de ejecución. La abstracción adicional introducida por AOP puede dar como resultado un mayor uso de la memoria y una disminución del rendimiento.
Entonces, ¿debería usar AOP en su próximo proyecto? La respuesta, como ocurre con la mayoría de las cosas en el desarrollo de software, es "depende".
Si necesita los beneficios de AOP, como una mayor modularidad o una duplicación de código reducida, entonces AOP puede ser una buena opción para su proyecto. Sin embargo, si está trabajando en un proyecto con estrictos requisitos de rendimiento, es posible que AOP no sea la mejor opción.
Spring AOP se utiliza para implementar aplicaciones empresariales. Se basa en AOP Alliance y utiliza la sintaxis de Java 5.
Para usar AOP en Spring Boot, debemos agregar la dependencia spring-boot-starter-aop a nuestro pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
También necesitamos habilitar AOP en nuestra aplicación Spring Boot agregando la anotación @EnableAspectJAutoProxy a nuestra clase principal:
@SpringBootApplication
@EnableAspectJAutoProxy
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Ahora que tenemos AOP configurado en nuestra aplicación, creemos un aspecto. Los aspectos en Spring AOP se implementan usando clases regulares de Java anotadas con la anotación @Aspect.
Considere el siguiente ejemplo:
@Aspect
public class MyAspect {
// methods and pointcuts go here
}
En este ejemplo, hemos creado un aspecto simple llamado MyAspect. Los aspectos pueden contener cualquier número de métodos y puntos de corte. Discutiremos los métodos y los puntos de corte con más detalle más adelante.
Una vez que hemos creado nuestro aspecto, debemos aplicarlo a nuestro código. Esto se hace usando puntos de corte. Un punto de corte es un predicado que coincide con los puntos de unión. Un punto de unión es un punto en la ejecución de nuestro programa, como una llamada a un método.
Los puntos de corte se pueden definir mediante expresiones regulares o sintaxis de Java 5. Por ejemplo, el siguiente punto de corte coincide con todos los métodos del paquete com.example:
@Pointcut("execution(* com.example..*.*(..))")
public void myPointcut() {}
El método myPointcut() es solo un marcador de posición para nuestro punto de corte. Ahora podemos usar las anotaciones @Before y @After para aplicar nuestro aspecto a nuestro código. La anotación @Before hará que el aspecto se ejecute antes de que se llame al método, y la anotación @After hará que el aspecto se ejecute después de que se llame al método.
Considere el siguiente ejemplo:
@Aspect
public class MyAspect {
@Pointcut("execution(* com.example..*.*(..))")
public void myPointcut() {}
@Before("myPointcut()")
public void before(JoinPoint joinPoint) {
// do something
}
@After("myPointcut()")
public void after(JoinPoint joinPoint) {
// do something
}
}
En este ejemplo, hemos definido un punto de corte que coincide con todos los métodos del paquete com.example. También hemos definido un método before() que se ejecutará antes de llamar al método coincidente, y un método after() que se ejecutará después de llamar al método coincidente.
En este artículo, hemos discutido la programación orientada a aspectos y cómo se puede usar en Spring Boot. También hemos visto cómo crear y aplicar aspectos en Spring Boot.