SpringBoot异步调用相同类的方法

在之前的文章中，我们学习了Spring Boot中的异步调用机制，以及如何使用@Async注解来实现方法的异步执行。然而，在实际开发中，我们可能会遇到这样一个问题：在同一个类中调用带有@Async注解的方法时，异步调用竟然失效了！这究竟是为什么呢？今天，我们就来深入探讨一下这个问题，并给出几种可行的解决方案。

一、问题介绍

在Spring Boot中，@Async注解被广泛应用于实现方法的异步执行。通常，我们只需要在方法上添加@Async注解，并在启动类上添加@EnableAsync注解，就可以实现方法的异步调用了。然而，当我们在同一个类中调用带有@Async注解的方法时，却发现异步调用并没有生效，方法仍然是同步执行的。

原因分析

这个问题的根源在于Spring的AOP（面向切面编程）代理机制。在Spring中，@Async注解的实现依赖于AOP代理。当我们在一个类中调用另一个方法时，如果直接通过this来调用（即类内部调用），那么实际上并没有通过Spring的代理对象来调用该方法，因此@Async注解也就无法生效了。

二、解决方案

2.1 将异步方法拆分到另一个Bean中

这是最简单也是最推荐的一种解决方案。我们可以将带有@Async注解的异步方法拆分到另一个Bean中，然后在原类中注入这个Bean，并通过调用这个Bean的方法来实现异步执行。

步骤：
‌创建异步方法所在的Bean‌：
java 复制代码
@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        // 异步方法的实现
        System.out.println("Async method starts");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("Async method ends");
    }
}
‌在原类中注入异步Bean并调用‌：
java 复制代码
@Service
public class MyService {

    @Autowired
    private AsyncService asyncService;

    public void myMethod() {
        System.out.println("My method starts");
        asyncService.asyncMethod();
        System.out.println("My method ends");
    }
}
实现效果：

当调用myMethod时，asyncMethod会在独立的线程中异步执行。

控制台输出顺序：My method starts -> My method ends -> Async method starts -> Async method ends（注意这里的顺序可能会因为线程调度而有所差异）。

2.2 自注入当前Bean

如果出于某种原因，我们不想将异步方法拆分到另一个Bean中，那么可以考虑使用自注入的方式。即在原类中注入自己，然后通过注入的实例来调用异步方法。

步骤：
‌在原类中注入自己 ‌：
java 复制代码
@Service
public class MyService {

    @Autowired
    private MyService self;

    public void myMethod() {
        System.out.println("My method starts");
        self.asyncMethod();
        System.out.println("My method ends");
    }

    @Async
    public void asyncMethod() {
        // 异步方法的实现
        System.out.println("Async method starts");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("Async method ends");
    }
}
‌注意‌：使用自注入需要确保没有循环依赖的问题。通常，如果只是方法调用的话，可能不会有问题。但为了避免潜在的风险，我们可以使用@Lazy注解来延迟Bean的加载。

实现效果：

当调用myMethod时，asyncMethod会在独立的线程中异步执行。

控制台输出顺序与上一种方案类似。

2.3 使用AopContext获取代理对象

另一种解决方案是使用AopContext来获取当前类的代理对象，并通过代理对象来调用异步方法。但这种方法需要开启exposeProxy选项，并且代码可能不够直观。

步骤：
‌在启动类上开启exposeProxy‌：
复制代码
java 复制代码
@SpringBootApplication
@EnableAsync
@EnableAspectJAutoProxy(exposeProxy = true)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
‌在方法中使用AopContext获取代理对象‌：
复制代码
java 复制代码
@Service
public class MyService {

    public void myMethod() {
        System.out.println("My method starts");
        ((MyService) AopContext.currentProxy()).asyncMethod();
        System.out.println("My method ends");
    }

    @Async
    public void asyncMethod() {
        // 异步方法的实现
        System.out.println("Async method starts");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("Async method ends");
    }
}
实现效果：

当调用myMethod时，asyncMethod会在独立的线程中异步执行。

控制台输出顺序与前面两种方案类似。

‌注意‌：使用AopContext获取代理对象的方法需要确保AOP代理已经正确暴露，并且代码中存在类型转换，可能不够安全。因此，在实际开发中需要谨慎使用。

2.4 使用ApplicationContext获取Bean实例

还有一种方法是使用ApplicationContext来获取Bean实例，并通过该实例来调用异步方法。但这种方法可能会有循环依赖的问题，或者代码看起来不够直观。

步骤：
‌在类中注入ApplicationContext ‌：
java 复制代码
@Service
public class MyService {

    @Autowired
    private ApplicationContext applicationContext;

    public void myMethod() {
        System.out.println("My method starts");
        MyService myService = applicationContext.getBean(MyService.class);
        myService.asyncMethod();
        System.out.println("My method ends");
    }

    @Async
    public void asyncMethod() {
        // 异步方法的实现
        System.out.println("Async method starts");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
        System.out.println("Async method ends");
    }
}
实现效果：

当调用myMethod时，asyncMethod会在独立的线程中异步执行。

控制台输出顺序与前面几种方案类似。

‌注意‌：使用ApplicationContext获取Bean实例的方法可能会有循环依赖的问题，特别是在复杂的依赖关系中。因此，在实际开发中需要谨慎使用，并确保没有引入新的问题。

总结

推荐方案：将异步方法拆分到另一个Bean，代码结构清晰且符合Spring设计。
自注入：适用于简单场景，需注意循环依赖。
AopContext：灵活但需额外配置，适合无法修改类结构的情况。