【小家Spring】Spring异步处理@Async的使用以及原理、源码分析（@EnableAsync）（下）

// 他继承自AsyncExecutionAspectSupport 来处理异步方法的处理，同时是个MethodInterceptor，来增强复合条件的方法
public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor, Ordered {
  ...
  // 显然这个方法它直接返回null，因为XML配置嘛~~~~
  @Override
  @Nullable
  protected String getExecutorQualifier(Method method) {
    return null;
  }
  // 这个厉害了。如果父类返回的defaultExecutor 为null，那就new一个SimpleAsyncTaskExecutor作为默认的执行器
  @Override
  @Nullable
  protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    Executor defaultExecutor = super.getDefaultExecutor(beanFactory);
    return (defaultExecutor != null ? defaultExecutor : new SimpleAsyncTaskExecutor());
  }
  // 最高优先级  希望的是最优先执行（XML配置就是这种优先级）
  @Override
  public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE;
  }
// 最重要的当然是这个invoke方法
  @Override
  @Nullable
  public Object invoke(final MethodInvocation invocation) throws Throwable {
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    // 注意：此处是getMostSpecificMethod  拿到最终要执行的那个方法
    Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
    // 桥接方法~~~~~~~~~~~~~~
    final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
    // determine一个用于执行此方法的异步执行器
    AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
    if (executor == null) {
      throw new IllegalStateException(
          "No executor specified and no default executor set on AsyncExecutionInterceptor either");
    }
    // 构造一个任务，Callable(此处不采用Runable，因为需要返回值)
    Callable<Object> task = () -> {
      try {
        // result就是返回值
        Object result = invocation.proceed();
        // 注意此处的处理~~~~  相当于如果不是Future类型，就返回null了
        if (result instanceof Future) {
          return ((Future<?>) result).get();
        }
      }
      // 处理执行时可能产生的异常~~~~~~
      catch (ExecutionException ex) {
        handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());
      }
      catch (Throwable ex) {
        handleError(ex, userDeclaredMethod, invocation.getArguments());
      }
      return null;
    };
    // 提交任务~~~~invocation.getMethod().getReturnType()为返回值类型
    return doSubmit(task, executor, invocation.getMethod().getReturnType());
  }
}

// 它继承自AsyncExecutionInterceptor ，只复写了一个方法
public class AnnotationAsyncExecutionInterceptor extends AsyncExecutionInterceptor {
  ...
  // 由此可以见它就是去拿到@Async的value值。以方法的为准，其次是类上面的
  // 备注：发现这里是不支持EJB的@Asynchronous注解的，它是不能指定执行器的
  @Override
  @Nullable
  protected String getExecutorQualifier(Method method) {
    // Maintainer's note: changes made here should also be made in
    // AnnotationAsyncExecutionAspect#getExecutorQualifier
    Async async = AnnotatedElementUtils.findMergedAnnotation(method, Async.class);
    if (async == null) {
      async = AnnotatedElementUtils.findMergedAnnotation(method.getDeclaringClass(), Async.class);
    }
    return (async != null ? async.value() : null);
  }
}

@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public Object hello() {
        System.out.println("当前线程：" + Thread.currentThread().getName());
        helloPrivate(); // 同类内部方法调用
        return "service hello";
    }
    @Async
    @Override
    public Object hello2() {
        System.out.println("当前线程：" + Thread.currentThread().getName());
        return null;
    }
}

当前线程：http-nio-8080-exec-3
当前线程：http-nio-8080-exec-3

@Service
public class HelloServiceImpl implements HelloService {
    @Autowired
    private ApplicationContext applicationContext;
    @Override
    public Object hello() {
        System.out.println("当前线程：" + Thread.currentThread().getName());
        // 从容器里拿到该类型的实例~~~~（注意：若是JDK代理，这里的类型只能传接口，而不能是实现类，否则NoSuchBean...）
        HelloService helloService = applicationContext.getBean(HelloService.class);
        // 然后用本实例去调用  而不是用默认的this去调用
        helloService.hello2();
        return "service hello";
    }
    @Async
    @Override
    public Object hello2() {
        System.out.println("当前线程：" + Thread.currentThread().getName());
        return null;
    }
}

当前线程：http-nio-8080-exec-4
当前线程：SimpleAsyncTaskExecutor-2

@EnableAsync //对应的@Enable注解，最好写在属于自己的配置文件上，保持内聚性
@Configuration
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10); //核心线程数
        executor.setMaxPoolSize(20);  //最大线程数
        executor.setQueueCapacity(1000); //队列大小
        executor.setKeepAliveSeconds(300); //线程最大空闲时间
        executor.setThreadNamePrefix("fsx-Executor-"); 指定用于新创建的线程名称的前缀。
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（一共四种，此处省略）
      // 这一步千万不能忘了，否则报错： java.lang.IllegalStateException: ThreadPoolTaskExecutor not initialized
        executor.initialize();
        return executor;
    }
    // 异常处理器：当然你也可以自定义的，这里我就这么简单写了~~~
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}