Spring5框架基础详解(四) （AOP概念、AOP术语、AOP底层原理、JDK动态代理实现、AOP操作）
文章目录
- 一、什么是AOP
- 二、AOP术语
- 三、AOP底层原理
- 四、AOP（JDK动态代理实现）
- 五、AOP操作
-
- 5.1AOP操作（基于AspectJ注解方式）
- 5.2完全注解开发
一、什么是AOP
面向切面编程，不通过修改源代码方式，在主干功能里面添加新功能。
二、AOP术语
1.连接点:类里面哪些方法可以被增强，这些方法称为连接点
2.切入点:实际被真正增强的方法，称为切入点
3.通知（增强）:
(1)实际增强的逻辑部分称为通知（增强）
(2)通知有多种类型
*前置通知
*后置通知
*环绕通知
*异常通知
*最终通知
4.切面：是动作，把通知应用到切入点的过程。
三、AOP底层原理
1.AOP底层使用动态代理
*1.有两种情况的动态代理
（1）有接口的情况,使用JDK动态代理：创建接口实现类的代理对象，来增强类的方法。
（2）没有接口的情况，使用CGLIB动态代理：创建子类的代理对象，增强类的方法。
四、AOP（JDK动态代理实现）
1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象。
*1.调用newProxyInstance方法,方法中有三个参数:
第一参数，类加载器；
第二参数，增强方法所在的类，这个类实现的接口，支持多个接口；
第三参数，实现接口IncocationHandler，创建代理对象，写增强的方法。
步骤如下：
*1.创建接口，定义方法：
public interface UserDao {
public int add(int a,int b);
public String update(String id);
}
*2.创建接口实现类，实现方法：
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
return a+b;
}
@Override
public String update(String id) {
return id;
}
}
*3.使用Proxy类创建接口代理对象
package cn.hncj.dao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
* Created on 2022/3/21.
*
* @author Hou chaof
*/
public class JDKProxy {
public static void main(String[] args) {
//创建接口实现类代理对象
Class[] interfaces={UserDao.class};
UserDaoImpl userDao=new UserDaoImpl();
var dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProcxy(userDao));
int result = dao.add(1, 2);
System.out.println("result："+result);
}
}
//创建代理对象代码
class UserDaoProcxy implements InvocationHandler{
//1.把创建的是谁的代理对象，就把谁传递过来
//有参数构造传递
private Object obj;
public UserDaoProcxy(Object obj){
this.obj=obj;
}
//增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前处理
System.out.println("方法之前执行..."+method.getName()+":传递的参数..."+ Arrays.toString(args));
//被增强的方法执行
Object res = method.invoke(obj, args);
//方法之后处理
System.out.println("方法之后执行"+obj);
return res;
}
}
package cn.hncj.dao;
/**
* Created on 2022/3/21.
*
* @author Hou chaof
*/
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
System.out.println("add方法执行了");
return a+b;
}
@Override
public String update(String id) {
System.out.println("update方法执行了");
return id;
}
}
package cn.hncj.dao;
/**
* Created on 2022/3/21.
*
* @author Hou chaof
*/
public interface UserDao {
public int add(int a,int b);
public String update(String id);
}
五、AOP操作
1.Spring框架一般都是基于AspectJ实现AOP操作。
(1) AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。
2.基于AspectJ实现AOP操作
（1）基于xml配置文件实现
（2）基于注解方式实现（使用）
3.在项目工程中引入AOP依赖
4. 切入点的表达式
*切入点表达式作用：知道对哪个类里面的哪个方法进行增强
*语法：execution([权限修饰符][返回类型][类的全限定路径][方法名称]([参数列表]))
*例1：对cn.hncj.dao.BookDao类里面的add方法进行增强
切入点表达式：execution(* cn.hncj.dao.BookDao.add(..))
*例2：对cn.hncj.dao.BookDao类里面的所有方法进行增强
切入点表达式：execution(* cn.hncj.dao.BookDao.*(..))
*例3：对cn.hncj.dao包里面的所有类，类里所有方法进行增强
切入点表达式：execution(* cn.hncj.dao.*.*(..))
5.1AOP操作（基于AspectJ注解方式）
步骤1.*创建类，在类里面定义方法
//被增强类
public class User {
public void add(){
System.out.println("add..");
}
}
步骤2.*创建增强类（编写增强逻辑）
（1）在增强类里面，创建方法，让不同方法代表不同通知类型。
//增强类
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
}
步骤3.*进行通知的配置
（1）在spring配置文件中，开启注解扫描
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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="cn.hncj.aopanno">context:component-scan>
beans>
（2）使用注解创建User和UserProxy对象
@Component
public class User{
}
@Component@
public class UserProxy {
}
（3）在增强类上面添加注解@Aspect
@Component@Aspect
public class UserProxy {
（4）在spring配置文件中开启生成代理对象
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
步骤4.*配置不同类型的通知
（1）在增强类的里面，在作为通知方法上面添加通知类注解，使用切入点表达式配置
//增强类
@Component@Aspect
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void before(){
System.out.println("before...");
}
}
完整代码如下：
package cn.hncj.aopanno;
import org.springframework.stereotype.Component;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
//被增强类
@Component
public class User {
public void add(){
System.out.println("add..");
}
}
package cn.hncj.aopanno;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
//增强类
@Component
@Aspect
public class UserProxy {
//前置通知
//@Before注解表数据作为前置通知
@Before(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void before() {
System.out.println("before...");
}
//后置通知（返回通知） 有异常，不通知
@AfterReturning(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterreturning...");
}
//异常通知
@AfterThrowing(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("afterthrowing...");
}
//最终通知 有异常也通知
@After(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//环绕通知
@Around(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
import cn.hncj.aopanno.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
public class TestAop {
@Test
public void test() {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean("user", User.class);
user.add();
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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="cn.hncj.aopanno">context:component-scan>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>
相同切入点抽取
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void pointdemo(){
}
//前置通知
//@Before注解表数据作为前置通知
@Before(value = "pointdemo()")
public void before() {
System.out.println("before...");
}
有多个增强类对同一个方法进行增强，设置增强类优先级。
*1.在增强类上面添加注解@Order(数字类型值)，数字类型的值越小，优先级越高
package cn.hncj.aopanno;
import org.springframework.stereotype.Component;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
//被增强类
@Component
public class User {
public void add(){
System.out.println("add..");
}
}
package cn.hncj.aopanno;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.junit.jupiter.api.Order;
import org.springframework.stereotype.Component;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
@Component
@Aspect
@Order(1)
public class PersonProxy {
//前置通知
@Before(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void before(){
System.out.println("Person before...");
}
}
package cn.hncj.aopanno;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.junit.jupiter.api.Order;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
//增强类
@Component
@Aspect
@Order(3)
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void pointdemo(){
}
//前置通知
//@Before注解表数据作为前置通知
@Before(value = "pointdemo()")
public void before() {
System.out.println("before...");
}
//后置通知（返回通知） 有异常，不通知
@AfterReturning(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterreturning...");
}
//异常通知
@AfterThrowing(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("afterthrowing...");
}
//最终通知 有异常也通知
@After(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//环绕通知
@Around(value = "execution(* cn.hncj.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
import cn.hncj.aopanno.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
public class TestAop {
@Test
public void test() {
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean("user", User.class);
user.add();
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.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="cn.hncj.aopanno">context:component-scan>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>
5.2完全注解开发
（1）创建配置类，不需要创建xml配置文件
package cn.hncj.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
@Configuration
@ComponentScan(basePackages = {"cn.hncj.aopanno"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
//测试类
import cn.hncj.aopanno.User;
import cn.hncj.config.ConfigAop;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created on 2022/3/22.
*
* @author Hou chaof
*/
public class TestAop {
@Test
public void test() {
ApplicationContext context=new AnnotationConfigApplicationContext(ConfigAop.class);
User user = context.getBean("user", User.class);
user.add();
}
}