Spring——AOP

一 AOP的基本概念

(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知

(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用

(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around

(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式

(5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

二 Spring AOP

Spring中的AOP代理还是离不开Spring的IOC容器，代理的生成，管理及其依赖关系都是由IOC容器负责，Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。

AOP

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

代理（Proxy 设计模式中的一种）分为两种：

一种是Java的静态代理

用一个例子来说明：

首先创建一个抽象类（明星）

package com.zking.proxy;

/**
 * 
 * @ClassName: IStar
 * @Description: 抽象类
 * @author LM
 * @date 2018年9月18日 上午11:42:07
 *
 */
public interface IStar {

	/**
	 * 
	 * @Title: sing
	 * @Description: 唱歌
	 * @return void
	 */
	public void sing();

}

然后创建一个代理类（谢娜）

package com.zking.proxy;

/**
 * 
 * @ClassName: XieNa
 * @Description: 代理的类
 * @author LM
 * @date 2018年9月18日 上午11:41:15
 *
 */
public class XieNa implements IStar {

	private IStar is;

	public XieNa(IStar is) {
		super();
		this.is = is;
	}

	@Override
	public void sing() {
		is.sing();
	}

}

再创建一个真实的类（张杰）

package com.zking.proxy;

/**
 * 
 * @ClassName: ZhangJie
 * @Description: 真实角色类
 * @author LM
 * @date 2018年9月18日 上午11:41:47
 *
 */
public class ZhangJie implements IStar {

	@Override
	public void sing() {
		System.out.println("勿忘心安");
	}

}

最后来一个测试类（Test）

package com.zking.proxy;

public class Test1 {

	public static void main(String[] args) {
		// 里氏替换原则
		IStar is = new ZhangJie();
		XieNa xn = new XieNa(is);
		xn.sing();
	}

}

输出结果为：

一种是Java的动态代理

一个示例来表明一下吧

创建一个抽象类

package com.zking.proxy2;

public interface IPerson {

	public void eat();

}

然后创建一个代理类

package com.zking.proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class Proxy implements InvocationHandler {

	private IPerson ip;

	public Proxy(IPerson ip) {
		super();
		this.ip = ip;
	}

	/**
	 * 执行方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		return method.invoke(ip, args);
	}

}

再创建一个真实的类

package com.zking.proxy2;

public class XiaoMing implements IPerson {

	@Override
	public void eat() {
		System.out.println("小茗同学");
	}

}

最后来一个测试类

package com.zking.proxy2;

import java.lang.reflect.Proxy;

public class Test2 {

	public static void main(String[] args) {
		IPerson ip = new XiaoMing();
		com.zking.proxy2.Proxy proxy = new com.zking.proxy2.Proxy(ip);
		IPerson ip1 = (IPerson) Proxy.newProxyInstance(XiaoMing.class.getClassLoader(), XiaoMing.class.getInterfaces(),
				proxy);
		ip1.eat();
	}

}

输出结果如下：

以上所说的皆是Java的代理方法，既然我们所说的是Spring的AOP，那么我们就来讲讲Spring的动态代理方法，也称之为通知。

通知又分为四种通知：

前置通知、后置通知、返回通知（环绕通知）、最后还有一个异常通知

首先创建一个接口

package com.zking.springproxy;

public interface IPerson {

	public void sleep();

	public void PersonAdd();

}

再创建一个实现接口的类

package com.zking.springproxy;

public class XiaoMing implements IPerson {

	@Override
	public void sleep() {
		int a = 4;
		int b = 0;
		a = a / b;
		System.out.println("睡" + a);
	}

	@Override
	public void PersonAdd() {
		System.out.println("add");
	}

}

以下分别去创建四个代理类的通知

前置通知：

package com.zking.springproxy;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class MyBefore implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("前置通知");
	}

}

后置通知：

package com.zking.springproxy;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfter implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("后置通知");
	}

}

返回通知（环绕通知）：

package com.zking.springproxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyInterceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("环绕通知");
		return invocation.proceed();
	}

}

异常通知：

package com.zking.springproxy;

import org.springframework.aop.ThrowsAdvice;

public class MyThrow implements ThrowsAdvice {

	public void afterThrowing(Exception e) throws Throwable {
		System.out.println("出异常了..." + e);
	}

}

然后开始配置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"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">

	<!-- 配置目标 也就是实现类 -->
	<bean id="xm" class="com.zking.springproxy.XiaoMing"></bean>

	<!-- 配置前置通知的bean的对象 -->
	<bean id="myBefore" class="com.zking.springproxy.MyBefore"></bean>
	<!-- 配置后置通知的bean的对象 -->
	<bean id="myAfter" class="com.zking.springproxy.MyAfter"></bean>
	<!-- 配置环绕通知的bean的对象 -->
	<bean id="myInterceptor"
		class="com.zking.springproxy.MyInterceptor"></bean>
	<!-- 配置异常通知的bean的对象 -->
	<bean id="myThrow" class="com.zking.springproxy.MyThrow"></bean>
	<!-- 配置通知的过滤器 -->
	<bean id="advisor"
		class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice" ref="myBefore"></property>
		<property name="pattern" value=".*add.*"></property>
	</bean>
	<bean id="sleepAdvisor"
		class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="advice" ref="myAfter"></property>
		<property name="pattern" value=".*sleep.*"></property>
	</bean>

	<!-- 配置一个混合的代理对象 -->
	<bean id="myproxy"
		class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 引用目标 -->
		<property name="target" ref="xm"></property>
		<!-- 代理类的接口 -->
		<property name="proxyInterfaces">
			<list>
				<value>com.zking.springproxy.IPerson</value>
			</list>
		</property>
		<!-- 引用通知 -->
		<property name="interceptorNames">
			<list>
				<idref bean="myBefore" />
				<idref bean="myAfter" />
				<idref bean="myInterceptor" />
				<idref bean="myThrow" />

				<!-- 通知的过滤器的引用 -->
				<!-- <idref bean="advisor" /> <idref bean="sleepAdvisor" /> -->
			</list>
		</property>
	</bean>

</beans>

最后创建一个测试类：

package com.zking.temp;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.zking.springproxy.IPerson;

public class Temp {

	@Test
	public void springProxy() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		IPerson ip = (IPerson) applicationContext.getBean("myproxy");
		ip.sleep();
		ip.PersonAdd();
	}

}

输出结果如下：

出异常的原因是实现接口的类里此方法的异常：

@Override
	public void sleep() {
		int a = 4;
		int b = 0;
		a = a / b;
		System.out.println("睡" + a);
	}

将其稍加修改：

@Override
	public void sleep() {
		int a = 4;
		int b = 2;
		a = a / b;
		System.out.println("睡" + a);
	}

输出结果：