prefacio

AOP también es un contenido relativamente importante en Spring. En comparación con el modo OOP tradicional, AOP tiene muchos lugares incomprensibles. Este artículo presentará el método de implementación de AOP y su implementación subyacente, que incluye:

POA inicial
Conceptos básicos de AOP
AOP ( conceptos ) Terminología
proxy dinámico
Introducción a las notificaciones (pre, post, devolución, excepción, envolvente)
Notificaciones de configuración basadas en anotaciones
Escenarios de aplicación de AOP

1. ¿Qué es AOP?

AOP (Programación Orientada a Aspectos), es decir, programación orientada a aspectos, complementa la OOP (Programación Orientada a Objetos, programación orientada a objetos), y proporciona una perspectiva de estructura de software abstracta diferente de la OOP. En OOP, usamos clases como Nuestra unidad básica, y la unidad básica en AOP es Aspect (aspecto)

En segundo lugar, el concepto básico de AOP

El marco AOP tiene las siguientes dos características:

Buen aislamiento entre múltiples pasos.
Independencia del código fuente.

3. Conceptos AOP (terminología AOP)

Aspecto/Asesores (sección)

Modularización de una preocupación que puede atravesar múltiples objetos. En Spring AOP, los aspectos se pueden implementar utilizando métodos basados en patrones o en anotaciones @Aspect.

punto de unión

Un punto durante la ejecución del programa. En Spring AOP, un punto de unión siempre representa la ejecución de un método.

Consejo

Una acción realizada en un punto de unión particular de un aspecto. Muchos marcos AOP (incluido Spring) usan interceptores como modelos de notificación y mantienen una cadena de interceptores centrada en puntos de unión.

Punto de corte (punto de entrada)

Encuentre condiciones para puntos de unión. El consejo está asociado con una expresión de punto de corte y opera en puntos de unión que satisfacen este punto de corte.

Introducción

Declarar métodos o propiedades adicionales en un tipo. Spring permite introducir nuevas interfaces (y una implementación correspondiente) a cualquier objeto proxy.

Objeto de destino

Un objeto a ser aconsejado por uno o más aspectos. También conocido como el objeto aconsejado. Dado que Spring AOP se implementa a través de servidores proxy en tiempo de ejecución, este objeto siempre es un objeto proxy.

Proxy AOP

El objeto creado por el marco AOP se utiliza para implementar el contrato de aspecto (como la ejecución del método de notificación, etc.). En Spring, los servidores proxy AOP pueden ser servidores proxy dinámicos JDK o servidores proxy CGLIB.

Costura

Weaving es un proceso, que es el proceso de aplicar aspectos al objeto de destino para crear un objeto proxy AOP.Weaving se puede realizar durante la compilación, la carga de clases y el tiempo de ejecución.

Primavera AOP

1. Spring AOP se implementa en Java puro, que no requiere un proceso de compilación especial. Spring AOP no requiere el control de la jerarquía del cargador de clases, por lo que es adecuado para contenedores de Servlet o servidores de aplicaciones.

2. Spring AOP actualmente solo admite puntos de unión de ejecución de métodos.

3. La forma en que Spring implementa AOP es diferente de otros marcos. Spring no tiene la intención de proporcionar la implementación de AOP más completa (aunque Spring AOP tiene esta capacidad), por el contrario, en realidad se enfoca en proporcionar una integración entre la implementación de AOP y el contenedor Spring IoC para ayudar a resolver problemas comunes de desarrollo a nivel empresarial.

4. Spring AOP nunca tiene la intención de competir con AspectJ al proporcionar una solución AOP integral. Creemos que tanto los marcos basados en proxy como Spring AOP o los marcos maduros como AspectJ son valiosos y deberían ser complementarios en lugar de competitivos.

Cuarto, la implementación subyacente de AOP en el marco Spring

La capa inferior de la tecnología AOP del marco Srping también es la tecnología proxy utilizada. El método proxy proporciona dos

1. Agente dinámico basado en JDK

Debe estar orientado a la interfaz, solo las clases que implementan interfaces específicas pueden generar objetos proxy

2. Proxy dinámico basado en CGLIB

Para una clase que no implementa una interfaz, también se puede generar un proxy para generar una subclase de esta clase

El AOP tradicional de Spring adopta diferentes métodos de proxy según si la clase implementa la interfaz

Si se implementa la interfaz de clase, use el proxy dinámico JDK para completar AOP
Si la interfaz no está implementada, use el proxy dinámico CGLIB para completar AOP

Implementación simple de AOP basada en Spring

Tenga en cuenta que antes de la explicación, déjeme explicar un punto: para usar Spring AOP, para ejecutar el código con éxito, no es suficiente usar solo el paquete jar proporcionado por Spring a los desarrolladores. Descargue dos paquetes jar adicionales de Internet:

aopalliance.jar
aspectojweaver.jar

5. Darse cuenta del efecto de la notificación aop a través de la configuración

configuración xml

<bean id="logger" class="com.ahpome.company.utils.Logger" />
<aop:config>
	// 定义切面 aspect
	<aop:aspect id="loggerAspect" ref="logger"> 
		// 定义 切入点
		<aop:pointcut id="loggerRef" expression="execution(* com.ahpome.company..*.*(..)) and !bean(logger)" />
		// 通知 环绕通知 :around;前置通知 :before;后置通知:after;最终通知:after-returning;异常通知:after-throwing
		<aop:around method="record" pointcut-ref="loggerRef" />
	</aop:aspect>
</aop:config>

	public Object record(ProceedingJoinPoint pjp){

		Log log = new Log();

		try {
			log.setOperator("admin");
			String mname = pjp.getSignature().getName();
			log.setOperName(mname);
			Object[] args = pjp.getArgs();
			log.setOperParams(Arrays.toString(args));

			// 执行目标方法，返回的是目标方法的返回值，本例中 void
			Object obj = pjp.proceed();
			if(obj != null){
				log.setResultMsg(obj.toString());
			}else{
				log.setResultMsg(null);
			}

			log.setOperResult("success");
			System.out.println("1111");

			return obj;
		} catch (Throwable e) {
			log.setOperResult("failure");
			log.setResultMsg(e.getMessage());
		} finally{
			// logService.saveLog(log);
		}
		// 注意：这里如果是返回null即使你调用的时候返回是null，即使你的方法中含有返回值
		return null;
	}

Proxy dinámico JDK

	/*
	 * 接口
	 */
	public interface UserService {
		void save();
		int select();
	}

    /*
	 * 接口实现类
	 */
	public class UserServiceImpl implements UserService {

		@Override
		public void save() {
			System.out.println("保存用户信息成功");
		}

		@Override
		public int select() {
			System.out.println("查询用户信息成功");
			return 10;
		}
	}


	/*
	 * JDK动态代理工厂类
	 */
	public class JdkProxyFactory implements InvocationHandler {
		private Object target;
		public JdkProxyFactory(Object target) {
			this.target = target;
		}

		/**
		 * 获取代理对象，当前类继承InvocationHandler
		 */
		public Object getProxyObject() {
			return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			//添加功能
			System.out.println("增强代码，添加日志功能");
			//执行原有方法
			return method.invoke(target, args);
		}
	}

Pruebe el proxy dinámico JDK

	@Test
	public void JdkProxyTest() {

		// 创建目标对象
		UserService userService = new UserServiceImpl();
		//创建工厂对象
		JdkProxyFactory jdkProxyFactory = new JdkProxyFactory(userService);
		UserService proxy = (UserService) jdkProxyFactory.getProxyObject();
		proxy.save();
		System.out.println("=========================");
		proxy.select();
		
	}

6. Escenarios de aplicación de AOP

Mencionamos anteriormente que AOP aplica principalmente alguna lógica comercial no central. Echemos un vistazo a los escenarios de aplicación comunes de AOP.

monitor
registro
cache
autenticación
asuntos
manejo de excepciones
Persistencia

Resumir

Lo anterior es mi resumen de los problemas de implementación subyacentes de Spring AOP en el desarrollo de Java de los principios de implementación Spring AOP de la arquitectura de Internet a gran escala.

El principio de implementación subyacente de Spring AOP