AOP原理与自实现

AOP是一种面向切面编程的技术,要实现AOP就不得不提到Proxy模式，具体代理模式的例子能够参考 设计模式整理

因为代理模式都必须有一个统一的接口，咱们先来写一个接口

public interface Greeting {
    void sayHello(String name);
}

还有一个实现类，是实现了它的主要功能。

public class GreetingImpl implements Greeting {
    public void sayHello(String name) {
        System.out.println("Hello! " + name);
    }
}

再写一个代理类来代理它（在设计模式的例子中，咱们是在须要的时候，干重活的时候才建立实现类的实例，此处为直接建立）

public class GreetingProxy implements Greeting {
    //代理类对实现类的委托
    private GreetingImpl greetingImpl;

    public GreetingProxy(GreetingImpl greetingImpl) {
        this.greetingImpl = greetingImpl;
    }

    public void sayHello(String name) {
        befor();
        greetingImpl.sayHello(name);
        after();
    }
    private void befor() {
        System.out.println("Before");
    }
    private void after() {
        System.out.println("after");
    }
}

经过main方法对它具体调用

public class Client {
    public static void main(String[] args) {
        Greeting greetingProxy = new GreetingProxy(new GreetingImpl());
        greetingProxy.sayHello("Jack");
    }
}

运行结果

Before
Hello! Jack
after

这样咱们就对这一个实现类进行了环绕，但若是这样的实现类很是多怎么办呢？这个时候咱们就须要用到动态代理了。

public class DynamicProxy<T> implements InvocationHandler {
    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }
    //获取目标对象的代理类实例
    public T getProxy() {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),  //目标对象类的加载器
                target.getClass().getInterfaces(),  //目标对象类的接口数组（由于一个类可能有几个接口）
                this
        );
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target,args);
        after();
        return result;
    }
    private void before() {
        System.out.println("Before");
    }
    private void after() {
        System.out.println("After");
    }
}

main方法

public class Client {
    public static void main(String[] args) {
        Greeting greetingProxy = new DynamicProxy<Greeting>(new GreetingImpl()).getProxy();
        greetingProxy.sayHello("Jack");
    }
}

运行结果与以前的代理模式相同

Before
Hello! Jack
After

动态代理是经过反射来实现的，这里有一个Proxy.newProxyInstance，咱们来看一下它的源代码（带注释）

//代理类的构造器的参数类型数组
private static final Class<?>[] constructorParams =
    { InvocationHandler.class };

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    //要求动态代理类自己不为空，若是为空会抛出异常
    Objects.requireNonNull(h);
    //将接口数组克隆出来
    final Class<?>[] intfs = interfaces.clone();
    //启动Java安全管理器
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        //检查调用类是否有启动接口的Class实例的加载器的权限
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     * 建立代理类的Class实例
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            //检查调用类是否有该代理类的权限
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        //经过构造参数类型来获取代理类的具体某一个构造器
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        //代理类自己实例
        final InvocationHandler ih = h;
        //获取代理类Class实例的全部修饰符，并判断是否为public,若是不为public则经过cons.setAccessible(true)设置为能够访问
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        //经过该具体的构造器来构造代理类自己的实例，以前咱们有说过Class的newInstance只能经过无参构造器来构造，但此处是选择了具体的有参构造器构造
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

由以上代码可知，该动态代理必需要有接口才能代理，而不能代理没有接口的类。

没有接口的类，咱们能够使用CGLib来动态代理

要使用CGLib，先要在pom中加入它的引用

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

public class CGLibDynamicProxy<T> implements MethodInterceptor {
    private static CGLibDynamicProxy instance = new CGLibDynamicProxy();

    private CGLibDynamicProxy() {

    }

    /**
     * 经过单例模式获取代理类的实例
     * @return
     */
    public static CGLibDynamicProxy getInstance() {
        return instance;
    }

    /**
     * 经过实现类的Class实例跟代理类对象关联
     * @param cls
     * @return
     */
    public T getProxy(Class<T> cls) {
        return (T)Enhancer.create(cls,this);
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o,objects);
        after();
        return result;
    }
    private void before() {
        System.out.println("Before");
    }
    private void after() {
        System.out.println("After");
    }
}

main方法

public class Client {
    public static void main(String[] args) {
        Greeting greetingProxy = (Greeting) CGLibDynamicProxy.getInstance().getProxy(GreetingImpl.class);
        greetingProxy.sayHello("Jack");
    }
}

运行结果与以前同样，咱们来简单看一下Enhancer.create的源码

public static Object create(Class type, Callback callback) {
    Enhancer e = new Enhancer();  //建立一个加强代理类对象，它能够拦截被代理的除final,static之外的全部类
    e.setSuperclass(type);  //设置该代理类的父类为实现类
    e.setCallback(callback);  //设置实现了MethodInterceptor接口的回调类，这里即为咱们动态代理类自己的实例，由于MethodInterceptor是继承于Callback的接口，它是一个
                              //对象方法拦截器
    return e.create();       //返回实现类的加强类（所谓加强便可以对这个类进行拦截和各类处理操做）
}

了解了动态代理以后，咱们来了解一下Spring+AspectJ的AOP。咱们主要结合拦截指定注解（@annotation）的方式来大概说明一下用法。

好比说咱们要拦截一个自定义的标签，对标有该标签的方法，记录日志，经过MQ（具体不限定哪一种MQ）发送到日志中心，进行存储。

首先咱们有一个日志的实体类

@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Log implements Serializable {

   private static final long serialVersionUID = -5398795297842978376L;

   private Long id;
   private String username;
   /** 模块 */
   private String module;
   /** 参数值 */
   private String params;
   private String remark;
   private Boolean flag;
   private Date createTime;
   private String ip;
   private String area;
}

有一个自定义的标签，这是一个方法级标签

/**
 * 日志注解
 *
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface LogAnnotation {

   String module();

   /**
    * 记录参数<br>
    * 尽可能记录普通参数类型的方法，和能序列化的对象
    * 
    * @return
    */
   boolean recordParam() default true;
}

增长日志所属的模块（用户操做）

/**
 * 日志模块定义
 *
 */
public abstract class LogModule {

    public static final Map<String, String> MODULES = new HashMap<>();

    public static final String LOGIN = "LOGIN";
    public static final String LOGOUT = "LOGOUT";

    public static final String ADD_PERMISSION = "ADD_PERMISSION";
    public static final String UPDATE_PERMISSION = "UPDATE_PERMISSION";
    public static final String DELETE_PERMISSION = "DELETE_PERMISSION";

    public static final String ADD_ROLE = "ADD_ROLE";
    public static final String UPDATE_ROLE = "UPDATE_ROLE";
    public static final String DELETE_ROLE = "DELETE_ROLE";
    public static final String SET_PERMISSION = "SET_PERMISSION";

    public static final String SET_ROLE = "SET_ROLE";
    public static final String UPDATE_USER = "UPDATE_USER";
    public static final String UPDATE_ME = "UPDATE_ME";

    public static final String UPDATE_PASSWORD = "UPDATE_PASSWORD";
    public static final String RESET_PASSWORD = "RESET_PASSWORD";

    public static final String ADD_MENU = "ADD_MENU";
    public static final String UPDATE_MENU = "UPDATE_MENU";
    public static final String DELETE_MENU = "DELETE_MENU";
    public static final String SET_MENU_ROLE = "SET_MENU_ROLE";

    public static final String ADD_BLACK_IP = "ADD_BLACK_IP";
    public static final String DELETE_BLACK_IP = "DELETE_BLACK_IP";

    public static final String FILE_UPLOAD = "FILE_UPLOAD";
    public static final String FILE_DELETE = "FILE_DELETE";

    public static final String ADD_MAIL = "ADD_MAIL";
    public static final String UPDATE_MAIL = "UPDATE_MAIL";
    public static final String DELETE_USER = "DELETE_USER";

    static {
        MODULES.put(LOGIN, "登录");
        MODULES.put(LOGOUT, "退出");

        MODULES.put(ADD_PERMISSION, "添加权限");
        MODULES.put(UPDATE_PERMISSION, "修改权限");
        MODULES.put(DELETE_PERMISSION, "删除权限");

        MODULES.put(ADD_ROLE, "添加角色");
        MODULES.put(UPDATE_ROLE, "修改角色");
        MODULES.put(DELETE_ROLE, "删除角色");
        MODULES.put(SET_PERMISSION, "分配权限");
        MODULES.put(SET_ROLE, "分配角色");

        MODULES.put(UPDATE_USER, "修改用户");
        MODULES.put(UPDATE_ME, "修改我的信息");
        MODULES.put(UPDATE_PASSWORD, "修改密码");
        MODULES.put(RESET_PASSWORD, "重置密码");

        MODULES.put(ADD_MENU, "添加菜单");
        MODULES.put(UPDATE_MENU, "修改菜单");
        MODULES.put(DELETE_MENU, "删除菜单");
        MODULES.put(SET_MENU_ROLE, "分配菜单");

        MODULES.put(ADD_BLACK_IP, "添加黑名单");
        MODULES.put(DELETE_BLACK_IP, "删除黑名单");

        MODULES.put(FILE_UPLOAD, "文件上传");
        MODULES.put(FILE_DELETE, "文件删除");

        MODULES.put(ADD_MAIL, "保存邮件");
        MODULES.put(UPDATE_MAIL, "修改邮件");
        MODULES.put(DELETE_USER, "删除用户");

    }

}

而后咱们定义一个AOP的实现类

@Aspect
public class LogAop {

    private static final Logger logger = LoggerFactory.getLogger(LogAop.class);
    //对@LogAnnotation标签进行环绕加强
    @Around(value = "@annotation(com.cloud.model.log.LogAnnotation)")
    public Object logSave(ProceedingJoinPoint joinPoint) throws Throwable { //ProceedingJoinPoint joinPoint链接点，能够经过该对象获取方法的任务信息，例如，方
        Log log = new Log();                                                //法名，参数等。
        log.setCreateTime(new Date());
        LoginAppUser loginAppUser = AppUserUtil.getLoginAppUser();
        if (loginAppUser != null) {
            log.setUsername(loginAppUser.getUsername());
        }
        //经过链接点获取方法签名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //经过方法的签名获取方法的标签
        LogAnnotation logAnnotation = methodSignature.getMethod().getDeclaredAnnotation(LogAnnotation.class);
        log.setModule(logAnnotation.module());
        //咱们是否要收集方法的参数，默认为true
        if (logAnnotation.recordParam()) {
            String[] paramNames = methodSignature.getParameterNames();// 获取方法参数名
            if (paramNames != null && paramNames.length > 0) {
                Object[] args = joinPoint.getArgs();// 经过链接点获取传入参数值
                //定义一个HashMap，并将对应的参数名和参数值所有放入该HashMap
                Map<String, Object> params = new HashMap<>();
                for (int i = 0; i < paramNames.length; i++) {
                    params.put(paramNames[i], args[i]);
                }

                try {
                    log.setParams(JSONObject.toJSONString(params)); //Json序列化对应参数信息放入log对象中
                } catch (Exception e) {
                    logger.error("记录参数失败：{}", e.getMessage());
                }
            }
        }

        try {
            Object object = joinPoint.proceed();// 执行原方法
            //执行成功处理
            log.setFlag(Boolean.TRUE);

            return object;
        } catch (Exception e) {
            //执行失败处理
            log.setFlag(Boolean.FALSE);
            log.setRemark(e.getMessage());
            throw e;
        } finally {
            // 异步将Log对象发送到队列
            CompletableFuture.runAsync(() -> {
                try {
                    /////////此处能够将日志对象log发送到消息队列，因为在一些系统中，一些用户的操做大量且频繁，推荐使用Kafka来做为推送日志的消息队列，好比
                    /////////商品购买，退货等等，在LogModule中添加对应的操做标志。
                    logger.info("发送日志到队列：{}", log);
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            });

        }

    }
}

由于@Aspect标签是未被Spring托管的，因此要对LogAop实行自动配置，在资源文件夹下的spring.factories中

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.cloud.log.autoconfigure.LogAop

有多条以, \分隔成多行。在一些本身开发的jar包导入新的Spring boot工程中，此种方法是最为有效的依赖注入方式。

好比在用户模块要修改我的信息的时候

/**
 * 修改本身的我的信息
 *
 * @param appUser
 * @return
 */
@LogAnnotation(module = LogModule.UPDATE_ME)
@PutMapping("/users/me")
public Map<String, Object> updateMe(@RequestBody AppUser appUser) {
    AppUser user = AppUserUtil.getLoginAppUser();
    appUser.setId(user.getId());

    appUserService.updateAppUser(appUser);

    return ResponseUtils.getDataResult(user);
}

这个updateMe方法就会被AOP环绕加强，将操做的信息，传递参数放入log对象，并经过MQ发送到日志中心进行接收。其实这里面接入点的具体实现也是经过反射来处理的。而AOP的整个实现也是经过动态代理来实现的。固然不要忘了在本模块内的配置文件中增长

spring:
  aop:  
    proxy-target-class: true

它的默认值是false,默认只能代理接口（使用JDK动态代理），当为true时，才能代理目标类（使用CGLib动态代理）。

如今咱们就来本身实现一套AOP.代码延续于 @Compenent,@Autowired,@PostConstruct自实现

package com.guanjian.annotion;

import java.lang.annotation.*;

/**
 * 切面注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aspect {
    //要拦截标签的类实例
    Class<? extends Annotation> value();
}

package com.guanjian.proxy;

/**
 * 代理接口
 */
public interface Proxy {
    /**
     * 执行链式代理
     * @param proxyChain
     * @return
     * @throws Throwable
     */
    Object doProxy(ProxyChain proxyChain) throws Throwable;
}

package com.guanjian.proxy;

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * 代理链
 */
public class ProxyChain {
    //目标Class实例
    private final Class<?> targetClass;
    //目标对象
    private final Object targetObject;
    //目标方法
    private final Method targetMethod;
    //方法代理
    private final MethodProxy methodProxy;
    //方法参数
    private final Object[] methodParams;
    //代理列表,由于同一个目标对象实例可能会有多个AOP的拦截，须要多个代理类实例
    private List<Proxy> proxyList = new ArrayList<>();
    //代理索引
    private int proxyIndex = 0;

    public ProxyChain(Class<?> targetClass, Object targetObject, Method targetMethod, MethodProxy methodProxy, Object[] methodParams, List<Proxy> proxyList) {
        this.targetClass = targetClass;
        this.targetObject = targetObject;
        this.targetMethod = targetMethod;
        this.methodProxy = methodProxy;
        this.methodParams = methodParams;
        this.proxyList = proxyList;
    }

    public Class<?> getTargetClass() {
        return targetClass;
    }

    public Method getTargetMethod() {
        return targetMethod;
    }

    public Object[] getMethodParams() {
        return methodParams;
    }

    /**
     * 双向调用的递归，逐个代理对象先把全部的before方法执行一遍，执行到列表中没有代理对象时执行被代理的对象的本方法
     * 再逐个代理对象把全部的after方法执行一遍
     * @return
     * @throws Throwable
     */
    public Object doProxyChain() throws Throwable {
        Object methodResult;
        if (proxyIndex < proxyList.size()) {
            methodResult = proxyList.get(proxyIndex++).doProxy(this);
        }else {
            methodResult = methodProxy.invokeSuper(targetObject,methodParams);
        }
        return methodResult;
    }
}

package com.guanjian.proxy;

import java.lang.reflect.Method;

/**
 * 切面代理
 */
public abstract class AspectProxy implements Proxy {

    @Override
    public Object doProxy(ProxyChain proxyChain) throws Throwable {
        Object result = null;
        Class<?> cls = proxyChain.getTargetClass();
        Method method = proxyChain.getTargetMethod();
        Object[] params = proxyChain.getMethodParams();

        begin();
        try {
            if (intercept(cls,method,params)) {
                before(cls,method,params);
                //跟代理链双向递归
                result = proxyChain.doProxyChain();
                after(cls,method,params,result);
            }else {
                result = proxyChain.doProxyChain();
            }
        } catch (Exception e) {
            System.out.println("proxy failure" + e);
            error(cls,method,params,e);
            throw e;
        } finally {
            end();
        }
        return result;
    }

    public void begin() {
    }

    public boolean intercept(Class<?> cls,Method method,Object[] params) throws Throwable {
        return true;
    }
    public void before(Class<?> cls,Method method,Object[] params) throws Throwable {
    }
    public void after(Class<?> cls,Method method,Object[] params,Object result) throws Throwable {
    }
    public void error(Class<?> cls,Method method,Object[] params,Throwable e) {
    }
    public void end() {
    }
}

package com.guanjian.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.List;

/**
 * 代理管理器，真正实现对实际的目标类实例进行拦截，并初始化调用链，执行对代理对象进行
 * 双向递归调用
 */
public class ProxyManager {
    public static <T> T createProxy(final Class<?> targetClass, final List<Proxy> proxyList) {
        return (T) Enhancer.create(targetClass, new MethodInterceptor() {
            @Override
            public Object intercept(Object targetObject, Method targetMethod, Object[] methodParams, MethodProxy methodProxy) throws Throwable {
                return new ProxyChain(targetClass,targetObject,targetMethod,methodProxy,methodParams,proxyList).doProxyChain();
            }
        });
    }
}

动态代理的类就是这些了，而后是跟整个IOC进行整合

在BeanHelper中增长

/**
 * 设置Bean实例
 * @param cls
 * @param object
 */
public static void setBean(Class<?> cls,Object object) {
    BEAN_MAP.put(cls,object);
}

在ClassHelper中增长

/**
 * 在扫描的类集合中获取指定父类(或接口)的子类(或实现类)
 * @param superClass
 * @return
 */
public static Set<Class<?>> getClassSetBySuper(Class<?> superClass) {
    Set<Class<?>> classSet = new HashSet<>();
    for (Class<?> cls:CLASS_SET) {
        if (superClass.isAssignableFrom(cls) && !superClass.equals(cls)) {
            classSet.add(cls);
        }
    }
    return classSet;
}

/**
 * 在扫描的类集合中获取有标记指定的标签类的全部类
 * @param annotationClass
 * @return
 */
public static Set<Class<?>> getClassSetByAnnotation(Class<? extends Annotation> annotationClass) {
    Set<Class<?>> classSet = new HashSet<>();
    for (Class<?> cls:CLASS_SET) {
        if (cls.isAnnotationPresent(annotationClass)) {
            classSet.add(cls);
        }
    }
    return classSet;
}

而后写一个方法拦截助手类

package com.guanjian.util;

import com.guanjian.annotion.Aspect;
import com.guanjian.proxy.AspectProxy;
import com.guanjian.proxy.Proxy;
import com.guanjian.proxy.ProxyManager;

import java.lang.annotation.Annotation;
import java.util.*;

/**
 * 方法拦截助手类
 */
public final class AopHelper {

    static {
        try {
            //AOP拦截与标记了该AOP拦截的全部类集合的map映射
            Map<Class<?>,Set<Class<?>>> proxyMap = createProxyMap();
            //目标类与代理类实例集合的map映射
            Map<Class<?>,List<Proxy>> targetMap = createTargetMap(proxyMap);
            //遍历目标类与代理类实例集合的map
            for (Map.Entry<Class<?>,List<Proxy>> targetEntry:targetMap.entrySet()) {
                //取出目标类
                Class<?> targetClass = targetEntry.getKey();
                //取出代理类集合列表
                List<Proxy> proxyList = targetEntry.getValue();
                //使用代理管理器对目标类进行拦截，并开始执行代理类集合列表的全部加强方法以及目标类的本方法
                Object proxy = ProxyManager.createProxy(targetClass,proxyList);
                //将目标类与代理对象添加进全局映射关系
                BeanHelper.setBean(targetClass,proxy);
            }
            System.out.println("aop Class loaded");
        } catch (Exception e) {
            System.out.println("aop failure" + e);
        }

    }

    /**
     * 建立全部的AOP类与与之对应的目标类集合的映射
     * @return
     * @throws Exception
     */
    private static Map<Class<?>,Set<Class<?>>> createProxyMap() throws Exception {
        Map<Class<?>,Set<Class<?>>> proxyMap = new HashMap<>();
        //获取切面代理类(抽象类)的全部实现类(子类)
        Set<Class<?>> proxyClassSet = ClassHelper.getClassSetBySuper(AspectProxy.class);
        for (Class<?> proxyClass:proxyClassSet) {
            //实现类是否有@Aspect标签
            if (proxyClass.isAnnotationPresent(Aspect.class)) {
                //获取该标签
                Aspect aspect = proxyClass.getAnnotation(Aspect.class);
                //获取全部目标类集合
                Set<Class<?>> targetClassSet = createTargetClassSet(aspect);
                //将代理类实例与该集合添加map映射
                proxyMap.put(proxyClass,targetClassSet);
            }
        }
        return proxyMap;
    }

    /**
     * 建立目标类集合
     * @param aspect
     * @return
     * @throws Exception
     */
    private static Set<Class<?>> createTargetClassSet(Aspect aspect) throws Exception {
        Set<Class<?>> targetClassSet = new HashSet<>();
        //获取要拦截的标签类实例
        Class<? extends Annotation> annotation = aspect.value();
        if (annotation != null && !annotation.equals(Aspect.class)) {
            //将扫描到的全部标记了该标签的全部类实例添加到集合中
            targetClassSet.addAll(ClassHelper.getClassSetByAnnotation(annotation));
        }
        return targetClassSet;
    }

    /**
     * 建立目标类与代理类集合的map映射
     * @param proxyMap
     * @return
     * @throws Exception
     */
    private static Map<Class<?>,List<Proxy>> createTargetMap(Map<Class<?>,Set<Class<?>>> proxyMap) throws Exception {
        //目标类与它全部代理集合的映射map
        Map<Class<?>,List<Proxy>> targetMap = new HashMap<>();
        //遍历全部的AOP拦截与标记了该AOP拦截的全部类集合的map
        for (Map.Entry<Class<?>,Set<Class<?>>> proxyEntry:proxyMap.entrySet()) {
            //取出AOP拦截类
            Class<?> proxyClass = proxyEntry.getKey();
            //取出标记了该拦截类的目标类集合
            Set<Class<?>> targetClassSet = proxyEntry.getValue();
            //遍历全部的目标类
            for (Class<?> targetClass:targetClassSet) {
                //实例化该AOP拦截类
                Proxy proxy = (Proxy)proxyClass.newInstance();
                //若是map中有该目标类
                if (targetMap.containsKey(targetClass)) {
                    //添加拦截类实例进列表
                    targetMap.get(targetClass).add(proxy);
                }else {
                    //若是没有，建立代理类实例列表
                    List<Proxy> proxyList = new ArrayList<>();
                    //将该代理类实例添加进列表
                    proxyList.add(proxy);
                    //建立新的目标类与该列表的映射
                    targetMap.put(targetClass,proxyList);
                }
            }
        }
        return targetMap;
     }
}

注意以上代码都是针对整个目标类的全部方法进行拦截的，若是有须要能够改写对个别方法的拦截

此时咱们就能够写测试代码了

测试标签类，由于是针对整个目标类的，因此是@Target(ElementType.TYPE)

package com.guanjian.annotion;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by Administrator on 2019-03-15.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationTest {
}

编写一个AOP实现类，打印方法执行时间，该类必须放在扫描包中进行扫描。

package com.guanjian.test.aop;

import com.guanjian.annotion.AnnotationTest;
import com.guanjian.annotion.Aspect;
import com.guanjian.proxy.AspectProxy;

import java.lang.reflect.Method;


/**
 * Created by Administrator on 2019-03-15.
 */

@Aspect(AnnotationTest.class)
public class AopTest extends AspectProxy{
    private long begin;
    @Override
    public void before(Class<?> cls, Method method, Object[] params) throws Throwable {
        begin = System.currentTimeMillis();
    }

    @Override
    public void after(Class<?> cls, Method method, Object[] params, Object result) throws Throwable {
        System.out.println("time: " + (System.currentTimeMillis() - begin));
    }
}

package com.guanjian.test.compent;

import com.guanjian.annotion.AnnotationTest;

/**
 * Created by Administrator on 2019-03-16.
 */

@AnnotationTest
public class Test3 {
    public void show() {
        System.out.println("你好，你好");
    }
}

注意，这些都是没有加以前的@Component标签的，由于这里不是Spring，因此它们都会被扫描到并被代理类实例加强执行。

最后是main方法

public class Test {
    public static void main(String[] args) {
        //扫描包
        Manager.scanAndImp("com.guanjian.test");
        //初始化AopHelper
        ClassUtil.loadClass(AopHelper.class.getName(),true);
        //这里其实拿到的是代理类的实例，代理类是目标类的子类
        Test3 test3 = (Test3)Manager.getBean(Test3.class);
        test3.show();
    }
}

运行结果：

aop Class loaded 你好，你好 time: 11