对AOP的理解

已于 2024-03-27 23:04:02 修改
阅读量1k 收藏 14
点赞数 8
分类专栏： java后端技术栈 spring 文章标签： spring aop
于 2024-03-27 22:56:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37477009/article/details/136998558
版权

目录

一、为何需要AOP？

1、从实际需求出发

public class Book {
	......
}

public interface IBookService {
    int insertBook(Book book);

    int deleteBookById(Long id);

    int updateBook(Book book);

    Book selectBookById(Long id);
}

public class BookServiceImpl implements IBookService {

    @Override
    public int insertBook(Book book) {
        // 入参检查

        // 日志记录

        // 事务处理

        // 业务逻辑

        return 0;
    }

    @Override
    public int deleteBookById(Long id) {
        // 入参检查

        // 日志记录

        // 事务处理

        // 业务逻辑

        return 0;
    }

    @Override
    public int updateBook(Book book) {
        // 入参检查

        // 日志记录

        // 事务处理

        // 业务逻辑

        return 0;
    }

    @Override
    public Book selectBookById(Long id) {
        // 入参检查

        // 日志记录

        // 事务处理

        // 业务逻辑

        return null;
    }
}
  • 上述代码的问题：
    • （1）业务逻辑代码和非业务逻辑代码耦合
    • （2）非业务逻辑的代码重复度高，却没有复用

2、现有的技术能解决吗？

  • 方案1：模板模式
public abstract class BookServiceTemplate {
    public <T, E> T execute(E e) {
        // 入参检查

        // 日志记录

        // 事务处理

        return doProcess(e);
    }

    protected abstract <T, E> T doProcess(E e);
}

public class BookServiceImpl implements IBookService {

    @Override
    public int insertBook(Book book) {
        return new BookServiceTemplate() {
            @Override
            protected <T, E> T doProcess(E e) {
                return null;
            }
        }.doProcess(book);
    }
	
	...
}
  • 在需求初期，BookServiceImpl的4个方法的入参检查、日志记录、事务处理都比较一致时，上面的写法还行得通。
  • 可一旦其中一个方法（如insertBook）需要改变入参检查、日志记录、事务处理时，事情就变得麻烦了。改模板吧，影响了其他方法（如updateBook）。去掉insertBook方法的模板吧，随着需求的发展，模板模式彻底腐化或被抛弃了。
  • 方案2：代理模式
public class BookServiceProxyImpl implements IBookService {
    
    private final IBookService bookService;

    public BookServiceProxyImpl(IBookService bookService) {
        this.bookService = bookService;
    }

    @Override
    public int insertBook(Book book) {
        // 入参检查
 		boolean pass = checkParams(book);
		
        // 日志记录

        // 事务处理

        // 业务逻辑
        return bookService.insertBook(book);
    }

	...

	// 入参检查
 	private boolean checkParams(Book book) {
 		...
 	}
}
  • 挺不错的，其中一个方法（如insertBook）需要改变入参检查、日志记录、事务处理时，改变这个方法即可，对其他方法没影响。
  • 但这个代理类不太“干净”，又能看到业务代码逻辑的入口（如insertBook），又能看到非业务逻辑代码（如checkParams）。

3、AOP可以解决

  • 将业务逻辑代码和非业务逻辑代码解耦
    • 业务逻辑代码在对象A，非业务逻辑代码在对象B
  • Spring管理了对象A和对象B，在逻辑执行中，交织对象A的业务逻辑和对象B的非业务逻辑
  • 这是我对AOP的简单理解。（AOP：Aspect Oriented Programming，即面向切面编程）
    • 面向对象编程（OOP）：通过将系统的大功能点拆分为一个一个小功能点，分别交给不同的类/对象负责（封装），并利用类的继承、多态构建系统的结构，让类相互配合，从而让系统运作起来。
    • AOP本质还是OOP，是对OOP的补充。
      在这里插入图片描述

二、如何实现AOP？

1、基本使用

public class User {
}

public interface IUserService {
    int insertUser(User user);

    int deleteUserById(Long id);
}

@Service
public class UserServiceImpl implements IUserService {
    @Override
    public int insertUser(User user) {
        return 0;
    }

    @Override
    public int deleteUserById(Long id) {
        return 0;
    }
}

public class Mail {
}

public interface IMailService {
    int insert(Mail mail);
}

@Service
public class MailServiceImpl implements IMailService {
    @Override
    public int insert(Mail mail) {
        return 0;
    }
}

@Aspect
@Component
public class LoggingAspect {

    /**
     *  com.forrest.learnspring.aop.example2.user.service.impl.UserServiceImpl类的所有public xxx 方法(yyy)在执行前都会被拦截，<br>
     *  并执行这个方法
     */
    @Before("execution(public * com.forrest.learnspring.aop.example2.user.service.impl.UserServiceImpl.*(..))")
    public void doAccessCheck() {
        System.out.println("[Before] do access check...");
    }

    /**
     * com.forrest.learnspring.aop.example2.mail.service.impl.MailServiceImpl类的所有public xxx 方法(yyy)在执行前都会被拦截，<br>
     * 并执行这个方法
     */
    @Around("execution(public * com.forrest.learnspring.aop.example2.mail.service.impl.MailServiceImpl.*(..))")
    public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("[Around] start " + pjp.getSignature());
        Object retVal = pjp.proceed();
        System.out.println("[Around] end " + pjp.getSignature());
        return retVal;
    }
}
  • 如果不加：@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        Arrays.stream(beanDefinitionNames).forEach(System.out::println);
    }
}

/**
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
application
loggingAspect
mailServiceImpl
userServiceImpl
*/
  • LoggingAspect因为被打上了@Component注解，因此也被加载成bean了。
  • 但实际上，loggingAspect没有起任何作用（什么都没输出）：
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        IUserService userService = applicationContext.getBean(UserServiceImpl.class);
        userService.insertUser(new User());
    }
}
  • 加上@EnableAspectJAutoProxy后：
@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        IUserService userService = applicationContext.getBean(UserServiceImpl.class);
        userService.insertUser(new User());
    }
}
  • 多了一个bean：org.springframework.aop.config.internalAutoProxyCreator
  • 但报错：
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.forrest.learnspring.aop.example2.user.service.impl.UserServiceImpl' available
  • 这就诡异了，明明在Spring容器中看到了userServiceImpl，Spring咋说没有呢？！
  • 很可能是因为：使用代理对象作为容器中的实际Bean
@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        Object bean = applicationContext.getBean("userServiceImpl");
        System.out.println(bean instanceof Advised); // 带上@EnableAspectJAutoProxy注解，则为true；否则为fasle。
    }
}
  • 这么改就对了：
@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        IUserService userService = applicationContext.getBean(IUserService.class);
        userService.insertUser(new User());
    }
}
  • 或者：
@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example2")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        IUserService userService = (IUserService) applicationContext.getBean("userServiceImpl");
        userService.insertUser(new User());
    }
}
  • 输出：
[Before] do access check...

2、更推荐的做法

2.1 “基本使用”存在的隐患

  • 目标代码（如userService.insertUser(new User());）无法感知到自己会被拦截。

2.2 最佳实践

2.2.1 参考@Transactional（通过AOP实现事务管理）
  • 对于一个bean，我希望这个bean的insertUser方法开启事务，可以这么写：
@Service
public class UserServiceImpl implements IUserService {
    @Override
    @Transactional
    public int insertUser(User user) {
        return 0;
    }

    ......
}

// 需要依赖:
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.25.RELEASE</version>
</dependency>
  • 通过注解，可以“自主”告知Spring，代理“我”吧，我需要AOP。
2.2.2 自定义注解

跟着廖雪峰老师，实现：对计算方法执行的耗时。

public class User {
}

public interface IUserService {
    User register(String email, String password, String name);
}

@Service
public class UserServiceImpl implements IUserService {
    @Override
    @MetricTime("register")
    public User register(String email, String password, String name) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return new User();
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MetricTime {
    String value();
}

@Aspect
@Component
public class MetricAspect {

    @Around("@annotation(metricTime)")
    public Object metric(ProceedingJoinPoint pjp, MetricTime metricTime) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return pjp.proceed();
        } finally {
            long end = System.currentTimeMillis();
            System.out.println("[Metric] [" + metricTime.value() + "] time cost: " + (end - start));
        }
    }
}
  • @annotation(xxx)中的xxx和MetricTime xxx要一一对应。
@EnableAspectJAutoProxy
@ComponentScan("com.forrest.learnspring.aop.example4.user")
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);
        IUserService userService = applicationContext.getBean(IUserService.class);
        userService.register("forrest@gmail.com", "123456", "forrest");
    }
}

/**
[Metric] [register] time cost: 1001
*/

3、后言

  • 实际开发中，写AOP代码比较少，主要是业务代码本身难以完全拨离非业务代码。
    • （1）例如，打日志。不可能只在方法的前后打日志，在方法执行中，也需要加一些日志。
    • （2）例如，参数检查。在方法执行前做参数检查，只是一些基本的检查。另外，有些参数的校验本身就属于业务逻辑的一部分。抛开业务本身，是没法判断参数是否正确的。
    • （3）例如，事务处理。可以用Spring提供的@Transactional注解。即使要自己定义注解通过AOP实现事务，在写方法体时也要格外注意，别带一些没必要参与事务的逻辑。
  • 不过，真需要在执行某些方法时，做一些拦截处理，AOP还是不错的选择。
南七行者
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Spring AOP
08-31
【深入理解Spring AOP】 Spring AOP，全称Aspect-Oriented Programming，是Spring框架的重要组成部分，它提供了面向切面编程的能力，旨在解决传统面向对象编程（OOP）中横切关注点的问题。OOP强调封装、继承和多态...
深入理解Android之AOP
01-26
深入理解Android之AOP；深入理解Android之AOP；深入理解Android之AOP
对AOP理解
weixin_50932484的博客
03-19 103
aop主要实现在是bean的后置处理器，使用jdk动态代理或者是cglib动态代理给原本的代码进行业务增强。
谈谈你对AOP的理解
BUEL_的博客
07-16 82
对SpringAOP的理解
对Spring当中AOP的理解
2301_77707071的博客
01-28 1581
指切面在系统中要应用的位置,spring 中能够使用切面的位置为方法，所以连接指方法连接点指要调用某个方法时拦截到对这个方法的调用，做一些其他事情然后再执行目标方法拦截到的方法就是连接点。AOP就是把系统中重复的代码抽取出来，单独开发，在系统需要时，使用动态代理技术，在不修改源码的基础上，将单独开发的功能通知织入(应用)到系统中的过程，完成完整的代码逻辑。下面我们来看后置通知，通过上述的前置通知，我们可以推断出后置通知应该就是addUser()执行后进行通知的，下面我们来看看是不是这样的。
Spring AOP理解
I_m_j的博客
06-10 1474
Spring AOP基础解读
对Spring AOP的理解
qq_53999369的博客
06-14 1947
对SpringAOP的相关术语的理解和代理的思想
说说你对Aop的理解
Fzmeng1543的博客
12-21 160
说说你对Aop的理解
AOP的理解
weixin_41563161的博客
10-24 114
AOP的理解
AOP理解
分享Android开发知识
03-25 816
一、什么是AOP？ 我们先回顾一下OOP：Object Oriented Programming，OOP作为面向对象编程的模式，获得了巨大的成功，OOP的主要功能是数据封装、继承和多态。 而AOP是一种新的编程方式，它和OOP不同，OOP把系统看作多个对象的交互，AOP把系统分解为不同的关注点，或者称之为切面（Aspect）。 要理解AOP的概念，我们先用OOP举例，比如一个业务组件BookService，它有几个业务方法： createBook：添加新的Book； updateBook：修改Book； d
面试常客：谈谈你对AOP的理解
qinuna's home
09-14 1915
AOP：Aspect oriented programming 面向切面编程，是 OOP 的一种延续 OOP 思想是一种垂直纵向的继承体系，通过子类继承父类可以解决大部分的代码重复问题，但对于一些特殊问题，比如在父类中的多个方法的相同位置出现了重复代码，OOP 就解决不了。比如要在父类的每个方法的的开始和结束，都添加一个性能监控或者日志输出。 这种需要在重复位置添加的代码，统称为 横切逻辑代码，这种横切代码与业务代码混杂在一起，致使代码臃肿，不便于维护，而 AOP 就是来解决这些问题的 AOP 通过横向抽取
Spring的AOP理解
红目香薰
03-08 259
OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。 AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。 AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态.
Spring核心IoC和AOP的理解
08-31
Spring核心IoC和AOP的理解 本文主要介绍了Spring核心IoC和AOP的相关知识，涵盖了IoC和AOP的概念、特点、优点和应用场景等方面的内容。 一、IoC（Inversion of Control） IoC是一种设计模式，目的是为了降低应用...
SpringAop的简单理解.pdf
02-28
SpringAop的简单理解.pdf
Android深入理解Aop
01-10
阿拉神农博客《Android深入理解Aop》的PDF版，也可以在https://blog.csdn.net/innost/article/details/49387395 该网站中直接观看，也可以下载下来保存
springboot start.aliyun.com java8
JavaUpgrade
07-15 140
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Springboo3中使用虚线程
最新发布
java scala
07-19 280
Java中的虚线程类似Go中的协程，简单来说可以通过同步编程的方式来达到异步编程模式的效果，
springboot基于协同过滤算法的黔醉酒业白酒销售系统lw源码调试讲解
u014445459的博客
07-16 804
本章开始先是介绍了系统进行测试目的及方法，然后简单地阐述了系统测试中常见的黑命、白盒和灰盒测试方法，以及它们各自的特征，随后围绕本系统的注册登录、删除分类、修改密码、等功能进行了功能测试，并将测试用例和测试结果呈现出来，此外，还对实现的系统进行了关于登录和功能模块的压力测试。本系统开发之前的所有调研基本都是本人独立完成，需求设计，功能开发等也都是自己及指导老师的帮助下完成，通过自己的努力解决掉开发过程中所遇到的问题经济支出可以忽略不计，固黔醉酒业白酒销售系统在经济可行性上完全可行可以开发。
Java 和 SpringBoot 中的设计模式 详解
weixin_68074170的博客
07-19 378
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
谈谈对spring aop理解
10-12
Spring AOP（Aspect-Oriented Programming）是一种编程范式，它允许开发人员在不修改源代码的情况下，通过将横切关注点（如日志记录、性能统计、安全性等）从主业务逻辑中分离出来，实现对系统的解耦和复用。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值