Java基础 05理解可配置AOP框架177

初探：理解可配置的AOP框架
补充知识：
1、AOP的概念：Aspect Oriented Programming（面向切面编程）
2、可配置 AOP框架实现

AOP使用场景
AOP用来封装横切关注点，具体可以在下面的场景中使用:
权限
缓存
错误处理
调试
记录跟踪
持久化
同步
事务
等等。。
先写个接口
IManager接口

package com.vince.aop;

/**
 * Created by vince on 2017/6/14.
 */
public interface IManager {
    public void add(String item);
}

接口的实现类

package com.vince.aop;

import java.util.ArrayList;

/**
 * Created by vince on 2017/6/14.
 */
public class IManagerImpl implements IManager {
    private ArrayList<String> list = new ArrayList<>();

    @Override
    public void add(String item) {
        //System.out.println("add start "+ System.currentTimeMillis());
        list.add(item);
        System.out.println(item);
        //System.out.println("add end "+ System.currentTimeMillis());
    }
}

把这个外围的记录日志的代码 即不是真正的业务代码 只是测试用的类似的
挪到代理里面去完成
就是面向切面编程 AOP
把侧面 切面的东西 挪到代理里面
让真正的业务代码只关注 业务的本身 而不需要关注外围的东西

下面我们自己写一个简洁版的AOP框架

前面的两个是·IManager是核心业务接口
和IManagerImpl核心业务类
先写个接口Advice
有前通知和后后通知方法

package com.vince.aop;

/**
 * Created by vince on 2017/6/14.
 * 通知
 */
public interface Advice {

    public void beforeAdvice();
    public void afterAdvice();
}

然后有一个实现类 专门记录日志的一个类

package com.vince.aop;

/**
 * Created by vince on 2017/6/14.
 * 切面的实现类
 */
public class LogAdvice implements Advice{
    @Override
    public void beforeAdvice() {
        System.out.println("start time:"+System.currentTimeMillis());
    }

    @Override
    public void afterAdvice() {
        System.out.println("end time:"+System.currentTimeMillis());
    }
}

写配置文件

bean.target=com.vince.aop.IManagerImpl
bean.advice=com.vince.aop.LogAdvice
bean=com.vince.aop.ProxyFactoryBean

实现动态代理 要写一个创建代理的类
实际上就是通过这个创建代理对象的类
把两个毫不相关的类（IManagerImpl和LogAdvice）连接起来

package com.vince.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by vince on 2017/6/14.
 */
public class ProxyFactoryBean implements InvocationHandler {
    private Object target;
    private Advice advice;

    public Object getProxy(){
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader()
                , target.getClass().getInterfaces()
                , this);
        return proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        advice.beforeAdvice();
        Object obj = method.invoke(target, args);
        advice.afterAdvice();
        return obj;
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Advice getAdvice() {
        return advice;
    }

    public void setAdvice(Advice advice) {
        this.advice = advice;
    }
}

还有一个读取配置文件 装配对象 的类 上一个博客写这个类时使用静态代码块实现的
现在换一种 我们使用构造器实现读取配置文件
然后写工厂类实现可配置编程

package com.vince.aop;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * Created by vince on 2017/6/14.
 * AOP框架的简单实现
 */
public class BeanFactory {

    Properties prop = new Properties();
    public BeanFactory(InputStream in){//这样可以不一定非要读一个文件 其他文件 只要传进来流 都可以绑定
        try {
            prop.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取一个bean实例
     * @param name
     * @return
     */
    public Object getBean(String name){
        String className = prop.getProperty(name);
        Object bean = null;
        try {
            //获取ProxyFactoryBean的class对象
            Class<?> aClass = Class.forName(className);
            bean = aClass.newInstance();//实例化对象
            //根据配置文件实例化target和advice对象
            Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();
            Object advice = Class.forName(prop.getProperty(name + ".advice")).newInstance();
            //通过内省实现对 ProxyFactoryBean的属性赋值
            BeanInfo beanInfo = Introspector.getBeanInfo(aClass);
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for(PropertyDescriptor pd: propertyDescriptors){
                String propertyName = pd.getName();
                Method writeMethod = pd.getWriteMethod();
                if("target".equals(propertyName)){
                    writeMethod.invoke(bean,target);
                }else if("advice".equals(propertyName)){
                    writeMethod.invoke(bean,advice);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IntrospectionException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return bean;
    }
}

最后来个测试

package com.vince.aop;

import org.junit.Test;

import java.io.InputStream;

/**
 * Created by vince on 2017/6/14.
 */
public class AOPTest {
    @Test
    public void test(){
        //1读取配置 文件
        InputStream in = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/vince/aop/bean.properties");
        //2创建Bean的工厂对象
        BeanFactory beanFactory = new BeanFactory(in);
        //3获取代理对象
        ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) beanFactory.getBean("bean");
        IManager proxy = (IManager) proxyFactoryBean.getProxy();
        proxy.add("我是一只猫");

    }
}