实现一个简单的AOP

提示：以下是本篇文章正文内容，下面案例可供参考

一、AOP是什么？

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二、一个简单的AOP实现

1.实现动态代理

代码如下（示例）：

package AOP;

/**
 * @author gc
 * @version 1.0
 */
public interface Imanger {
    public void add(String itrm);
}

package AOP;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @author gc
 * @version 1.0
 */
public class IMangerIP implements Imanger{
    List<String>list=new ArrayList<>();
    @Override
    public void add(String item) {
        list.add(item);
    }
}

package AOP;

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

/**
 * 动态代理
 * @author gc
 * @version 1.0
 */
public class ProxyFactory implements InvocationHandler {

    private Object target;//被代理的对象
    private Advice advice;//



    /**
     * 设置代理对象
     * @return
     */
    public Object getProxy(){
        /**利用的是反射Proxy.newProxyInstance()*/
        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.befor();
        Object invoke = method.invoke(target, args);
        advice.after();
        return invoke;
    }
    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;
    }
}

2.面向切面编程（这里是在添加开始和结束的时间）

代码如下（示例）：

package AOP;

/**
 * 通知
 * 切面编程的接口
 * @author gc
 * @version 1.0
 */
public interface Advice {
    public void befor();
    public void after();
}

package AOP;

/**
 * @author gc
 * @version 1.0
 */
public class LogAdvice implements Advice{
    @Override
    public void befor() {
        System.out.println("before Start:"+System.currentTimeMillis());
    }

    @Override
    public void after() {
        System.out.println("after End:"+System.currentTimeMillis());
    }
}

3.用一个工厂类将其进行初始化

package 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;

/**
 * @author gc
 * @version 1.0
 */
public class BeanFactory {
    Properties pop = new Properties();

    public BeanFactory(InputStream in) {
        try {
            pop.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public Object setFactory(String name) {
        Object bean = null;
        //获取key相对性的value值
        String beanValue = pop.getProperty(name);
        String targetValue = pop.getProperty(name + ".target");
        String adviceValue = pop.getProperty(name + ".advice");

        try {
            //获取Class对象
            Class<?> aClass = Class.forName(beanValue);  
            bean = aClass.newInstance();
            //将target和advice实例化
            Object target = Class.forName(targetValue).newInstance();
            Object advice = Class.forName(adviceValue).newInstance();
            //先获取类信息
            BeanInfo beanInfo = Introspector.getBeanInfo(aClass);
            //获取属性信息
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (int i = 0; i < propertyDescriptors.length; i++) {
                String name1 = propertyDescriptors[i].getName();
                Method writeMethod = propertyDescriptors[i].getWriteMethod();
                //设置(设置的是动态代理中的定义的那两个属性名)
                if ("target".equals(name1)) {
                    writeMethod.invoke(bean, target);
                } else if ("advice".equals(name1)) {
                    writeMethod.invoke(bean, advice);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IntrospectionException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return bean;
    }
}

5.然后就是测试了

package AOP;

import org.junit.Test;

import java.io.InputStream;

/**
 * @author gaochuang
 * @version 1.0
 */
public class AOPTest {
    @Test
    public void Test() {
        //加载配置文件
        InputStream in = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("AOP/bean.properties");
        //创建Bean工厂
        BeanFactory beanFactory = new BeanFactory(in);
        //获取代理对象
        ProxyFactory bean = (ProxyFactory) beanFactory.setFactory("bean");
        //获取的被代理的对象是IMangerIP
        Imanger proxy = (Imanger) bean.getProxy();
        proxy.add("我是小白");
    }
}

6.配置文件

bean.target=AOP.IMangerIP
bean.advice=AOP.LogAdvice
bean=AOP.ProxyFactory

---