sss

src/main/java/example/aop/proxy/Main.java

@@ -0,0 +1,21 @@
+package example.aop.proxy;
+
+import com.sysu.admin.support.system.user.UserRepository;
+import org.springframework.aop.framework.ProxyFactory;
+
+public class Main {
+    public static void main(String[] args) {
+
+
+        ProxyFactory result = new ProxyFactory();
+        result.setTarget(new MyRepositoryExecutor<>());
+
+        result.setInterfaces(UserRepository.class);
+
+        result.addAdvice(new MyMethodInterceptor());
+
+        UserRepository repository = (UserRepository)result.getProxy(org.springframework.util.ClassUtils.getDefaultClassLoader());
+        repository.findByUsername("123");
+        repository.enable(0,0L);
+    }
+}

src/main/java/example/aop/proxy/MyMethodInterceptor.java

@@ -0,0 +1,40 @@
+package example.aop.proxy;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.springframework.core.convert.support.DefaultConversionService;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.core.support.RepositoryFactorySupport;
+
+public class MyMethodInterceptor implements MethodInterceptor {
+    @Override
+    public Object invoke(MethodInvocation invocation) throws Throwable {
+        Query query = invocation.getMethod().getAnnotation(Query.class);
+        if(query != null) {
+            System.out.println("is native: " + query.nativeQuery());
+            System.out.println("sql = " + query.value());
+        }else{
+            System.out.println("name = " + invocation.getMethod().getName());
+        }
+        return isBaseType(invocation.getMethod().getReturnType()) ? 0 : null;
+    }
+
+    /**
+     * 判断object是否为基本类型
+     * @return
+     */
+    public static boolean isBaseType(Class clazz) {
+        String className = clazz.getTypeName();
+        if (className.equals("int") ||
+                className.equals("byte") ||
+                className.equals("long") ||
+                className.equals("double") ||
+                className.equals("float") ||
+                className.equals("char") ||
+                className.equals("short") ||
+                className.equals("boolean")) {
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/example/aop/proxy/MyRepositoryExecutor.java

@@ -0,0 +1,259 @@
+package example.aop.proxy;
+
+import com.querydsl.core.types.OrderSpecifier;
+import com.querydsl.core.types.Predicate;
+import com.querydsl.jpa.impl.JPADeleteClause;
+import com.querydsl.jpa.impl.JPAQuery;
+import com.querydsl.jpa.impl.JPAUpdateClause;
+import com.xiesx.fastboot.core.jpa.JpaPlusRepository;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.support.CrudMethodMetadata;
+
+import java.util.List;
+import java.util.Optional;
+
+public class MyRepositoryExecutor <T,ID> implements JpaPlusRepository<T, ID> {
+    @Override
+    public T findOne(ID id) {
+        return null;
+    }
+
+    @Override
+    public Optional<T> findOne(Predicate predicate) {
+        return Optional.empty();
+    }
+
+    @Override
+    public List<T> findAll(Predicate predicate) {
+        return null;
+    }
+
+    @Override
+    public List<T> findAll(Predicate predicate, Sort sort) {
+        return null;
+    }
+
+    @Override
+    public Iterable<T> findAll(Predicate predicate, OrderSpecifier<?>... orders) {
+        return null;
+    }
+
+    @Override
+    public Iterable<T> findAll(OrderSpecifier<?>... orders) {
+        return null;
+    }
+
+    @Override
+    public Page<T> findAll(Predicate predicate, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public long count(Predicate predicate) {
+        return 0;
+    }
+
+    @Override
+    public boolean exists(Predicate predicate) {
+        return false;
+    }
+
+    @Override
+    public <S> Page<S> findAll(JPAQuery<S> query, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public <S> Page<S> findAllNoCount(JPAQuery<S> query, Pageable pageable, long count) {
+        return null;
+    }
+
+    @Override
+    public <O extends T> List<O> insert(O... entities) {
+        return null;
+    }
+
+    @Override
+    public int insertOrUpdate(T... entities) {
+        return 0;
+    }
+
+    @Override
+    public int delete(ID... ids) {
+        return 0;
+    }
+
+    @Override
+    public int delete(JPADeleteClause delete) {
+        return 0;
+    }
+
+    @Override
+    public int delete(JPADeleteClause delete, Predicate... predicate) {
+        return 0;
+    }
+
+    @Override
+    public int update(JPAUpdateClause update) {
+        return 0;
+    }
+
+    @Override
+    public int update(JPAUpdateClause update, Predicate... predicate) {
+        return 0;
+    }
+
+    @Override
+    public void setRepositoryMethodMetadata(CrudMethodMetadata crudMethodMetadata) {
+
+    }
+
+    @Override
+    public List<T> findAll() {
+        return null;
+    }
+
+    @Override
+    public List<T> findAll(Sort sort) {
+        return null;
+    }
+
+    @Override
+    public Page<T> findAll(Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public List<T> findAllById(Iterable<ID> ids) {
+        return null;
+    }
+
+    @Override
+    public long count() {
+        return 0;
+    }
+
+    @Override
+    public void deleteById(ID id) {
+
+    }
+
+    @Override
+    public void delete(T entity) {
+
+    }
+
+    @Override
+    public void deleteAll(Iterable<? extends T> entities) {
+
+    }
+
+    @Override
+    public void deleteAll() {
+
+    }
+
+    @Override
+    public <S extends T> S save(S entity) {
+        return null;
+    }
+
+    @Override
+    public <S extends T> List<S> saveAll(Iterable<S> entities) {
+        return null;
+    }
+
+    @Override
+    public Optional<T> findById(ID id) {
+        return Optional.empty();
+    }
+
+    @Override
+    public boolean existsById(ID id) {
+        return false;
+    }
+
+    @Override
+    public void flush() {
+
+    }
+
+    @Override
+    public <S extends T> S saveAndFlush(S entity) {
+        return null;
+    }
+
+    @Override
+    public void deleteInBatch(Iterable<T> entities) {
+
+    }
+
+    @Override
+    public void deleteAllInBatch() {
+
+    }
+
+    @Override
+    public T getOne(ID id) {
+        return null;
+    }
+
+    @Override
+    public <S extends T> Optional<S> findOne(Example<S> example) {
+        return Optional.empty();
+    }
+
+    @Override
+    public <S extends T> List<S> findAll(Example<S> example) {
+        return null;
+    }
+
+    @Override
+    public <S extends T> List<S> findAll(Example<S> example, Sort sort) {
+        return null;
+    }
+
+    @Override
+    public <S extends T> Page<S> findAll(Example<S> example, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public <S extends T> long count(Example<S> example) {
+        return 0;
+    }
+
+    @Override
+    public <S extends T> boolean exists(Example<S> example) {
+        return false;
+    }
+
+    @Override
+    public Optional<T> findOne(Specification<T> spec) {
+        return Optional.empty();
+    }
+
+    @Override
+    public List<T> findAll(Specification<T> spec) {
+        return null;
+    }
+
+    @Override
+    public Page<T> findAll(Specification<T> spec, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public List<T> findAll(Specification<T> spec, Sort sort) {
+        return null;
+    }
+
+    @Override
+    public long count(Specification<T> spec) {
+        return 0;
+    }
+}