Spring AOP

最新推荐文章于 2024-11-13 17:07:29 发布
最新推荐文章于 2024-11-13 17:07:29 发布
阅读量87 收藏
点赞数 1
分类专栏： java 文章标签： spring html5 html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61211769/article/details/120166183
版权

1、AOP（面向切面编程）

1.1、作用：

        AOP 主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用

1.2、特点：

  • 降低模块与模块之间的耦合度，提高业务代码的聚合度（高内聚低耦合）

  • 提高了代码的复用性

  • 提高系统的扩展性（高版本兼容低版本）

  • 可以在不影响原有的功能基础上添加新的功能   

1.3、底层实现：

        动态代理（JDK + CGLIB）

1.4、基本概念：

  • Joinpoint（连接点）：目标对象的所有方法
  • Pointcut（切入点）：与表达式匹配的方法
  • Advice（通知）：
    • 前置通知（前置增强）before() ：执行方法前通知
    • 返回通知（返回增强）afterReturn：方法正常结束返回后的通知
    • 异常抛出通知（异常抛出增强）：afetrThrow()
    • 最终通知  after：无论方法是否发生异常，均会执行该通知
    • 环绕通知 around：包围一个连接点（joinpoint）的通知，如方法调用
  • Aspect（切面）：切入点和通知的抽象
  • Target（目标对象）：被代理的目标对象
  • Weave（织入）：将切面应用到目标对象并生成代理对象的这个过程
  • Introduction（引入）：在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程

2、Spring AOP 的实现

2.1、环境搭建

2.1.1、引入依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.9</version>
</dependency>

2.1.2、添加 spring.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: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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--  开启扫描  -->
    <context:component-scan base-package="com.yjxxt"/>

    <!--  开启注解开发 aop  -->
    <aop:aspectj-autoproxy/>

</beans>

2.2、注解实现

2.2.1、类

public class User {
    private Integer id;
    private String name;
    private String password;

    public User() {}

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

2.2.2、mapper 层

public interface UserDao {
    public int insertUser(User user);
    public int deleteUserById(Integer id);
    public int updateUser(User user);
}

@Repository
public class UserDaoImpl implements UserDao {

    @Override
    public int insertUser(User user) {
        System.out.println("insertUser.....");
        return 1;
    }

    @Override
    public int deleteUserById(Integer id) {
        System.out.println("deleteUserById.....");
        return 1;
    }

    @Override
    public int updateUser(User user) {
        System.out.println("updateUser.....");
        return 1;
    }
}

2.2.3、service 层

public interface UserService {
    public int addUser(User user);
    public int removeUserById(Integer id);
    public int changeUser(User user);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    public UserDao userDao;

    @Override
    public int addUser(User user) {
        System.out.println("UserService addUser.....");
        return userDao.insertUser(user);
    }

    @Override
    public int removeUserById(Integer id) {
        return userDao.deleteUserById(id);
    }

    @Override
    public int changeUser(User user) {
        return userDao.updateUser(user);
    }
}

2.2.4、controller

@Controller
public class UserController {

    @Autowired
    public UserService userService;

    public void add(){
        int i = userService.addUser(new User());
        if (i == 1) {
            System.out.println("添加成功！");
        }
    }
}

2.2.5、aop 层

@Component
@Aspect
public class LogerPage {

    // 切点
    @Pointcut(value = "execution(* com.yjxxt.service.UserServiceImpl.addUser(..))")
    public void cut(){
    }

    @Before(value = "cut()")
    public void addlog1(){
        System.out.println(new Date().toLocaleString());
    }

    // 切面
    @After(value = "execution(* com.yjxxt.service.UserServiceImpl.addUser(..))")
    public void addlog2(){
        System.out.println(new Date().toLocaleString());
    }
}

2.2.6、测试

public class Test01 {

    @Test
    public void test01(){
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        UserController uc = app.getBean("userController", UserController.class);
        uc.add();
    }
}

2、代理模式

2.1、静态代理

2.1.1、静态代理的三要素：

  • 有共同的行为 ——> 接口

  • 目标角色 ——> 实现行为

  • 代理角色 ——> 实现行为，增强目标对象行为

2.1.2、静态代理的特点

  • 目标角色固定

  • 在应用程序执行前就得到目标角色

  • 代理对象会增强目标对象的行为

  • 有可能存在多个代理引起 "类爆炸"（缺点）

2.1.3、静态代理的实现（需实现接口）

        定义行为（接口）

public interface Marray {

    public void toMarray();

}

        目标对象

public class You implements Marray{

    @Override
    public void toMarray() {
        System.out.println("我要结婚了！！！");
    }
}

        代理对象

public class CompProxy implements Marray {

    // 目标对象
    public Marray marray;

    public CompProxy(Marray marray) {
        this.marray = marray;
    }

    @Override
    public void toMarray() {
        // 前置增强
        before();
        // 调用目标对象的方法
        marray.toMarray();
        // 后置增强
        after();
    }

    public void before(){
        System.out.println("准备婚礼！！！");
    }

    public void after(){
        System.out.println("洞房花烛！！！");
    }
}

        测试

public class Test01 {

    @Test
    public void test01(){
        // 实例化目标对象
        You you = new You();
        // 实例化代理对象
        CompProxy proxy = new CompProxy(you);
        // 代理对象执行目标对象的方法
        proxy.toMarray();
    }
}

2.2、动态代理

2.2.1、动态代理的特点：

  • 目标对象不固定

  • 在应用程序执行时动态创建目标对象

  • 代理对象会增强目标对象的行为

2.2.2、 JDK 动态代理（有接口实现）

public class JdkHanlder implements InvocationHandler {

    // 目标对象
    private Object target;

    public JdkHanlder(Object target) {
        this.target = target;
    }

    /**
     * 调用目标对象的方法，增强目标对象的行为
     * @param proxy 调用该方法的代理实例
     * @param method 目标对象的方法
     * @param args 目标对象的方法形参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("before");
        // 通过反射执行目标对象的方法
        Object result = method.invoke(target, args);
        // 后置增强
        System.out.println("after");
        return result;
    }

    /**
     * 获取动态代理对象
     * @return
     */
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}
public class Test02 {

    @Test
    public void test02(){

        // 实例化目标对象
        You you = new You();
        // 实例化代理对象
        JdkHanlder jdkHanlder = new JdkHanlder(you);
        // 动态的获取代理对象
        Marray proxy = (Marray) jdkHanlder.getProxy();
        // 代理对象执行目标对象的方法
        proxy.toMarray();
    }
}

2.2.3、CGLIB 动态代理

        引入依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

        定义类

public class User {
    public void add(){
        System.out.println("我要增强.....");
    }
}

 

public class CglibProxy implements MethodInterceptor {

    // 目标对象
    private Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    /**
     * 调用目标对象的方法，增强目标对象的行为
     * @param o 由 CGLib 动态生成的代理实例
     * @param method 实体类所调用的被代理的方法引用
     * @param objects 参数值列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 前置增强
        System.out.println("before");
        // 通过反射执行目标对象的方法
        Object result = methodProxy.invoke(target, objects);
        // 后置增强
        System.out.println("after");
        return result;
    }

    public Object getProxy(){
        // 实例化对象
        Enhancer enhancer = new Enhancer();
        // 将目标对象作为父类
        enhancer.setSuperclass(target.getClass());
        // 设置拦截器 回调对象为本身对象
        enhancer.setCallback(this);
        // 生成一个代理类对象，并返回
        return enhancer.create();
    }
}
public class Test03 {

    @Test
    public void test03(){
        // 实例化目标对象
        User user = new User();
        // 实例化代理对象
        CglibProxy cglibProxy = new CglibProxy(user);
        // 动态的获取代理对象
        User proxy = (User) cglibProxy.getProxy();
        // 代理对象执行目标对象的方法
        proxy.add();
    }
}

SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP全面详解(超级详细)
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
Spring AOP 详解
2301_80035594的博客
10-19 3631
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP详解
这河里吗l的博客
06-17 1434
AOP(Aspect-Oriented Programming)面向切面编程，作为面向对象的一种补充，将公共逻辑（事务管理、日志、缓存等）封装成切面，跟业务代码进行分离，可以减少系统的重复代码和降低模块之间的耦合度，并有利于未来的可拓展性和可维护性。
spring aop详解
hanbin1998的博客
04-13 6317
1.前言 spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。 2.概念 Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。 2.1 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，工作中做的最多的
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 3019
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
spring aop参数传递
weixin_43931625的博客
04-23 2767
spring aop参数传递
Spring AOP底层原理、注解和代码样例
热门推荐
用文字记录下每一个瞬间的感动和每一次思考的火花
03-11 11万+
Spring AOP是面向切面编程的一种实现，它允许开发者将横切关注点（如日志、事务管理等）与业务逻辑分离，从而提高代码的模块化和可维护性。在底层，Spring AOP主要通过Java的动态代理机制实现，对于实现了接口的类，它使用JDK动态代理；对于没有实现接口的类，则使用CGLIB代理。连接点（Join Point）表示“在哪里干”；只支持方法执行作为连接点；所有类的所有方法均可以作为连接点。切点（Pointcut）“在哪里干”的集合；
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
spring-security（记住密码，CSRF）
2302_79087378的博客
11-10 620
PersistentTokenRepository实现类InMemoryTokenRepositoryImpl基于内存实现JdbcTokenRepositoryImpl基于数据库实现@Bean。
SpringBoot(五)
最新发布
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 662
Rest请求处理
spring -第十四章 spring事务
m0_74606902的博客
11-11 793
要在spring中实现事务有两种方式编程式事务：编写代码手动的开启、提交、回滚事务。声明式事务：使用注解或xml配置文件进行事务管理。
基于Java+SpringBoot在线考试系统
源码好优多
11-12 332
项目编号：springbootA004传统的教育方式受限于时间和空间，无法满足人们的灵活学习需求。而在线教育通过利用互联网技术，打破了传统教育的限制，提供了更加灵活、自主、便捷和高效的学习途径。在线考试作为在线教育的一部分，成为了评估学生学习成果的重要手段。传统的考试方式存在很多缺点，如需要纸质试卷、人工评分、时间和空间限制等。这些问题不仅增加了教师的工作量，也限制了考试的效率和准确性1.管理员。
spring aop
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值