dynamictp学习

public class ZookeeperRefresher extends AbstractRefresher implements EnvironmentAware, InitializingBean{
    public ZookeeperRefresher(DtpProperties dtpProperties) {
        super(dtpProperties);
    }
    @Override
    public void afterPropertiesSet() {

    }

    private void loadAndRefresh() {
        refresh(CuratorUtil.genPropertiesMap(dtpProperties));
    }

}

@Configuration
@ConditionalOnClass(value = org.apache.curator.framework.CuratorFramework.class)
@ConditionalOnBean({DtpBaseBeanConfiguration.class})
@AutoConfigureAfter({DtpBaseBeanConfiguration.class})
public class DtpZkAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean()
    public ZookeeperRefresher zookeeperRefresher(DtpProperties dtpProperties) {
        return new ZookeeperRefresher(dtpProperties);
    }
} 

    protected void doRefresh(DtpProperties properties) {
        DtpRegistry.refresh(properties);
        publishEvent(properties);
    }

/**
 * Refresh while the listening configuration changed.
 *
 * @param dtpProperties the main properties that maintain by config center
 */
public static void refresh(DtpProperties dtpProperties) {
    if (Objects.isNull(dtpProperties) || CollectionUtils.isEmpty(dtpProperties.getExecutors())) {
        log.debug("DynamicTp refresh, empty thread pool properties.");
        return;
    }
    dtpProperties.getExecutors().forEach(DtpRegistry::refresh);
}

private static final Map<String, ExecutorWrapper> EXECUTOR_REGISTRY = new ConcurrentHashMap<>();

public static void refresh(DtpExecutorProps props) {
    if (Objects.isNull(props) || StringUtils.isBlank(props.getThreadPoolName())) {
        log.warn("DynamicTp refresh, thread pool name must not be blank, executorProps: {}", props);
        return;
    }
    ExecutorWrapper executorWrapper = EXECUTOR_REGISTRY.get(props.getThreadPoolName());
    if (Objects.nonNull(executorWrapper)) {
        refresh(executorWrapper, props);
        return;
    }
    log.warn("DynamicTp refresh, cannot find specified executor, name: {}.", props.getThreadPoolName());
}

public static void registerExecutor(ExecutorWrapper wrapper, String source) {
    log.info("DynamicTp register executor: {}, source: {}", ExecutorConverter.toMainFields(wrapper), source);
    EXECUTOR_REGISTRY.putIfAbsent(wrapper.getThreadPoolName(), wrapper);
}

public class DtpPostProcessor implements BeanPostProcessor, BeanFactoryAware, PriorityOrdered {
    @Override
    public Object postProcessAfterInitialization(@NonNull Object bean, @NonNull String beanName) throws BeansException {
        if (!(bean instanceof ThreadPoolExecutor) && !(bean instanceof ThreadPoolTaskExecutor)) {
            return bean;
        }
        if (bean instanceof DtpExecutor) {
            return registerAndReturnDtp(bean);
        }
        // register juc ThreadPoolExecutor or ThreadPoolTaskExecutor
        return registerAndReturnCommon(bean, beanName);
    }

private DefaultListableBeanFactory beanFactory;@Override

public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    this.beanFactory = (DefaultListableBeanFactory) beanFactory;
}

private Object registerAndReturnCommon(Object bean, String beanName) {
    String dtpAnnoValue;
    try {
        DynamicTp dynamicTp = beanFactory.findAnnotationOnBean(beanName, DynamicTp.class);
        if (Objects.nonNull(dynamicTp)) {
            dtpAnnoValue = dynamicTp.value();
        } else {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            if (!(beanDefinition instanceof AnnotatedBeanDefinition)) {
                return bean;
            }
            AnnotatedBeanDefinition annotatedBeanDefinition = (AnnotatedBeanDefinition) beanDefinition;
            MethodMetadata methodMetadata = (MethodMetadata) annotatedBeanDefinition.getSource();
            if (Objects.isNull(methodMetadata) || !methodMetadata.isAnnotated(DynamicTp.class.getName())) {
                return bean;
            }
            dtpAnnoValue = Optional.ofNullable(methodMetadata.getAnnotationAttributes(DynamicTp.class.getName()))
                    .orElse(Collections.emptyMap())
                    .getOrDefault("value", "")
                    .toString();
        }
    } catch (NoSuchBeanDefinitionException e) {
        log.warn("There is no bean with the given name {}", beanName, e);
        return bean;
    }
    String poolName = StringUtils.isNotBlank(dtpAnnoValue) ? dtpAnnoValue : beanName;
    return doRegisterAndReturnCommon(bean, poolName);
}