Spring笔记3（AOP面向切面）

AOP 面向切面

1、 AOP概念

面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（也就是不通过修改源代码的方式，在主干功能添加新的功能）

2、 AOP底层原理

1） AOP底层原理使用动态代理，两种情况的动态代理：

a.	有接口情况，使用jdk动态代理
b.	没有接口情况，使用cglib代理

3、 AOP术语

Class User{
	Add(){}
	Update(){}
	Delete(){}
	Select(){}
}

1） 连接点：类里的那些可以被功能增强的方法都被称为连接点
2） 切入点：实际真正被增强的方法，叫做切入点
3） 通知（增强）
实际增强的部分称为通知
登录后加的权限判断就叫做通知
通知类型：
a. 前置通知 被增强方法之前执行
b. 后置通知 被增强的方法之后执行
c. 环绕通知 被增强的方法前后都执行
d. 异常通知 被增强的方法出现异常执行
e. 最终通知 永远会执行 （try{}， catch{}， finally{}）
4)切面
把通知应用到切入点过程（把权限判断功能加入到登录方法过程）

4、 AOP操作（准备）

1） aspectJ实现aop
什么是aspectJ?
aspectJ不是spring组成部分，是独立的aop框架，一般吧aspectJ和spring框架一起使用，进行aop操作
2） 基于xml配置，基于注解配置
3） 引入依赖
4） 切入点表达式：
a. 根据切入点表达式，知道对哪个类里的哪个方法进行增强
b. 语法结构
execution(【权限修饰符】【返回类型类】【全路径】【方法名称】(参数列表))
例1：对com.spring.dao BookDao的add方法进行增强

Execution(*  com.spring.dao. BookDao.add(..))

例2：对com.spring.dao BookDao的所有方法进行增强

Execution(* com.spring.dao. BookDao.*(..))

例3：对com.spring.dao包里的所有类的所有方法进行增强

Execution(* com.spring.dao.*.*(..))

5、 AOP操作（aspectJ注解）

1）创建类，在类中定义方法（被增强类、被增强方法）

//被增强类
public class User {
//被增强方法
public void add(){
	System.out.println("======add=======");
	}
}

2） 创建一个增强类，增强方法

//增强类
public class UserProxy {
//增强方法
public void before(){
	System.out.println("=======before=======");
	}
}

3） 进行通知配置
A) 在spring配置文件中，开启注解扫描
引入context、aop名称空间

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-3.0.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">

<!-- 开启注解扫描 -->
<context:component-scan base-package="com.spring.aop"></context:component-scan>

B)使用注解创建增强对象和被增强对象

   //被增强类
@Component
public class User {
//被增强方法
public void add(){
	System.out.println("======add=======");
	}
}

//增强类
@Component
public class UserProxy {

//增强方法
public void before(){
	System.out.println("=======before=======");
	}
}

C)在增强类上@Aspect生成代理对象

//增强类
@Component
@Aspect
public class UserProxy {

//增强方法
public void before(){
	System.out.println("=======before=======");
	}
}

D)在spring配置文件中开启生成代理对象

<!-- 开启aspectJ生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4)配置不同类型的通知
在增强类中，在作为通知方法上面添加通知类型注解，使用切入点配置

//前置通知
@Before(value=“execution(* com.spring.aop.User.add(…))”)
public void before(){
System.out.println("=before=");
}

@After(value="execution(* com.spring.aop.User.add(..))")
public void After(){
	System.out.println("=======After=======");
}

@AfterReturning(value="execution(* com.spring.aop.User.add(..))")
public void AfterReturning(){
	System.out.println("=======AfterReturning=======");
}

@AfterThrowing(value="execution(* com.spring.aop.User.add(..))")
public void AfterThrowing(){
	System.out.println("=======AfterThrowing=======");
}

//环绕通知
@Around(value="execution(* com.spring.aop.User.add(..))")
public void Around(ProceedingJoinPoint point) throws Throwable{
	System.out.println("=======环绕之前=======");
	
	//执行被增强方法
	point.proceed();
	
	System.out.println("========环绕之后========");
}

@After:最终通知，在被增强方法执行之后执行，不管有没有异常都执行
@afterReturning：后置通知（返回通知），在返回值之后执行，有异常不执行
@AfterThrowing：异常通知

5)相同切入点抽取
切入点表达式都一样

//切入点抽取
@Pointcut(value="execution(* com.spring.aop.User.add(..))")
public void pointdemo(){
	
}

//增强方法
//前置通知
@Before(value="pointdemo()")
public void before(){
	System.out.println("=======before=======");
}

@After(value="pointdemo()")
public void After(){
	System.out.println("=======After=======");
}

@AfterReturning(value="pointdemo()")
public void AfterReturning(){
	System.out.println("=======AfterReturning=======");
}

@AfterThrowing(value="pointdemo()")
public void AfterThrowing(){
	System.out.println("=======AfterThrowing=======");
}

//环绕通知
@Around(value="pointdemo()")
public void Around(ProceedingJoinPoint point) throws Throwable{
	System.out.println("=======环绕之前=======");
	
	//执行被增强方法
	point.proceed();
	
	System.out.println("========环绕之后========");
}

6)如果有多个增强类对同一个方法进行增强，设置增强类的优先级
@Order(数字类型值)，值越小优先级越高

//第二个增强类
@Component
@Aspect
@Order(0)
public class PersonProxy {

//前置通知
@Before(value="execution(* com.spring.aop.User.add(..))")
public void before(){
	System.out.println("=======person before=======");
}

}