spring aop 的一个demo（未完，待完善）

最新推荐文章于 2020-12-19 15:02:06 发布

原创最新推荐文章于 2020-12-19 15:02:06 发布 · 136 阅读

0 ·

CC 4.0 BY-SA版权

本文探讨了在Java中如何根据不同方法的需求选择性地从缓存或数据库读取数据。通过自定义注解和代理工厂实现了灵活的读取策略。

假设我们有这样的一个场景：对于一个类的众多方法，有些方法需要从缓存读取数据,有些则需要直接从数据库读取数据。怎样实现呢？

实现方案有多种。下面我说下常见的几种实现方案：

1、直接采用spring xml、或者 annotation AOP完成。但个人认为这种方案似乎有点不是很完美。

原因： ①、如果只有针对这个类做切面拦截,这种方案是没有问题的,只需对需要走DB（or 缓存,两者择一）的方法配置切面。

　　　　②、那如果是多个类呢？统一做一个切面,对指定方法拦截,如selectXXX。但,还要考虑个特殊场景,每个人的代码风格不一致,你不能限制

　　　　别人的风格,查询他就偏偏用queryXXX来命令。你能拦截到么？

2、采用 ProxyFactory 拦截处理, 并且用java自定义的annotation来作为是否需要走缓存的方法唯一标识。（实现得不是很好,后期会持续优化,见谅）

看下代码

1）自定义注解,标识是否需要走缓存

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheAnnotition {

}

2）接口定义

public interface UserReadService {
    
    @CacheAnnotition
    public UserInfo getUserInfoById(Long id);
    
    public UserInfo getUserInfoByName(String name);
}
@Component("userReadService")
public class UserReadServiceImpl implements UserReadService {

    @Override
    public UserInfo getUserInfoById(Long id) {
        System.out.println("获取用户信息");
        return null;
    }
    
    @Override
    public UserInfo getUserInfoByName(String name) {
        // TODO Auto-generated method stub
        return null;
    }

}

View Code

public interface PeopleReadService {
    
    @CacheAnnotition
    public UserInfo getPeopleInfoById(Long id);
    
    public UserInfo getPeopleInfoByName(String name);
}
@Component("peopleReadService")
public class PeopleReadServiceImpl implements PeopleReadService {

    @Override
    public UserInfo getPeopleInfoById(Long id) {
        System.out.println("getPeopleInfoById : 获取用户信息");
        return null;
    }

    @Override
    public UserInfo getPeopleInfoByName(String name) {
        // TODO Auto-generated method stub
        return null;
    }

}

View Code

3）拦截处理核心逻辑

public class ProxyFactoryDemo {

    public static Map<String, Class<?>> beanMap = new HashMap<String, Class<?>>();
    public static Map<String, Class<?>> instanceMap = new HashMap<String, Class<?>>();

    public static List<Object> proxyObjs = new ArrayList<Object>();

    static {
        beanMap.put("userReadService", UserReadService.class);
        beanMap.put("peopleReadService", PeopleReadService.class);

        instanceMap.put("userReadService", UserReadServiceImpl.class);
        instanceMap.put("peopleReadService", PeopleReadServiceImpl.class);
    }

    public static void main(String[] args) throws Exception {
        initProxyObjs();
        
        for(Object proxy : proxyObjs) {
            if (proxy instanceof UserReadService) {
                UserReadService u = (UserReadService)proxy;
                u.getUserInfoById(null);
                u.getUserInfoByName(null);
            } else if(proxy instanceof PeopleReadService) {
                PeopleReadService p = (PeopleReadService)proxy;
                p.getPeopleInfoById(null);
                p.getPeopleInfoByName(null);
            }
        }
    }

    public static void initProxyObjs() throws InstantiationException, IllegalAccessException {
        Iterator<String> it = beanMap.keySet().iterator();
        while (it.hasNext()) {
            String beanName = it.next();
            Class<?> beanClass = instanceMap.get(beanName);
            Object proxy = getProxy(beanClass.newInstance(), beanMap.get(beanName), beanName);
            proxyObjs.add(proxy);
        }
    }

    public static Object getProxy(final Object target, Class<?> aClass, final String beanName) {

        ProxyFactory factory = new ProxyFactory();

        factory.addInterface(aClass);
        factory.setTarget(target);
        factory.setOpaque(true);
        factory.addAdvice(new MethodInterceptor() {

            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("start");
                if (invocation.getMethod().isAnnotationPresent(CacheAnnotition.class)) {
                    System.out.println(invocation.getMethod().getName() + "需要走缓存");
                } else {
                    System.out.println(invocation.getMethod().getName() + "不需要走缓存");
                }
                Object obj = invocation.proceed();
                System.out.println("end");
                return obj;
            }
        });

        return factory.getProxy(factory.getClass().getClassLoader());
    }
}