前置增强、后置增强、环绕增强听起来说实话，我完全不清楚是什么意思，研究以后，发现很简单，就是对方法的增强，比如前置增强，就是我有一个方法A，但是有一些功能是通用的，我不想写到A里面，但是A方法又需要使用，这个时候就可以使用前置增强，这样每次在执行方法A之前，就会自动调用这个增强方法了。

1、增强分类

1. 前置增强：org.springframework.aop.BeforeAdvice 代表前置增强，因为spring只支持方法级的增强，所以MethodBeforeAdvice 是目前可用前置增强，表示在目标方法执行前实施增强。
2. 后置增强 ：org.springframework.aop.AfterAdvice 代表后增强，表示目标方法在执行后实施增强
3. 环绕增强 ：org.springframework.aop.MethodInterceptor 代表环绕增强，表示目标方法执行前后实施增强
4. 异常抛出增强 ：org.springframework.aop.ThrowsAdvice 代表抛出异常增强，表示目标方法抛出异常后实施增强
5. 引介增强 ：org.springframework.aop.IntroductionInterceptor 代表引介增强，表示在目标类中添加一些新的方法和属性

2 实例

1、先写一个需要被增强的方法

这里写的是A类下面的aaaa（）方法，下面将对这个方法增强

package com.bootdo.clouddocommon.advice;

public class A {
	
	 public void aaaa() {
		System.out.println("方法执行了~");
	}
	 
}

2、前置增强类

package com.bootdo.clouddocommon.advice;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

/**
 * 前置增强
 * 
 * @author Administrator
 *
 */
@Component
public class HelloBeforeAdvice implements MethodBeforeAdvice {
 
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.err.println("--------------before return----------------------------");
		System.err.println(method);
		System.err.println(args);
		System.err.println(target);
		System.err.println("--------------before return----------------------------");
	}
 
}

3、后置增强类

package com.bootdo.clouddocommon.advice;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

/**
 * 后置增强
 * 
 * @author Administrator
 *
 */
@Component
public class HelloAfterAdvice implements AfterReturningAdvice {
 
	@Override
	public void afterReturning(Object obj, Method method, Object[] args, Object target) throws Throwable {
		System.err.println("--------------after return----------------------------");
		System.err.println(obj);
		System.err.println(method);
		System.err.println(args);
		System.err.println(target);
		System.err.println("--------------after return----------------------------");
	}
 
}

4、环绕增强类

package com.bootdo.clouddocommon.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.stereotype.Component;

@Component
public class HelloAroundAdvice implements MethodInterceptor {
 
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		before();
		Object result = invocation.proceed();
		after();
		System.out.println("arround");
		return result;
	}
 
	private void after() {
		System.out.println("after");
	}
 
	private void before() {
		System.out.println("before");
	}
 
}

5、对方法aaaa进行增强并测试类

package com.bootdo.clouddocommon.advice;

import org.springframework.aop.framework.ProxyFactory;


public class Client {
	public static void main(String[] args) {
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(new A());
 
		// 1.分别 添加前置增强 、后置增强
		proxyFactory.addAdvice(new HelloBeforeAdvice());
		proxyFactory.addAdvice(new HelloAfterAdvice());
		// 3.环绕增强
		proxyFactory.addAdvice(new HelloAroundAdvice());
 
		// 2.同时 实现前置增强、后置增强
		// proxyFactory.addAdvice(new HelloBeforeAfterAdvice());
 
		
		// proxyFactory.addAdvice(new HelloAroundAdvice());
		// proxyFactory.addAdvice(new HelloThrowAdvice());
		A a = (A) proxyFactory.getProxy();
		a.aaaa();  
	}
 
}

proxyFactory.addAdvice 将增强类 放到代理类中，然后调用即可实现
以下是执行结果截图：

异常抛出增强和引介增强同理

总结：以上代码看起来还是挺简单的，但个人觉得还是没有直接切入方便，但这种方法也有这种方式的好处吧，就跟自定义注解一样，有些地方需要用到，有些地方不需要用到，需要用的地方就增强，不需要用的地方就不增强。

此文章是基于demo写的，感兴趣的可以下载运行看看。
下载地址：https://download.csdn.net/download/qq_28483283/11233595
前端是vue写的，后端是springboot+springcloud
ps:本来不想要设置下载积分的，可是csdn强制要5积分，我也很无奈.

Spring核心技术：AOP面向切面

所谓的面向切面编程，是一种通过预编译和运行期动态代理的方式，实现在不修改源代码的情况下给程序动态添加功能的技术。
面向对象的延续，Spring框架的重要内容，是函数式编程的一种衍生泛型。
利用AOP可以对业务逻辑各部分之间耦合度降低，提高程序的重用性，提高开发效率。

AOP的原理：(1)将复杂的需求分解出不同的方面，将散布在系统中的公共功能集中解决。
		  (2)采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能。
		  
AOP相关术语：
通知(advice):增强的方法,通知就是在切面的某个连接点上执行的操作，也就是事务管理，日志管理，权限管理等；
切入点(PointCut):已经被增强的链接点，切入点就是描述某一类选定的连接点，也就是指定某一类要织入通知的方法。
连接点(Joinpoint):指哪些方法可能被增强，程序执行时的某个特定的点，在Spring中就是一个方法的执行。
切面(Aspect):是切入点PointCut和通知advice的一个结合，切面就是一个关注点的模块化，如事务管理，日志管理，权限管理等。
目标对象(target):需要被代理的类(Service),一般指的是业务层的类，就是被AOP动态代理的目标对象。
AOP代理(proxy):代理类
织入(Weaving):是指把增强advice应用到目标对象target中来创建新的代理对象proxy的过程。

面向切面编程：从系统中分离出切面，独立于业务逻辑（service）实现，在程序“执行时”织入程序中运行（在什么位置，执行什么功能）
配置AOP主要使用aop命名空间下的元素完成，可以实现定义切入点和织入增强等操作

实现方式

（1）导入命名空间

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
	   http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

</beans>

（2）将增强类转换为Bean的增强类

public class UserServiceLogger {
    private static Logger log = Logger.getLogger(UserServiceLogger.class);
    //前置增强 JoinPoint:目标方法的类名  方法名 参数列表...
    public void before(JoinPoint jp) {
        log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().
                getName() + " 方法。方法入参：" + Arrays.toString(jp.getArgs()));
    }

    //后置增强 JoinPoint:目标方法的类名   方法名 参数列表...
    //result 获取目标 方法的返回值
    public void afterReturning(JoinPoint jp, Object result) {
        log.info("调用 " + jp.getTarget() + " 的 " + jp.getSignature().
                getName() + " 方法。方法返回值：" + result);
    }
}

增强类

<!--增强类-->
<bean id="userServiceLogger" class="org.westos.demo.aop.UserServiceLogger">
</bean>

（3）配制文件：Application.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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
	   http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

    <!--增强类-->
    <bean id="userServiceLogger" class="com.xk.demo.aop.UserServiceLogger"></bean>
   
    <!--切入点 规则
        public * addNewUser(entity.User)： “*”表示匹配所有类型的返回值。
        public void *(entity.User)： “*”表示匹配所有方法名。
        public void addNewUser(..)： “..”表示匹配所有参数个数和类型。
        * com.service.*.*(..)：匹配com.service包下所有类的所有方法。
        * com.service..*.*(..)：匹配com.service包及其子包下所有类的所有方法-->

    <!--切面-->
    <aop:config>
        <!--切入点：PointCut-->
        <!--expression="execution(访问修饰符 返回值类型 方法名( 包名.类名( 参数 )  ))" -->
        <!--   .. 任何参数   -->
        <!-- org.westos.demo.service.*.*  第一个* 表示所有类  第二个*所有方法   -->
        <aop:pointcut id="pointcut" expression="execution(* org.westos.demo.service.*.*(..))"/>
            <!-- 可以有很多个增强类  使用哪一个增强类  增强取决于 aop:aspect ref ="bean id"-->
            <aop:aspect ref="userServiceLogger">
                <!-- aop:before： 固定格式  前置增强   -->
                <!-- method 方法名称  （来自增强类） -->
                <!-- pointcut-ref  切入点名称 aop:pointcut id="pointcut" -->
                <aop:before method="before" pointcut-ref="pointcut"></aop:before>

                <!-- aop:after-returning： 固定格式  后置增强   -->
                <!-- method 方法名称  （来自增强类） -->
                <!-- pointcut-ref  切入点名称 aop:pointcut id="pointcut" -->
                <!-- returning 有返回值参数   （来自增强类） -->
                <aop:after-returning method="afterReturning" 
                 		pointcut-ref="pointcut" returning="result"/>
            </aop:aspect>
    </aop:config>

</beans>

测试类

public class TestUser {
    @Test
    public void testUser(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        /*转换为 接口 接口 接口 UserService*/
        UserService userService = (UserService) applicationContext.getBean("userService");

        int row = userService.addUser(new User("admin", "张三", "123456"));
        System.out.println(row==1?"成功":"失败");
    }
}