diff --git a/java-dataloader-plus-core/pom.xml b/java-dataloader-plus-core/pom.xml index 9109e47..fcafc10 100644 --- a/java-dataloader-plus-core/pom.xml +++ b/java-dataloader-plus-core/pom.xml @@ -16,10 +16,9 @@ 8 3.1.0 1.1.11 - 1.18.18 4.11 3.1.0 - 0.0.10 + 0.1.4 @@ -28,11 +27,6 @@ java-dataloader ${dataloader.version} - - org.projectlombok - lombok - ${lombok.version} - ch.qos.logback logback-classic diff --git a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/AbstractDataLoaderFactory.java b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/AbstractDataLoaderFactory.java new file mode 100644 index 0000000..8ed9971 --- /dev/null +++ b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/AbstractDataLoaderFactory.java @@ -0,0 +1,29 @@ +package com.github.lokic.dataloaderplus.core; + +import lombok.SneakyThrows; +import org.dataloader.DataLoader; +import org.dataloader.DataLoaderOptions; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +public abstract class AbstractDataLoaderFactory implements DataLoaderFactory { + + private final Map>, MultiKeyMappedBatchLoader> dataLoaderCreators = new ConcurrentHashMap<>(); + + @SuppressWarnings("unchecked") + @Override + public > T getInstance(Class batchLoaderType) { + return (T) dataLoaderCreators.computeIfAbsent(batchLoaderType, this::createInstance); + } + + public abstract > T createInstance(Class batchLoaderType); + + @SneakyThrows + @Override + public DataLoader create(Class> batchLoaderType, DataLoaderOptions options) { + MultiKeyMappedBatchLoader loader = getInstance(batchLoaderType); + return org.dataloader.DataLoaderFactory.newMappedDataLoader(loader, options); + } + +} diff --git a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactory.java b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactory.java index 2facb6a..e67f78d 100644 --- a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactory.java +++ b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactory.java @@ -1,32 +1,20 @@ package com.github.lokic.dataloaderplus.core; +import lombok.SneakyThrows; import org.dataloader.DataLoader; import org.dataloader.DataLoaderOptions; -import java.util.Map; -import java.util.Optional; -import java.util.concurrent.ConcurrentHashMap; - /** * DataLoader的工厂，基于 {@link MultiKeyMappedBatchLoader} 创建 {@link DataLoader} */ -public class DataLoaderFactory { - - private final Map> DATA_LOADER_CREATORS = new ConcurrentHashMap<>(); - - public void addMultiKeyMappedBatchLoader(String name, MultiKeyMappedBatchLoader dataLoaderProvider) { - DATA_LOADER_CREATORS.put(name, dataLoaderProvider); - } +public interface DataLoaderFactory { - public MultiKeyMappedBatchLoader getMultiKeyMappedBatchLoader(String name) { - return DATA_LOADER_CREATORS.get(name); - } + > T getInstance(Class batchLoaderType); - public DataLoader create(String name, DataLoaderOptions options) { - MultiKeyMappedBatchLoader loader = Optional.ofNullable(DATA_LOADER_CREATORS.get(name)) - .orElseThrow(() -> new IllegalArgumentException("not found data loader supplier, name = " + name)); + @SneakyThrows + default DataLoader create(Class> batchLoaderType, DataLoaderOptions options) { + MultiKeyMappedBatchLoader loader = getInstance(batchLoaderType); return org.dataloader.DataLoaderFactory.newMappedDataLoader(loader, options); } - } diff --git a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactoryImpl.java b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactoryImpl.java new file mode 100644 index 0000000..89299c1 --- /dev/null +++ b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/DataLoaderFactoryImpl.java @@ -0,0 +1,10 @@ +package com.github.lokic.dataloaderplus.core; + +import lombok.SneakyThrows; + +public class DataLoaderFactoryImpl extends AbstractDataLoaderFactory { + @SneakyThrows + public > T createInstance(Class batchLoaderType) { + return batchLoaderType.getConstructor().newInstance(); + } +} diff --git a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/ExDataLoaderRegistry.java b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/ExDataLoaderRegistry.java index 153a30b..746fd56 100644 --- a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/ExDataLoaderRegistry.java +++ b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/ExDataLoaderRegistry.java @@ -53,8 +53,8 @@ protected ExDataLoaderRegistry(@NonNull ExDataLoaderRegistry exRegistry) { * @param * @return */ - public DataLoader getOrRegisterDataLoader(Class> clazz) { - return registry.computeIfAbsent(clazz.getName(), key -> factory.create(key, options)); + public DataLoader getOrRegisterDataLoader(Class> clazz) { + return registry.computeIfAbsent(clazz.getName(), key -> factory.create(clazz, options)); } public void dispatchAll() { diff --git a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/TemplateConfig.java b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/TemplateConfig.java index 74b7979..6be86a1 100644 --- a/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/TemplateConfig.java +++ b/java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/TemplateConfig.java @@ -10,7 +10,7 @@ public class TemplateConfig { private static final DataLoaderOptions DEFAULT_OPTIONS = DataLoaderOptions.newOptions(); - private static final DataLoaderFactory DEFAULT_FACTORY = new DataLoaderFactory(); + private static final DataLoaderFactory DEFAULT_FACTORY = new DataLoaderFactoryImpl(); private final DataLoaderOptions options; private final DataLoaderFactory factory; diff --git a/java-dataloader-plus-core/src/test/java/com/github/lokic/dataloaderplus/core/DataLoaderTemplateTest.java b/java-dataloader-plus-core/src/test/java/com/github/lokic/dataloaderplus/core/DataLoaderTemplateTest.java index c0b0aaf..726a7ce 100644 --- a/java-dataloader-plus-core/src/test/java/com/github/lokic/dataloaderplus/core/DataLoaderTemplateTest.java +++ b/java-dataloader-plus-core/src/test/java/com/github/lokic/dataloaderplus/core/DataLoaderTemplateTest.java @@ -5,6 +5,7 @@ import com.github.lokic.dataloaderplus.core.service.UserService; import com.github.lokic.dataloaderplus.core.service.UserService2; import com.github.lokic.javaplus.CompletableFutures; +import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import org.dataloader.BatchLoaderEnvironment; import org.dataloader.DataLoaderOptions; @@ -13,6 +14,7 @@ import org.junit.Test; import org.mockito.Mockito; +import java.lang.reflect.Field; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.stream.Collectors; @@ -31,17 +33,24 @@ public class DataLoaderTemplateTest { private UserService2 userService2; + @SuppressWarnings("unchecked") + @SneakyThrows @Before public void init() { - - UserAddressBatchLoader userAddressBatchLoader = Mockito.spy(new UserAddressBatchLoader()); userService2 = ExDataLoaderRegistry.getService(UserService2.class); userService = ExDataLoaderRegistry.getService(UserService.class); - UserNameBatchLoader userNameBatchLoader = Mockito.spy(new UserNameBatchLoader()); - DataLoaderFactory factory = new DataLoaderFactory(); - factory.addMultiKeyMappedBatchLoader(UserNameBatchLoader.class.getName(), userNameBatchLoader); - factory.addMultiKeyMappedBatchLoader(UserAddressBatchLoader.class.getName(), userAddressBatchLoader); + DataLoaderFactory factory = new DataLoaderFactoryImpl(); + factory.getInstance(UserNameBatchLoader.class); + factory.getInstance(UserAddressBatchLoader.class); + + Field field = AbstractDataLoaderFactory.class.getDeclaredField("dataLoaderCreators"); + field.setAccessible(true); + Map map = (Map) field.get(factory); + for (Object aClass : map.keySet()) { + Object o = map.get(aClass); + map.put(aClass, Mockito.spy(o)); + } templateConfig = new TemplateConfig(DataLoaderOptions.newOptions(), factory, Propagation.REQUIRED); template = new DataLoaderTemplate(templateConfig); @@ -79,8 +88,8 @@ public void test_batchLoader_callOneTimes() throws Throwable { expectedRes.add("2" + "," + "name:2" + "," + "address:2"); Assert.assertEquals(expectedRes, strings); - UserNameBatchLoader userNameBatchLoader = (UserNameBatchLoader) templateConfig.getFactory().getMultiKeyMappedBatchLoader(UserNameBatchLoader.class.getName()); - UserAddressBatchLoader userAddressBatchLoader = (UserAddressBatchLoader) templateConfig.getFactory().getMultiKeyMappedBatchLoader(UserAddressBatchLoader.class.getName()); + UserNameBatchLoader userNameBatchLoader = templateConfig.getFactory().getInstance(UserNameBatchLoader.class); + UserAddressBatchLoader userAddressBatchLoader = templateConfig.getFactory().getInstance(UserAddressBatchLoader.class); Mockito.verify(userNameBatchLoader, Mockito.times(1)) .load(Mockito.eq(set), Mockito.any()); diff --git a/java-dataloader-plus-spring-boot-starter/pom.xml b/java-dataloader-plus-spring-boot-starter/pom.xml index cac6793..61a3645 100644 --- a/java-dataloader-plus-spring-boot-starter/pom.xml +++ b/java-dataloader-plus-spring-boot-starter/pom.xml @@ -36,6 +36,11 @@ spring-boot-starter-test test + + com.github.lokic + custom-annotation-spring-registrar + 0.0.2 + diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/BatchLoaderBeanPostProcessor.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/BatchLoaderBeanPostProcessor.java deleted file mode 100644 index f5ac688..0000000 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/BatchLoaderBeanPostProcessor.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.github.lokic.dataloaderplus.spring; - -import com.github.lokic.dataloaderplus.core.DataLoaderFactory; -import com.github.lokic.dataloaderplus.core.MultiKeyMappedBatchLoader; -import org.springframework.beans.BeansException; -import org.springframework.beans.factory.BeanFactory; -import org.springframework.beans.factory.BeanFactoryAware; -import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter; -import org.springframework.beans.factory.support.DefaultListableBeanFactory; -import org.springframework.core.Ordered; - -public class BatchLoaderBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements BeanFactoryAware, Ordered { - - private DefaultListableBeanFactory beanFactory; - - - @Override - public void setBeanFactory(BeanFactory beanFactory) throws BeansException { - if (beanFactory instanceof DefaultListableBeanFactory) { - this.beanFactory = (DefaultListableBeanFactory) beanFactory; - } - } - - @Override - public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { - if (bean instanceof MultiKeyMappedBatchLoader) { - DataLoaderFactory dataLoaderFactory = beanFactory.getBean(DataLoaderFactory.class); - // 此处必须是beanName，否则后面基于class name会找不到对应的MultiKeyMappedBatchLoader， - // 因为字节码增强之后，bean具体实现类名已经改变 - dataLoaderFactory.addMultiKeyMappedBatchLoader(beanName, (MultiKeyMappedBatchLoader) bean); - } - return bean; - } - - @Override - public int getOrder() { - return Ordered.LOWEST_PRECEDENCE; - } -} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoadableBeanFactoryPointcutAdvisor.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoadableBeanFactoryPointcutAdvisor.java deleted file mode 100644 index da2a62b..0000000 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoadableBeanFactoryPointcutAdvisor.java +++ /dev/null @@ -1,32 +0,0 @@ -package com.github.lokic.dataloaderplus.spring; - -import com.github.lokic.dataloaderplus.spring.annotation.DataLoadable; -import org.springframework.aop.Pointcut; -import org.springframework.aop.support.AbstractBeanFactoryPointcutAdvisor; -import org.springframework.aop.support.StaticMethodMatcherPointcut; -import org.springframework.core.annotation.AnnotationUtils; - -import java.lang.reflect.Method; -import java.util.Objects; - -public class DataLoadableBeanFactoryPointcutAdvisor extends AbstractBeanFactoryPointcutAdvisor { - - private final DataLoadablePointcut pointcut; - - public DataLoadableBeanFactoryPointcutAdvisor() { - this.pointcut = new DataLoadablePointcut(); - } - - @Override - public Pointcut getPointcut() { - return pointcut; - } - - public static class DataLoadablePointcut extends StaticMethodMatcherPointcut { - - @Override - public boolean matches(Method method, Class targetClass) { - return Objects.nonNull(AnnotationUtils.findAnnotation(method, DataLoadable.class)); - } - } -} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderAutoConfiguration.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderAutoConfiguration.java index 1666ad0..5141026 100644 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderAutoConfiguration.java +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderAutoConfiguration.java @@ -1,7 +1,9 @@ package com.github.lokic.dataloaderplus.spring; import com.github.lokic.dataloaderplus.core.DataLoaderFactory; +import com.github.lokic.dataloaderplus.core.DataLoaderFactoryImpl; import org.dataloader.DataLoaderOptions; +import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.context.annotation.Bean; @@ -15,36 +17,14 @@ @Configuration public class DataLoaderAutoConfiguration { - - @Role(BeanDefinition.ROLE_INFRASTRUCTURE) - @Bean - public DataLoadableBeanFactoryPointcutAdvisor dataLoadableBeanFactoryPointcutAdvisor() { - DataLoadableBeanFactoryPointcutAdvisor advisor = new DataLoadableBeanFactoryPointcutAdvisor(); - advisor.setAdvice(dataLoadableInterceptor()); - advisor.setOrder(LOWEST_PRECEDENCE); - return advisor; - } - - @Role(BeanDefinition.ROLE_INFRASTRUCTURE) @Bean - public DataLoaderInterceptor dataLoadableInterceptor() { - return new DataLoaderInterceptor(dataLoaderTemplateManager()); + public DataLoaderPostProcessor dataLoaderPostProcessor(DataLoaderFactory dataLoaderFactory) { + return new DataLoaderPostProcessor(dataLoaderFactory); } @Bean - public DataLoaderTemplateFactory dataLoaderTemplateManager() { - return new DataLoaderTemplateFactory(DataLoaderOptions.newOptions(), dataLoaderFactory()); + public DataLoaderFactory dataLoaderFactory(AutowireCapableBeanFactory autowireCapableBeanFactory) { + return new SpringDataLoaderFactory(autowireCapableBeanFactory); } - @Bean - public DataLoaderFactory dataLoaderFactory() { - return new DataLoaderFactory(); - } - - @Bean - public BatchLoaderBeanPostProcessor dataLoaderTemplateBeanPostProcessor() { - return new BatchLoaderBeanPostProcessor(); - } - - } diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderInterceptor.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderInterceptor.java index 5579237..1edb52f 100644 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderInterceptor.java +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderInterceptor.java @@ -17,10 +17,10 @@ public class DataLoaderInterceptor implements MethodInterceptor { private final Map attributeMapping = new ConcurrentHashMap<>(); - private final DataLoaderTemplateFactory manager; + private final DataLoaderTemplateFactory factory; - public DataLoaderInterceptor(DataLoaderTemplateFactory manager) { - this.manager = manager; + public DataLoaderInterceptor(DataLoaderTemplateFactory factory) { + this.factory = factory; } @Override @@ -34,7 +34,7 @@ public Object invoke(MethodInvocation invocation) throws Throwable { throw new IllegalArgumentException("return type need CompletableFuture"); }; DataLoadableAttribute attribute = attributeMapping.computeIfAbsent(invocation.getMethod(), this::parseAttribute); - DataLoaderTemplate template = manager.createTemplate(attribute); + DataLoaderTemplate template = factory.createTemplate(attribute); return template.using(RegistryManager.getRegistry(), callback); } diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderPostProcessor.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderPostProcessor.java new file mode 100644 index 0000000..e81bfd1 --- /dev/null +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderPostProcessor.java @@ -0,0 +1,26 @@ +package com.github.lokic.dataloaderplus.spring; + +import com.github.lokic.dataloaderplus.core.DataLoaderFactory; +import com.github.lokic.dataloaderplus.spring.annotation.DataLoadable; +import org.dataloader.DataLoaderOptions; +import org.springframework.aop.Pointcut; +import org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor; +import org.springframework.aop.support.DefaultPointcutAdvisor; +import org.springframework.beans.factory.InitializingBean; + +public class DataLoaderPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor implements InitializingBean { + + private final DataLoaderTemplateFactory dataLoaderTemplateFactory; + + public DataLoaderPostProcessor(DataLoaderFactory dataLoaderFactory) { + this.dataLoaderTemplateFactory = new DataLoaderTemplateFactory(DataLoaderOptions.newOptions(), dataLoaderFactory); + } + + @Override + public void afterPropertiesSet() throws Exception { + Pointcut pointcut = new MethodAnnotationPointcut(DataLoadable.class); + this.advisor = new DefaultPointcutAdvisor(pointcut, new DataLoaderInterceptor(dataLoaderTemplateFactory)); + } + + +} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderRegistrar.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderRegistrar.java index 6e7b53e..8ab52d7 100644 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderRegistrar.java +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderRegistrar.java @@ -1,103 +1,27 @@ package com.github.lokic.dataloaderplus.spring; -import com.github.lokic.dataloaderplus.core.MultiKeyMappedBatchLoader; -import com.github.lokic.dataloaderplus.core.annotation.DataLoaderMapping; -import com.github.lokic.dataloaderplus.core.kits.Types; +import com.github.lokic.custom.registrar.ProxyFactoryBean; +import com.github.lokic.custom.registrar.ProxyRegistrar; +import com.github.lokic.dataloaderplus.core.annotation.DataLoaderService; import com.github.lokic.dataloaderplus.spring.annotation.EnableDataLoader; -import lombok.SneakyThrows; -import org.springframework.aop.config.AopConfigUtils; -import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition; -import org.springframework.beans.factory.config.BeanDefinition; -import org.springframework.beans.factory.support.AbstractBeanDefinition; -import org.springframework.beans.factory.support.BeanDefinitionRegistry; -import org.springframework.beans.factory.support.RootBeanDefinition; -import org.springframework.context.ResourceLoaderAware; -import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; -import org.springframework.core.annotation.AnnotationUtils; -import org.springframework.core.io.ResourceLoader; -import org.springframework.core.type.AnnotationMetadata; -import java.lang.reflect.Method; -import java.util.*; +import java.lang.annotation.Annotation; -public class DataLoaderRegistrar implements ResourceLoaderAware, ImportBeanDefinitionRegistrar { - - private ResourceLoader resourceLoader; +public class DataLoaderRegistrar extends ProxyRegistrar { @Override - public void setResourceLoader(ResourceLoader resourceLoader) { - this.resourceLoader = resourceLoader; + protected Class getEnableAnnotationType() { + return EnableDataLoader.class; } - @Override - public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { - // enable proxyTargetClass - AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); - - Set basePackages = getBasePackages(importingClassMetadata); - - DataLoaderServiceScanner scanner = new DataLoaderServiceScanner(registry); - scanner.setResourceLoader(this.resourceLoader); - scanner.doScan(basePackages.toArray(new String[0])); - - List>> batchLoaderClasses = parseBatchLoaderClasses(scanner, registry, basePackages); - for (Class> batchLoaderClass : batchLoaderClasses) { - registerToSpring(registry, batchLoaderClass); - } - + protected Class getClassAnnotationType() { + return DataLoaderService.class; } - @SneakyThrows - private List>> parseBatchLoaderClasses(DataLoaderServiceScanner scanner, BeanDefinitionRegistry registry, Set basePackages) { - List>> batchLoaderClasses = new ArrayList<>(); - for (String basePackage : basePackages) { - Set candidateComponents = scanner.findCandidateComponents(basePackage); - for (BeanDefinition candidateComponent : candidateComponents) { - if (candidateComponent instanceof AnnotatedBeanDefinition) { - AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent; - Method[] methods = Class.forName(beanDefinition.getBeanClassName()).getDeclaredMethods(); - for (Method method : methods) { - DataLoaderMapping dataLoaderMapping = AnnotationUtils.findAnnotation(method, DataLoaderMapping.class); - if (dataLoaderMapping != null) { - Class> batchLoaderClass = dataLoaderMapping.batchLoader(); - batchLoaderClasses.add(batchLoaderClass); - } - } - } - } - } - return batchLoaderClasses; - } - - - private void registerToSpring(BeanDefinitionRegistry registry, Class clazz) { - RootBeanDefinition beanDefinition = new RootBeanDefinition(); - beanDefinition.setBeanClass(clazz); - beanDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR); - beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); - beanDefinition.setPrimary(true); - // 此处必须是原始class的名字，后面字节码增强之后，实现的类名会改变 - registry.registerBeanDefinition(clazz.getName(), beanDefinition); - } - - /** - * 生成basePackages - * - * @param importingClassMetadata - * @return - */ - private Set getBasePackages(AnnotationMetadata importingClassMetadata) { - Set basePackages = new HashSet<>(); - Map annotationAttributes = importingClassMetadata.getAnnotationAttributes(EnableDataLoader.class.getName()); - String[] basePackagesAttr = (String[]) annotationAttributes.get("basePackages"); - if (basePackagesAttr == null || basePackagesAttr.length == 0) { - basePackages.add( - Types.getPackageName(importingClassMetadata.getClassName())); - } else { - basePackages.addAll(Arrays.asList(basePackagesAttr)); - } - return basePackages; + @Override + protected Class getFactoryBeanType() { + return DataLoaderServiceFactory.class; } } diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactory.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactory.java new file mode 100644 index 0000000..c4bb619 --- /dev/null +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactory.java @@ -0,0 +1,17 @@ +package com.github.lokic.dataloaderplus.spring; + +import com.github.lokic.custom.registrar.ProxyFactoryBean; +import com.github.lokic.dataloaderplus.core.ExDataLoaderRegistry; +import lombok.NonNull; + +public class DataLoaderServiceFactory extends ProxyFactoryBean { + + public DataLoaderServiceFactory(@NonNull Class innerClass) { + super(innerClass); + } + + @Override + public Object getObject(Class clazz) { + return ExDataLoaderRegistry.getService(clazz); + } +} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactoryBean.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactoryBean.java deleted file mode 100644 index b3e351c..0000000 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceFactoryBean.java +++ /dev/null @@ -1,41 +0,0 @@ -package com.github.lokic.dataloaderplus.spring; - -import com.github.lokic.dataloaderplus.core.ExDataLoaderRegistry; -import lombok.SneakyThrows; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.FactoryBean; - -/** - * 基于 @{@link com.github.lokic.dataloaderplus.core.annotation.DataLoaderService} 注解的接口的实现类工厂 - * - * @param - */ -@Slf4j -public class DataLoaderServiceFactoryBean implements FactoryBean { - - private final Class innerClass; - - public DataLoaderServiceFactoryBean(Class innerClass) { - this.innerClass = innerClass; - } - - @SuppressWarnings("unchecked") - @Override - public T getObject() throws Exception { - if (!innerClass.isInterface()) { - throw new IllegalArgumentException("only support interface"); - } - return (T) ExDataLoaderRegistry.getService(innerClass); - } - - @SneakyThrows - @Override - public Class getObjectType() { - return innerClass; - } - - @Override - public boolean isSingleton() { - return true; - } -} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceScanner.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceScanner.java deleted file mode 100644 index 35fe5d8..0000000 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/DataLoaderServiceScanner.java +++ /dev/null @@ -1,44 +0,0 @@ -package com.github.lokic.dataloaderplus.spring; - -import com.github.lokic.dataloaderplus.core.annotation.DataLoaderService; -import lombok.SneakyThrows; -import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition; -import org.springframework.beans.factory.config.BeanDefinitionHolder; -import org.springframework.beans.factory.support.BeanDefinitionRegistry; -import org.springframework.beans.factory.support.GenericBeanDefinition; -import org.springframework.context.annotation.ClassPathBeanDefinitionScanner; -import org.springframework.core.type.filter.AnnotationTypeFilter; - -import java.util.Set; - -public final class DataLoaderServiceScanner extends ClassPathBeanDefinitionScanner { - - public DataLoaderServiceScanner(BeanDefinitionRegistry registry) { - super(registry); - } - - @Override - public void registerDefaultFilters() { - this.addIncludeFilter(new AnnotationTypeFilter(DataLoaderService.class)); - } - - @SneakyThrows - @Override - public Set doScan(String... basePackages) { - Set beanDefinitions = super.doScan(basePackages); - for (BeanDefinitionHolder holder : beanDefinitions) { - GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition(); - definition.getConstructorArgumentValues() - .addIndexedArgumentValue(0, Class.forName(definition.getBeanClassName())); - definition.setBeanClass(DataLoaderServiceFactoryBean.class); - } - return beanDefinitions; - } - - @Override - public boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { - return beanDefinition.getMetadata().isInterface() - && beanDefinition.getMetadata().hasAnnotation(DataLoaderService.class.getName()); - } - -} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/MethodAnnotationPointcut.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/MethodAnnotationPointcut.java new file mode 100644 index 0000000..358ed17 --- /dev/null +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/MethodAnnotationPointcut.java @@ -0,0 +1,22 @@ +package com.github.lokic.dataloaderplus.spring; + +import org.springframework.aop.support.StaticMethodMatcherPointcut; +import org.springframework.core.annotation.AnnotationUtils; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; +import java.util.Objects; + +public class MethodAnnotationPointcut extends StaticMethodMatcherPointcut { + + private final Class methodAnnotationType; + + public MethodAnnotationPointcut(Class methodAnnotationType) { + this.methodAnnotationType = methodAnnotationType; + } + + @Override + public boolean matches(Method method, Class targetClass) { + return Objects.nonNull(AnnotationUtils.findAnnotation(method, methodAnnotationType)); + } +} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/SpringDataLoaderFactory.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/SpringDataLoaderFactory.java new file mode 100644 index 0000000..584a6fb --- /dev/null +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/SpringDataLoaderFactory.java @@ -0,0 +1,20 @@ +package com.github.lokic.dataloaderplus.spring; + +import com.github.lokic.dataloaderplus.core.AbstractDataLoaderFactory; +import com.github.lokic.dataloaderplus.core.MultiKeyMappedBatchLoader; +import org.springframework.beans.factory.config.AutowireCapableBeanFactory; + +public class SpringDataLoaderFactory extends AbstractDataLoaderFactory { + + private final AutowireCapableBeanFactory beanFactory; + + public SpringDataLoaderFactory(AutowireCapableBeanFactory beanFactory) { + this.beanFactory = beanFactory; + } + + @Override + public > T createInstance(Class batchLoaderType) { + return beanFactory.createBean(batchLoaderType); + } + +} diff --git a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/annotation/EnableDataLoader.java b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/annotation/EnableDataLoader.java index 6362af2..c38aed0 100644 --- a/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/annotation/EnableDataLoader.java +++ b/java-dataloader-plus-spring-boot-starter/src/main/java/com/github/lokic/dataloaderplus/spring/annotation/EnableDataLoader.java @@ -1,6 +1,7 @@ package com.github.lokic.dataloaderplus.spring.annotation; import com.github.lokic.dataloaderplus.spring.DataLoaderConfigurationSelector; +import org.springframework.context.annotation.EnableAspectJAutoProxy; import org.springframework.context.annotation.Import; import java.lang.annotation.*; @@ -8,6 +9,7 @@ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Documented +@EnableAspectJAutoProxy(proxyTargetClass = true) @Import(DataLoaderConfigurationSelector.class) public @interface EnableDataLoader { diff --git a/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/DataLoadableTest.java b/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/DataLoadableTest.java index caf1240..b0f43b7 100644 --- a/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/DataLoadableTest.java +++ b/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/DataLoadableTest.java @@ -1,12 +1,16 @@ package com.github.lokic.dataloaderplus.spring; +import com.github.lokic.dataloaderplus.core.AbstractDataLoaderFactory; +import com.github.lokic.dataloaderplus.core.DataLoaderFactoryImpl; import com.github.lokic.dataloaderplus.spring.annotation.EnableDataLoader; import com.github.lokic.dataloaderplus.spring.appservice.UserAppService; import com.github.lokic.dataloaderplus.spring.client.UserAddressBatchLoader; import com.github.lokic.dataloaderplus.spring.client.UserNameBatchLoader; import com.github.lokic.dataloaderplus.spring.service.UserService; import com.github.lokic.javaplus.CompletableFutures; +import lombok.SneakyThrows; import org.junit.Assert; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mockito; @@ -15,6 +19,9 @@ import org.springframework.context.annotation.Import; import org.springframework.test.context.junit4.SpringRunner; +import java.lang.reflect.Field; +import java.util.Map; + @RunWith(SpringRunner.class) @EnableDataLoader @Import({UserAppService.class, UserService.class}) @@ -23,8 +30,8 @@ public class DataLoadableTest { @Autowired private UserAppService userAppService; - @SpyBean - private DataLoaderInterceptor dataLoaderInterceptor; + @Autowired + private SpringDataLoaderFactory springDataLoaderFactory; @SpyBean private UserNameBatchLoader userNameBatchLoader; @@ -32,6 +39,17 @@ public class DataLoadableTest { @SpyBean private UserAddressBatchLoader userAddressBatchLoader; + @SuppressWarnings("unchecked") + @SneakyThrows + @Before + public void init() { + Field field = AbstractDataLoaderFactory.class.getDeclaredField("dataLoaderCreators"); + field.setAccessible(true); + Map map = (Map) field.get(springDataLoaderFactory); + map.put(UserNameBatchLoader.class, userNameBatchLoader); + map.put(UserAddressBatchLoader.class, userAddressBatchLoader); + } + @Test(expected = IllegalArgumentException.class) public void test_DataLoadable_throw_in_template() { CompletableFutures.join(userAppService.getThrow("123")); @@ -49,8 +67,6 @@ public void test_DataLoadable_get_in_template() { @Test public void test_DataLoadable_getNew_in_template() throws Throwable { String res = CompletableFutures.join(userAppService.getNew("123")); - Mockito.verify(dataLoaderInterceptor, Mockito.times(2)) - .invoke(Mockito.any()); Mockito.verify(userNameBatchLoader, Mockito.times(1)) .doLoad(Mockito.any(), Mockito.any()); Mockito.verify(userAddressBatchLoader, Mockito.times(1)) @@ -61,8 +77,6 @@ public void test_DataLoadable_getNew_in_template() throws Throwable { @Test public void test_DataLoadable_getRepeatNew_in_template() throws Throwable { CompletableFutures.join(userAppService.getRepeatNew("123")); - Mockito.verify(dataLoaderInterceptor, Mockito.times(2)) - .invoke(Mockito.any()); Mockito.verify(userNameBatchLoader, Mockito.times(2)) .doLoad(Mockito.any(), Mockito.any()); } @@ -70,8 +84,6 @@ public void test_DataLoadable_getRepeatNew_in_template() throws Throwable { @Test public void test_DataLoadable_getNest_in_template() throws Throwable { CompletableFutures.join(userAppService.getNest("123")); - Mockito.verify(dataLoaderInterceptor, Mockito.times(2)) - .invoke(Mockito.any()); Mockito.verify(userNameBatchLoader, Mockito.times(1)) .doLoad(Mockito.any(), Mockito.any()); } diff --git a/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/EnableDataLoaderTest.java b/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/EnableDataLoaderTest.java index 87d61b7..c49703a 100644 --- a/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/EnableDataLoaderTest.java +++ b/java-dataloader-plus-spring-boot-starter/src/test/java/com/github/lokic/dataloaderplus/spring/EnableDataLoaderTest.java @@ -24,9 +24,6 @@ public class EnableDataLoaderTest { public void test_inject() { Assertions.assertThat(context.getBeansOfType(UserClient.class)).hasSize(1); Assertions.assertThat(context.getBeansOfType(DataLoaderFactory.class)).hasSize(1); - Assertions.assertThat(context.getBeansOfType(DataLoaderTemplateFactory.class)).hasSize(1); - Assertions.assertThat(context.getBeansOfType(UserNameBatchLoader.class)).hasSize(1); - Assertions.assertThat(context.getBeansOfType(UserAddressBatchLoader.class)).hasSize(1); } diff --git a/pom.xml b/pom.xml index fc85e66..4b95f56 100644 --- a/pom.xml +++ b/pom.xml @@ -43,8 +43,17 @@ UTF-8 UTF-8 0.0.1-SNAPSHOT + 1.18.18 + + + org.projectlombok + lombok + ${lombok.version} + + +