Spring框架教程（四）：AOP面向切面编程

一、AOP概述

1.什么是AOP

• AOP翻译过来是面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。
• 通俗地讲，要往一个主干功能添加新的功能，不修改源代码，而是将新功能独立成一个模块。

2.底层原理(动态代理)

• 第一种：有接口，使用JDK的动态代理

  比如，我们有一个UserDao类接口和UserDaoImpl实现类，如下：

	interface UserDao{
    
    
		void login();
	}

	public class UserDaoImpl implements UserDao{
    
    
		public void login(){
    
    
			//登录实现过程
		}
	}

  JDK动态代理的工作原理是：创建UserDao接口实现类的代理对象，通过代理对象来增强接口的方法。

• 第二种：无接口，使用CGLIB的动态代理

  比如，我们有一个User类，如下：

	class User{
    
    
		public void add(){
    
    
			...
		}
	}

  CGLIB动态代理的工作原理是：创建User类的一个子类的代理对象，通过代理对象来增强接口的方法。

3.AOP的操作术语

• 连接点：类中哪些方法可以被增强，这些方法称为连接点。
• 切入点：实际真正被增强的方法。
• 通知(增强)：实际增强的逻辑的部分，比如日志、权限判断，通知分为前置通知、后置通知、环绕通知、异常通知、最终通知。
• 切面：把通知应用到切入点的过程。

二、AOP操作-准备工作

  Spring框架一般都是基于AspectJ实现AOP操作。AspectJ不是Spring的组成部分，而是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

  基于AspectJ实现AOP操作：基于xml配置文件、基于注解(常用)。

• 导入依赖：

  除了前面几个jar包，还需要几个别的jar包：

  spring-aspects-5.2.6.RELEASE.jar(spring-framework-5.2.6.RELEASE文件夹中能找到)
  com.springsource.net.sf.cglib-2.2.0.jar
  com.springsource.org.aopalliance-1.0.0.jar
  com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

• 搞懂切入点表达式：

  execution([权限修饰符][返回类型][类全路径][方法名称][([参数路径]))

  举例1 对com.wang.dao.BookDao里面的add方法进行增强：excution(*com.wang.dao.BookDao.add(…))，第一个星号表示所有权限，省略了返回类型，参数列表用两个点代替。

  举例2 对com.wang.dao.BookDao里面的所有方法进行增强：excution(* com.wang.dao.BookDao. * )。

  举例3 对com.wang.dao.BookDao里面的所有类的所有方法进行增强：excution(* com.wang.dao.*. * )。

三、AspectJ注解

1.基本步骤

  打开已经导入好依赖的项目spring5_demo1。

(1)创建类，并在类中定义方法

  在com.wang包下新建aspectJ包，用来存放一些类，用来对这一章内容进行学习。创建Family类，如下：

	package com.wang.aspectJ;
	import org.springframework.stereotype.Component;
	
	@Component
	public class Family {
    
    
	    public void add(){
    
    
	        System.out.println("add...family...");
	    }
	}

(2)创建增强类

  创建Family类的增强类FamilyProxy，如下：

	package com.wang.aspectJ;
	
	import org.aspectj.lang.annotation.Aspect;
	import org.springframework.stereotype.Component;
	
	@Component
	@Aspect
	public class FamilyProxy {
    
    
	}

(3)进行通知的配置

• 开启注解扫描：通过xml配置文件(还需要配置context、aop名称空间)、或者直接用配置类。注意，xml文件必须放在src下，而不能放在com.wang下，会报错。
• 使用注解创建Family和FamilyProxy对象，我是用的是@Component。
• 在增强类FamilyProxy上添加注解@Aspect。
• 在spring配置文件中开启生成代理对象，如下：

	<!--开启Aspect生成代理对象
    将加了@Aspect注解的类生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

(4)配置不同类型的通知

  在增强类里，在相应的通知方法上添加响应注解，并使用切入表达式，完善后的增强类如下：

	package com.wang.aspectJ;
	import org.aspectj.lang.ProceedingJoinPoint;
	import org.aspectj.lang.annotation.*;
	import org.springframework.stereotype.Component;
	
	@Component
	@Aspect
	public class FamilyProxy {
    
    
	    //事前通知：执行顺序2
	    @Before(value = "execution(* com.wang.aspectJ.Family.add(..))")
	    public void before(){
    
    
	        System.out.println("事前通知...");
	    }
	
	    //环绕通知
	    @Around(value = "execution(* com.wang.aspectJ.Family.add(..))")
	    public void around(ProceedingJoinPoint p) throws Throwable{
    
    
	        System.out.println("环绕之前...");//执行顺序1
	        p.proceed(); //被增强的方法执行：执行顺序3
	        System.out.println("环绕之后...");//执行顺序4
	
	    }
	
	    //最终通知：执行顺序5，方法执行后执行
	    @After(value = "execution(* com.wang.aspectJ.Family.add(..))")
	    public void after(){
    
    
	        System.out.println("最终通知...");
	    }
	
	    //异常通知：发生异常时执行
	    @AfterThrowing(value = "execution(* com.wang.aspectJ.Family.add(..))")
	    public void afterThrowing(){
    
    
	        System.out.println("异常通知...");
	    }
	
	    //后置(返回)通知：执行顺序6，返回值之后执行，有异常时不执行
	    @AfterReturning(value = "execution(* com.wang.aspectJ.Family.add(..))")
	    public void afterReturning(){
    
    
	        System.out.println("后置通知...");
	    }
	}

(5)最后测试一下

	@Test
    public void testFamily(){
    
    
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Family family=context.getBean("family",Family.class);

        System.out.println(family);
        family.add();
    }

2.公共切入点抽取

	package com.wang.aspectJ;
	import org.aspectj.lang.ProceedingJoinPoint;
	import org.aspectj.lang.annotation.*;
	import org.springframework.stereotype.Component;
	
	@Component
	@Aspect
	public class FamilyProxy {
    
    
	    //切入点抽取
	    @Pointcut(value="execution(* com.wang.aspectJ.Family.add(..))")
	    public void point(){
    
    }
	
	    //事前通知：执行顺序②
	    @Before(value = "point()")
	    public void before(){
    
    
	        System.out.println("事前通知...");
	    }
	
	    //环绕通知
	    @Around(value = "point()")
	    public void around(ProceedingJoinPoint p) throws Throwable{
    
    
	        System.out.println("环绕之前...");//执行顺序①
	        p.proceed(); //被增强的方法执行：执行顺序③
	        System.out.println("环绕之后...");//执行顺序④
	
	    }
	
	    //最终通知：执行顺序⑤，方法执行后执行
	    @After(value = "point()")
	    public void after(){
    
    
	        System.out.println("最终通知...");
	    }
	
	    //异常通知：发生异常时执行
	    @AfterThrowing(value = "point()")
	    public void afterThrowing(){
    
    
	        System.out.println("异常通知...");
	    }
	
	    //后置(返回)通知：执行顺序⑥，返回值之后执行，有异常时不执行
	    @AfterReturning(value = "point()")
	    public void afterReturning(){
    
    
	        System.out.println("后置通知...");
	    }
	}

3.多个增强类对同一个方法增强，设置增强类优先级

  在增强类上面添加注解@Order(数字类型值)，值越小优先级越高。

四、AspectJ配置文件

1.创建类和增强类

  在aspectJ包中创建City类和CityProxy类，如下：

	package com.wang.aspectJ;
	
	public class City {
    
    
	    public void add(){
    
    
	        System.out.println("city add...");
	    }
	}
	
	public class CityProxy {
    
    
	    public void before(){
    
    
	        System.out.println("before...");
	    }
	}

2.在spring配置文件中创建两个类对象

  为了与前面的内容相分开，我又创建了一个新的xml配置文件。

• 引入名称空间aop。
• 创建两个类的对象：

	<!--创建City类和CityProxy类的对象-->
    <bean id="city" class="com.wang.aspectJ.City"></bean>
    <bean id="cityProxy" class="com.wang.aspectJ.CityProxy"></bean>

3.在spring配置文件中配置切入点

	<!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p1" expression="execution(* com.wang.aspectJ.City.add(..))"/>
        <!--切面-->
        <aop:aspect ref="cityProxy">
            <!--具体的增强-->
            <aop:before method="before" pointcut-ref="p1"/>
        </aop:aspect>
    </aop:config>

4.测试

  测试方法自己写吧，执行结果如下：

五、纯注解开发

  这里再展示一下AOP的配置类怎么写，如下：

	package com.wang.config;
	
	import org.springframework.context.annotation.ComponentScan;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.EnableAspectJAutoProxy;
	
	@Configuration
	@ComponentScan(basePackages = {
    
    "com.wang"}) //开启注解扫描
	@EnableAspectJAutoProxy(proxyTargetClass = true) //开启@Aspect生成代理对象
	public class ConfigAop {
    
    
	}