1. ¿Qué es AOP?
1. AOP (Programación Orientada a Aspectos), que utiliza el aislamiento de varias partes de la lógica empresarial, reduciendo así el acoplamiento entre las distintas partes de la lógica empresarial, mejorando la reutilización del programa y mejorando la eficiencia del desarrollo.
2. AOP adopta un mecanismo de extracción horizontal para reemplazar el código repetitivo del sistema tradicional de herencia vertical (monitoreo del desempeño, administración de transacciones, inspección de seguridad, almacenamiento en caché)
2. ¿Por qué debería aprender AOP?
Porque es posible mejorar los métodos existentes durante la operación sin modificar el código fuente.
3. ¿Cuáles son las ventajas de AOP?
- Reducir el código repetitivo 2. Proporcionar eficiencia de desarrollo 3. Mantenimiento conveniente
Cuatro, el principio subyacente de AOP
Tecnología de proxy dinámico de JDK (principalmente)
1. Cree un archivo de código de bytes de la clase de proxy para la interfaz
2. Utilice ClassLoader para cargar el archivo de código de bytes en la JVM
3. Cree un objeto de instancia de la clase de proxy y ejecute el método de destino del objeto
tecnología proxy cglib
Cinco, términos relacionados con AOP
Joinpoint (punto de conexión) El llamado punto de conexión se refiere a aquellos puntos que son interceptados. Se refiere a todos los métodos en Spring, porque Spring solo admite puntos de conexión de tipos de métodos.
Pointcut (pointcut) - (escribir expresión pointcut), entrada de mejora del programa.
Consejo (información / mejora): para mejorar el método en primavera, escriba el código relacionado con la gestión de transacciones.
Objetivo: el objetivo del agente.
Weaving: se refiere al proceso de aplicar mejoras al objeto de destino para crear un nuevo objeto proxy.
Proxy: después de que AOP teje y mejora una clase, se genera una clase de proxy resultante
Aspecto = punto de entrada + notificación
Seis, caso de entrada
(1) Primero, hable brevemente sobre los próximos pasos
①Introducir nuevas coordenadas AOP, aspectos de primavera, aspecto; ②Introducir restricciones específicas de AOP en el archivo de configuración; ③Escribir la estructura del paquete, escribir la interfaz específica y la clase de implementación; ④Inyectar la clase de destino; ⑤Definir la clase de aspecto; ⑥En el archivo de configuración clase de aspecto de inyección; ⑦ configuración AOP completa; ⑧ prueba
(2) Implementación específica
① Introducir nuevas coordenadas AOP, aspectos de primavera, aspecto;
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
<!-- Spring Aspects -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!-- aspectj -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.3</version>
</dependency>
②El archivo de configuración presenta restricciones específicas de AOP;
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
③Escribir la estructura del paquete, escribir interfaces específicas y clases de implementación;
接口：
package demo3;
public interface UserService {
public void save();
}
实现类：
package demo3;
public class UserServiceImpl implements UserService {
public void save() {
System.out.println("业务层：保护用户...");
}
}
④Inyectar la clase de destino;
<bean id="userService2" class="demo3.UserServiceImpl">
⑤ Definir la categoría de aspecto;
package demo3;
/*
* 自定义切面类 = 切入点(表达式) + 通知(增强的代码)
* */
public class MyXmlAspect {
/*通知*/
public void log(){
System.out.println("增强的方法执行了......");
}
}
⑥Inyectar facetas en el archivo de configuración;
<bean id="myXmlAspect" class="demo3.MyXmlAspect"/>
⑦Configuración AOP completa;
<!--
切入点的表达式：
execution() 固定的写法
public 是可以省略不写的
方法的返回值 int String 通用的写法，可以编写 * 不能省略不写的
包名+类名 不能省略不写的，编写 * UserServiceImpl AccountServiceImpl
方法名称 save() 可以写 *
参数列表 (..) 表示任意类型和个数的参数
比较通用的表达式：execution(public * cn.tx.*.*ServiceImpl.*(..))
-->
<aop:config>
<!--配置切面 = 切入点 + 通知组成-->
<aop:aspect ref="myXmlAspect">
<!--前置通知-->
<aop:before method="log" pointcut="execution(public * demo3.UserServiceImpl.save(..)))"/>
</aop:aspect>
</aop:config>
⑧ Escriba la clase de prueba para probar
//运行单元测试 切记需要单元测试环境 导入spring-test
@RunWith(SpringJUnit4ClassRunner.class)
//加载类路径下的配置文件
@ContextConfiguration("classpath:applicationContext4.xml")
public class demo4 {
//按照类型自动导入
@Autowired
private UserService userService;
/*测试*/
@Test
public void run(){
userService.save();
}
}
(3) Tipos de notificación AOP
<!--
AOP的通知类型
前置通知：目标方法执行前，进行增强。
<aop:before method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
最终通知：目标方法执行成功或者失败，进行增强。
<aop:after method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
后置通知：目标方法执行成功后，进行增强。
<aop:after-returning method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
异常通知：目标方法执行失败后，进行增强。
<aop:after-throwing method="log" pointcut="execution(* cn.tx.*.*ServiceImpl.save*(..))" />
环绕通知：目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行。
-->
Seven, el método de anotación de tecnología AOP de Spring
Según el 1 anterior
, agregue la anotación @Aspect a la clase de aspecto, escriba métodos mejorados y use declaraciones de anotación de tipo de notificación
@Component // 把该类交给IOC去管理
@Aspect // 声明是切面类 == <aop:aspect ref="myXmlAspect">
public class MyXmlAspect {
/*通知*/
// @Before(value = "切入点的表达式")
@Before(value = "execution(public * demo3.UserServiceImpl.save(..))")
public void log(){
System.out.println("增强的方法执行了......");
}
}
2. Active el proxy automático en el archivo de configuración.
<!--开启注解扫描-->
<context:component-scan base-package="demo3"/>
<!--开启自动代理--> c
<aop:aspectj-autoproxy/
Ocho, método de anotación pura con tecnología AOP de Spring
Anotación de tipo
de notificación
@Before - notificación previa @AfterReturing - notificación
posterior @Around - notificación circundante (el método del objeto de destino no se ejecuta de forma predeterminada y debe ejecutarse manualmente) @After - notificación
final
@AfterThrowing - notificación de lanzamiento de excepción
Escribir clase de configuración
@Configuration // 配置类
@ComponentScan(value = "cn.tx.demo3") // 扫描包
@EnableAspectJAutoProxy // 开启自动代理 == <aop:aspectj-autoproxy />
public class SpringConfig {
}
Resumen de los puntos de conocimiento importantes del marco Spring (4) .