SpringBoot 功能统一禁用启用注解+AOP

注解和 AOP

注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnabledIgnore {
    String beanName();
    String message() default "";
    boolean async() default true;
}

AOP

@Aspect
@Slf4j
@Configuration(value = EnabledIgnoreAspect.BEAN_NAME)
@Order(EnabledIgnoreAspect.ASPECT_ORDER)
public class EnabledIgnoreAspect {

    public static final String BEAN_NAME = "enabledIgnoreAspect";

    public static final int ASPECT_ORDER = LockAspect.ASPECT_ORDER + 10;

    @Resource
    private ThreadPoolTaskExecutor taskExecutor;

    private final Map<String, EnableFlag> beanMap = new ConcurrentHashMap<>();

    @Around("@annotation(enabledIgnore)")
    public Object round(ProceedingJoinPoint pjp, EnabledIgnore enabledIgnore) throws Throwable {
        EnableFlag enableFlag = getEnableFlag(enabledIgnore);
        if (enableFlag == null) {
            log.error("[启用禁用]未找到对应bean: {}", enabledIgnore.beanName());
            return pjp.proceed();
        }

        if (!enableFlag.isEnabled()) {
            log.info("[启用禁用-{}]功能未开启", enableFlag.logMark());
            return null;
        }
        if (enabledIgnore.async()) {
            TransactionUtil.afterCommitAsync(() -> {
                try {
                    pjp.proceed();
                } catch (Throwable e) {
                    log.error("事务提交后执行失败", e);
                }
            }, taskExecutor);
            return null;
        } else {
            return pjp.proceed();
        }
    }

    private EnableFlag getEnableFlag(EnabledIgnore enabledIgnore) {
        EnableFlag bean = beanMap.get(enabledIgnore.beanName());
        if (bean != null) {
            return bean;
        }

        EnableFlag enableFlag = SpringUtil.getBean(enabledIgnore.beanName());
        beanMap.putIfAbsent(enabledIgnore.beanName(), enableFlag);
        return enableFlag;
    }


    public interface EnableFlag {

        boolean isEnabled();

        String logMark();
    }
}

使用

@Data
@Slf4j
@Configuration
public class AppAbilityAuth2Config {

    public static final String PEOPERTIES_BEAN_NAME = "huiZhiOAuth2Properties";

    @ConfigurationProperties(prefix = "app.ability.hz-oauth")
    @Bean(name = PEOPERTIES_BEAN_NAME)
    @RefreshScope
    public HuiZhiOAuth2Properties huiZhiOAuth2Properties() {
        return new HuiZhiOAuth2Properties();
    }

    @Data
    public static class HuiZhiOAuth2Properties implements EnabledIgnoreAspect.EnableFlag {
        /**
         * 基本地址前缀
         */
        private String baseUrl;

        /**
         * 账号
         */
        private String account;

        /**
         * 密码
         */
        private String password;

        private boolean enabled = false;


        @Override
        public String logMark() {
            return "统一认证";
        }
    }
}

@Service
@Profile("prod")
@Slf4j
public class HuiZhiOauth2ServiceImpl implements IHuiZhiOauth2Service {

    @Override
    @EnabledIgnore(beanName = AppAbilityAuth2Config.PEOPERTIES_BEAN_NAME)
    public Oauth2ConfigDTO createConfig(String appName, Long appId, String callbackUrl) {
        // ....
    }
}

@Slf4j
public class TransactionUtil {

    /**
     * 用于保证事务提交后同步执行时按照调用顺序执行
     */
    private static final AtomicInteger ATOMICINTEGER = new AtomicInteger(0);

    /**
     * 异步执行日志打印
     */
    private static final Consumer<Exception> LOG_ASYNC_EXCEPTION = e -> log.error("事务提交后业务异步执行出错", e);

    /**
     * 同步执行日志打印
     */
    private static final Consumer<Exception> LOG_SYNC_EXCEPTION = e -> log.error("事务提交后业务执行出错", e);

    /**
     * 事务提交后异步执行
     *
     * @param r        要执行的业务
     * @param executor 异步执行器
     */
    public static void afterCommitAsync(Runnable r, Executor executor) {
        afterCommitAsync(r, LOG_ASYNC_EXCEPTION, executor);
    }

    /**
     * 事务提交后异步执行
     *
     * @param r                 要执行的业务
     * @param exceptionConsumer 异常处理
     * @param executor          异步执行器
     */
    public static void afterCommitAsync(Runnable r, Consumer<Exception> exceptionConsumer, Executor executor) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            final int order = ATOMICINTEGER.getAndIncrement();
            TransactionSynchronizationManager.registerSynchronization(
                    new TransactionSynchronization() {
                        @Override
                        public void afterCommit() {
                            try {
                                executor.execute(r);
                            } catch (Exception e) {
                                exceptionConsumer.accept(e);
                            }
                        }

                        @Override
                        public int getOrder() {
                            return order;
                        }
                    });
        } else {
            try {
                executor.execute(r);
            } catch (Exception e) {
                exceptionConsumer.accept(e);
            }
        }
    }

    /**
     * 事务提交后执行
     *
     * @param r 要执行的业务
     */
    public static void afterCommitSync(Runnable r) {
        afterCommitSync(r, LOG_SYNC_EXCEPTION);
    }

    /**
     * 事务提交后执行
     *
     * @param exceptionConsumer 异常处理
     * @param r                 要执行的业务
     */
    public static void afterCommitSync(Runnable r, Consumer<Exception> exceptionConsumer) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            final int order = ATOMICINTEGER.getAndIncrement();
            TransactionSynchronizationManager.registerSynchronization(
                    new TransactionSynchronization() {
                        @Override
                        public void afterCommit() {
                            try {
                                r.run();
                            } catch (Exception e) {
                                exceptionConsumer.accept(e);
                            }
                        }

                        @Override
                        public int getOrder() {
                            return order;
                        }
                    });
        } else {
            try {
                r.run();
            } catch (Exception e) {
                exceptionConsumer.accept(e);
            }
        }
    }
}