什么是aop面向切面编程？aop是一种编程范式，它通过将业务逻辑的各个部分隔离，从而降低了这些部分之间的耦合度，提升了程序的可重用性，并提高了开发效率。简单来说，aop允许你在不修改原始代码的情况下，向主干功能中添加新功能。例如，在登录系统中，aop可以用来添加日志记录、权限验证等功能，而无需改变登录逻辑本身。

AOP的底层原理是使用动态代理技术实现的。动态代理有两种情况：

1. JDK动态代理：适用于有接口的情况。通过创建接口实现类的代理对象来增强类的方法。

2. CGLIB动态代理：适用于没有接口的情况。通过创建子类的代理对象来增强类的方法。

AOP（JDK动态代理）使用JDK动态代理，通过Proxy类中的方法创建代理对象。

调用newProxyInstance方法，该方法有三个参数：

• 第一参数：类加载器
• 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口
• 第三参数：实现这个接口InvocationHandler，创建代理对象，写增强的部分

编写JDK动态代理代码，首先创建接口并定义方法：

package com.dance.spring.learn.proxy;
public interface UserDao {
    public int add(int a, int b);
    public String update(String id);
}

然后创建接口实现类并实现方法：

package com.dance.spring.learn.proxy.impl;
import com.dance.spring.learn.proxy.UserDao;
public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String update(String id) {
        return id;
    }
}

接着使用Proxy创建接口代理对象：

package com.dance.spring.learn.proxy;
import com.dance.spring.learn.proxy.impl.UserDaoImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class JDKProxy {
    public static void main(String[] args) {
        Class>[] classes = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao userDao1 = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), classes, new UserDaoProxy(userDao));
        int add = userDao1.add(1, 2);
        System.out.println(add);
    }
}
class UserDaoProxy implements InvocationHandler{
    private UserDao userDao;
    public UserDaoProxy(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法之前执行:"+method.getName()+",参数:"+ Arrays.toString(args));
        // 执行方法
        Object invoke = method.invoke(userDao, args);
        System.out.println("方法之后执行:返回值为:"+invoke);
        return invoke;
    }
}

执行结果：

方法之前执行:add,参数:[1, 2]
方法之后执行:返回值为:3

CGLIB动态代理（扩展知识点）：CGLIB（Code Generation Library）是一个开源项目，是一个强大、高性能、高质量的代码生成类库。它可以在运行时扩展Java类和实现Java接口。Hibernate使用它来实现持久化对象的动态生成。CGLIB通过ASM字节码处理框架来转换字节码并生成新的类。它广泛用于许多AOP框架中，如Spring AOP，用于方法拦截。脚本语言如Groovy和BeanShell也使用ASM来生成Java字节码。

如果有兴趣尝试CGLIB动态代理，可以参考以下链接：

https://www./link/5001e11e24d2f4e723a67feb678f4e27

AOP术语：

• 连接点：类中可以被增强的方法称为连接点。
• 切入点：实际被增强的方法称为切入点。如果一个类中有四个方法可以被增强，但只对其中两个进行增强，这两个方法就是切入点。
• 通知（增强）：实际增强的逻辑部分称为通知（增强）。
• 通知的类型：前置通知、后置通知、环绕通知、异常通知、最终通知。
• 切面：把通知应用到切入点的过程称为切面。

AOP操作（准备工作）：Spring框架通常基于AspectJ实现AOP操作。AspectJ不是Spring的组成部分，而是一个独立的AOP框架。通常将AspectJ和Spring框架一起使用来进行AOP操作。基于AspectJ的AOP操作可以通过XML配置文件或注解方式实现。

切点表达式：切点表达式的作用是知道对哪个类中的哪个方法进行增强。语法结构为：execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]))。例如：

• 对com.dance.spring.learn.BookDao类中的add方法进行增强：execution(* com.dance.spring.learn.BookDao.add(..))
• 对com.dance.spring.learn.BookDao类中的所有方法进行增强：execution(* com.dance.spring.learn.BookDao.*(..))
• 对com.dance.spring.learn.dao包中所有类、类中所有方法进行增强：execution(* com.dance.spring.learn.*.*(..))

AOP操作（AspectJ注解）：首先创建User类：

package com.dance.spring.learn.aop;
@Component
public class User {
    public void add(){
        System.out.println("add......");
    }
}

然后创建增强类并编写增强逻辑：

package com.dance.spring.learn.aop;
public class UserProxy {
    /**
     * 前置通知
     */
    public void before() {
        System.out.println("before......");
    }
}

进行通知的配置：

修改增强类，配置前置通知：

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

编写测试类：

@Test
public void test10(){
    ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Spring-aop.xml");
    User user = classPathXmlApplicationContext.getBean("user", User.class);
    user.add();
}

执行结果：

before......
add......

编写其他通知：

package com.dance.spring.learn.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserProxy {
    /**
     * 前置通知
     */
    @Before(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public void before() {
        System.out.println("before......");
    }
    /**
     * 后置通知（返回通知）
     */
    @AfterReturning(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }
    /**
     * 最终通知
     */
    @After(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }
    /**
     * 异常通知
     */
    @AfterThrowing(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }
    /**
     * 环绕通知
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
        return proceed;
    }
}

执行结果（使用test10进行测试）：

环绕之前.........before......add......环绕之后.........after.........afterReturning.........

异常通知只有在方法抛出异常时才会执行。手动修改代码模拟异常：

修改User类的add方法：

public void add(){
    int i = 5/0;
    System.out.println("add......");
}

再次调用test10：

环绕之前.........before......after.........afterThrowing.........

可以看到在报错后执行了异常通知，但后置通知和环绕之后的通知未执行。

注解总结：

• @Aspect：标识这是一个aspect类。
• @Before：前置通知。
• @AfterReturning：后置通知（返回通知）。
• @After：最终通知（finally）。
• @AfterThrowing：异常通知。
• @Around：环绕通知。

相同的切入点抽取：

package com.dance.spring.learn.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserProxy {
    @Pointcut(value = "execution(* com.dance.spring.learn.aop.User.add(..))")
    public void pointcut(){}
    /**
     * 前置通知
     */
    @Before(value = "pointcut()")
    public void before() {
        System.out.println("before......");
    }
    /**
     * 后置通知（返回通知）
     */
    @AfterReturning(value = "pointcut()")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }
    /**
     * 最终通知
     */
    @After(value = "pointcut()")
    public void after() {
        System.out.println("after.........");
    }
    /**
     * 异常通知
     */
    @AfterThrowing(value = "pointcut()")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }
    /**
     * 环绕通知
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "pointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
        return proceed;
    }
}

如果有多个类对同一个方法进行增强，可以设置优先级。在增强类上添加注解@Order(数字类型值)，数字越小优先级越高：

@Order(1)

完全注解开发，使用配置类替换XML：

package com.dance.spring.learn.aop.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan(basePackages = {"com.dance.spring.learn.aop"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {}

编写测试类：

@Test
public void test11(){
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(com.dance.spring.learn.aop.config.SpringConfig.class);
    User user = annotationConfigApplicationContext.getBean("user", User.class);
    user.add();
}

执行结果：

环绕之前.........before......add......环绕之后.........after.........afterReturning.........

# ai  # 权限验证  # 动态代理  # spring框架  # java接口  # Java  # spring  # hibernate  # 子类  # xml  # 接口  # finally  # 数字类型  # 对象  # https  # 类中  # 是一个  # 多个  # 适用于  # 值为  # 是一种  # 你在  # 这是一个  # 这两个 

相关栏目： 【 网站优化151355 】 【 网络推广146373 】 【 网络技术251813 】 【 AI营销90571 】

相关推荐： Laravel如何处理JSON字段的查询和更新_Laravel JSON列操作与查询技巧  Laravel如何实现用户注册和登录？（Auth脚手架指南）  HTML透明颜色代码怎么让下拉菜单透明_下拉菜单透明背景指南【技巧】  如何在HTML表单中获取用户输入并用JavaScript动态控制复利计算循环  如何快速生成专业多端适配建站电话？  如何在香港免费服务器上快速搭建网站？  Laravel中的withCount方法怎么高效统计关联模型数量  Laravel PHP版本要求一览_Laravel各版本环境要求对照  js实现点击每个li节点，都弹出其文本值及修改  专业商城网站制作公司有哪些,pi商城官网是哪个？  如何用AWS免费套餐快速搭建高效网站？  Laravel如何发送系统通知_Laravel Notifications实现多渠道消息通知  Python面向对象测试方法_mock解析【教程】  如何在Ubuntu系统下快速搭建WordPress个人网站？  网站建设要注意的标准 促进网站用户好感度！  小视频制作网站有哪些,有什么看国内小视频的网站，求推荐？  Laravel如何配置和使用队列处理异步任务_Laravel队列驱动与任务分发实例  在Oracle关闭情况下如何修改spfile的参数  大连网站制作费用,大连新青年网站，五年四班里的视频怎样下载啊？  如何快速选择适合个人网站的云服务器配置？  为什么php本地部署后css不生效_静态资源加载失败修复技巧【技巧】  Laravel如何优雅地处理服务层_在Laravel中使用Service层和Repository层  Laravel怎么做缓存_Laravel Cache系统提升应用速度的策略与技巧  网站设计制作书签怎么做,怎样将网页添加到书签/主页书签/桌面？  Laravel怎么自定义错误页面_Laravel修改404和500页面模板  Edge浏览器怎么启用睡眠标签页_节省电脑内存占用优化技巧  laravel服务容器和依赖注入怎么理解_laravel服务容器与依赖注入解析  如何快速生成凡客建站的专业级图册？  Laravel如何处理跨站请求伪造（CSRF）保护_Laravel表单安全机制与令牌校验  node.js报错：Cannot find module 'ejs'的解决办法  百度输入法ai面板怎么关 百度输入法ai面板隐藏技巧  企业网站制作这些问题要关注  Laravel如何使用Eloquent进行子查询  Laravel控制器是什么_Laravel MVC架构中Controller的作用与实践  Laravel如何使用Seeder填充数据_Laravel模型工厂Factory批量生成测试数据【方法】  如何快速辨别茅台真假？关键步骤解析  Laravel表单请求验证类怎么用_Laravel Form Request分离验证逻辑教程  如何用腾讯建站主机快速创建免费网站？  齐河建站公司：营销型网站建设与SEO优化双核驱动策略  Laravel数据库迁移怎么用_Laravel Migration管理数据库结构的正确姿势  邀请函制作网站有哪些,有没有做年会邀请函的网站啊？在线制作，模板很多的那种？  Laravel如何将应用部署到生产服务器_Laravel生产环境部署流程  浏览器如何快速切换搜索引擎_在地址栏使用不同搜索引擎【搜索】  Laravel怎么进行浏览器测试_Laravel Dusk自动化浏览器测试入门  千问怎样用提示词获取健康建议_千问健康类提示词注意事项【指南】  微信小程序 input输入框控件详解及实例（多种示例）  Laravel Eloquent性能优化技巧_Laravel N+1查询问题解决  如何获取上海专业网站定制建站电话？  清除minerd进程的简单方法  PHP怎么接收前端传的文件路径_处理文件路径参数接收方法【汇总】