custom annotation spring registrar

java-dataloader-plus-core/pom.xml

@@ -16,10 +16,9 @@
         <maven.compiler.target>8</maven.compiler.target>
         <dataloader.version>3.1.0</dataloader.version>
         <logback.version>1.1.11</logback.version>
-        <lombok.version>1.18.18</lombok.version>
         <junit.version>4.11</junit.version>
         <mockito.version>3.1.0</mockito.version>
-        <java-plus.version>0.0.10</java-plus.version>
+        <java-plus.version>0.1.4</java-plus.version>
     </properties>
 
     <dependencies>
@@ -28,11 +27,6 @@
             <artifactId>java-dataloader</artifactId>
             <version>${dataloader.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>${lombok.version}</version>
-        </dependency>
         <dependency>
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-classic</artifactId>

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<Class<? extends MultiKeyMappedBatchLoader<?, ?>>, MultiKeyMappedBatchLoader<?, ?>> dataLoaderCreators = new ConcurrentHashMap<>();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends MultiKeyMappedBatchLoader<?, ?>> T getInstance(Class<T> batchLoaderType) {
+        return (T) dataLoaderCreators.computeIfAbsent(batchLoaderType, this::createInstance);
+    }
+
+    public abstract <T extends MultiKeyMappedBatchLoader<?, ?>> T createInstance(Class<T> batchLoaderType);
+
+    @SneakyThrows
+    @Override
+    public DataLoader<?, ?> create(Class<? extends MultiKeyMappedBatchLoader<?, ?>> batchLoaderType, DataLoaderOptions options) {
+        MultiKeyMappedBatchLoader<?, ?> loader = getInstance(batchLoaderType);
+        return org.dataloader.DataLoaderFactory.newMappedDataLoader(loader, options);
+    }
+
+}

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<String, MultiKeyMappedBatchLoader<?, ?>> 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 extends MultiKeyMappedBatchLoader<?, ?>> T getInstance(Class<T> 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<? extends MultiKeyMappedBatchLoader<?, ?>> batchLoaderType, DataLoaderOptions options) {
+        MultiKeyMappedBatchLoader<?, ?> loader = getInstance(batchLoaderType);
         return org.dataloader.DataLoaderFactory.newMappedDataLoader(loader, options);
     }
-
 }

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 extends MultiKeyMappedBatchLoader<?, ?>> T createInstance(Class<T> batchLoaderType) {
+        return batchLoaderType.getConstructor().newInstance();
+    }
+}

java-dataloader-plus-core/src/main/java/com/github/lokic/dataloaderplus/core/ExDataLoaderRegistry.java

@@ -53,8 +53,8 @@ protected ExDataLoaderRegistry(@NonNull ExDataLoaderRegistry exRegistry) {
      * @param <V>
      * @return
      */
-    public <K, V> DataLoader<K, V> getOrRegisterDataLoader(Class<? extends MappedBatchLoaderWithContext<?, ?>> clazz) {
-        return registry.computeIfAbsent(clazz.getName(), key -> factory.create(key, options));
+    public <K, V> DataLoader<K, V> getOrRegisterDataLoader(Class<? extends MultiKeyMappedBatchLoader<?, ?>> clazz) {
+        return registry.computeIfAbsent(clazz.getName(), key -> factory.create(clazz, options));
     }
 
     public void dispatchAll() {

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;

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<Object, Object> map = (Map<Object, Object>) 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());
 

java-dataloader-plus-spring-boot-starter/pom.xml

@@ -36,6 +36,11 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.github.lokic</groupId>
+            <artifactId>custom-annotation-spring-registrar</artifactId>
+            <version>0.0.2</version>
+        </dependency>
     </dependencies>
 
 

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();
-    }
-
-
 }

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<Method, DataLoadableAttribute> 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);
     }
 

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));
+    }
+
+
+}