Spring IOC、AOP可謂是spring中兩大王牌
上次我們手寫了IOC，那麼今天我們來手寫一下AOP

我是學習他的寫法，然後將一些我不懂的程式碼進行了註釋解釋，應該可以更加適合小白學習吧。

一.準備

首先我們都知道Spring AOP的核心技術是動態代理，但是在這個demo中用的不是Jdj1.8的動態代理方法。
用的是cgib的動態代理方式。
那麼這二者有什麼區別呢？

JDK動態代理: 只能代理實現了介面的類
沒有實現介面的類不能實現JDK動態代理。

Cglib代理: 針對類來實現代理,對指定目標
產生一個子類 通過方法攔截技術攔截所有父類方法的呼叫。

二.思路

1 掃描 aop 包， 獲取 aspect 的類

2 根據 切點 獲取該切點的 類 和 方法

3 根據配置的 類 和 方法 為該類生成一個代理物件

4 將改代理物件放入 bean Map 中

5 呼叫的時候 將代理物件 轉換成需要的物件

三.具體程式碼

註解：

package com.example.writeaopdemo.annotion;

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

/**
 * @author Jet
 */
@Retention(RetentionPolicy.RUNTIME) //保留時間長短
@Target(value = {ElementType.TYPE})//使用範圍、介面、類、列舉、註解
public @interface Aspect {

}

package com.example.writeaopdemo.annotion;

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

/**
 * 方法切入點
 */
@Retention(RetentionPolicy.RUNTIME)//保留時間長短
@Target(value = {ElementType.METHOD}) //使用範圍 方法
public @interface PointCut {

    /**
     * 全類名_方法名
     * @return
     */
    String value();
}

測試bean測試Aspect

package com.example.writeaopdemo.domain;

import com.example.writeaopdemo.annotion.Aspect;
import com.example.writeaopdemo.annotion.PointCut;
import com.example.writeaopdemo.proxy.AbsMethodAdvance;
@Aspect
public class TestAspect extends AbsMethodAdvance {
    /**
     *全類名 方法名
     */
    @PointCut("com.example.writeaopdemo.domain.Test_doSomeThing")
    public void testAspect(){

    }


    @Override
    public void doBefore() {
            System.out.println("do before");
    }

    @Override
    public void doAfter() {
        System.out.println("do after");
    }
}

代理類（在建立代理物件的同時攔截方法的執行實現before和after邏輯）

package com.example.writeaopdemo.proxy;

import com.example.writeaopdemo.util.StringUtils;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;


import java.lang.reflect.Method;

/**
 * @author Jet
 */
public abstract class AbsMethodAdvance implements MethodInterceptor {
    /**
     * 要被代理的物件
     */
    private Object targetObject;

    /**
     * 被代理的方法名
     */
    private String proxyMethodName;

    public Object createProxyObject(Object target){
        this.targetObject = target;
        //該類用於生成代理物件
        Enhancer enhancer = new Enhancer();
        //設定目標類為代理物件的父類
        enhancer.setSuperclass(this.targetObject.getClass());
        //設定回撥用物件為本身
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable{
        Object result;

        String proxyMethod = getProxyMethodName();

        if(StringUtils.isNotBlank(proxyMethod) && proxyMethod.equals(method.getName())){
            doBefore();
        }

        //執行攔截的方法
        result = methodProxy.invokeSuper(proxy,args);

        if(StringUtils.isNotBlank(proxyMethod) && proxyMethod.equals(method.getName())){
            doAfter();
        }
        return result;
    }
    public abstract void doBefore();

    public abstract void doAfter();

    public String getProxyMethodName(){
        return proxyMethodName;
    }
    public void setProxyMethodName(String proxyMethodName){
        this.proxyMethodName = proxyMethodName;
    }
}

載入類

package com.example.writeaopdemo.util;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * @author Jet
 */
public class ClassUtil {
    /**
     * 獲取類載入器
     *
     * @return
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 載入類
     * 需要提供類名是否初始化標誌
     * 初始化是指知否執行靜態程式碼塊
     *
     * @param className
     * @param isInitialized
     * @return
     */
    public static Class<?> loadClass(String className, boolean isInitialized) {
        Class<?> cls;
        try {
            cls = Class.forName(className, isInitialized, getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return cls;
    }

    /**
     * 載入類(預設將初始化類)
     *
     * @param className
     * @return
     */
    public static Class<?> loadClass(String className) {
        return loadClass(className, true);
    }

    public static Set<Class<?>> getClassSet(String packageName) throws IOException {
        Set<Class<?>> classSet = new HashSet<>();
        try {
            Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".", "/"));
            //Enumeration相當於老闆迭代器
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                if (url != null) {
                    String protocol = url.getProtocol();//獲得URL的協議
                    if (protocol.equals("file")) {
                        //轉碼
                        String packagePath = URLDecoder.decode(url.getFile(), "UTF-8");//轉碼為utf-8的格式
                        addClass(classSet, packagePath, packageName);
                    } else if (protocol.equals("jar")) {
                        JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();//解析Jar檔案
                        if (jarURLConnection != null) {
                            JarFile jarFile = jarURLConnection.getJarFile();
                            if (jarFile != null) {
                                Enumeration<JarEntry> jarEntries = jarFile.entries();
                                while (jarEntries.hasMoreElements()) {
                                    JarEntry jarEntry = jarEntries.nextElement();
                                    String jarEntryName = jarEntry.getName();
                                    if (jarEntryName.endsWith(".class")) {
                                        String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/", ".");
                                        doAddClass(classSet, className);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } catch (IOException e) {
            throw e;
        }
        return classSet;
    }
    private static void addClass(Set<Class<?>> classSet,String packagePath,String packageName){
       // System.out.println("packageName: " + packageName);
        File[] files = new File(packagePath).listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return (file.isFile() && file.getName().endsWith(".class") || file.isDirectory());
            }
        });

        for(File file : files){
            String fileName = file.getName();
            if(file.isFile()){
                String className = fileName.substring(0,fileName.lastIndexOf("."));

                if(StringUtils.isNotBlank(packageName)){
                    className = packageName + "." + className;
                }
                //新增
                doAddClass(classSet,className);
            }else{
                //子目錄
                String subPackagePath = fileName;
                if(StringUtils.isNotBlank(packagePath)){
                    subPackagePath = subPackagePath + "/" + subPackagePath;
                }
                String subPackageName = fileName;
                if(StringUtils.isNotBlank(packageName)){
                    subPackageName = packageName + "." + subPackageName;
                }
                addClass(classSet,subPackagePath,subPackageName);
            }
        }
    }
    private static void doAddClass(Set<Class<?>> classSet,String className){
        Class<?> cls = loadClass(className,false);
        classSet.add(cls);
    }
}

通過反射機制建立例項呼叫方法和設定成員變數的值

package com.example.writeaopdemo.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionUtil {
    /**
     * 建立例項
     */
    public static Object newInstance(Class<?> cls){
        Object instance;

        try{
            instance = cls.newInstance();
        }catch (Exception e){
            throw new RuntimeException();
        }
        return instance;
    }

    /**
     * 建立例項 根據類名
     */
    public static Object newInstance(String className){
        Class<?> cls = ClassUtil.loadClass(className);
        return newInstance(cls);
    }

    /**
     * 呼叫方法
     */
    public static Object invokeMethod(Object obj, Method method,Object... args){
        Object result;
        try{
            method.setAccessible(true);
            result = method.invoke(obj,args);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        return result;
    }

    /**
     * 設定成員變數的值
     */
    public static void setField(Object obj, Field field,Object value){
        try{
            field.setAccessible(true);
            field.set(obj,value);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

字串處理類

package com.example.writeaopdemo.util;

/**
 * @author Jet
 */
public class StringUtils {
    public static boolean isNotBlank(String str){
        if(str != null && str.trim().length() > 0){
            return true;
        }else{
            return false;
        }
    }
    public static boolean isBlank(String str){
        return !isNotBlank(str);
    }
}

找到切點切面設定代理初始化容器類

package com.example.writeaopdemo;

import com.example.writeaopdemo.annotion.Aspect;
import com.example.writeaopdemo.annotion.PointCut;
import com.example.writeaopdemo.proxy.AbsMethodAdvance;
import com.example.writeaopdemo.util.ClassUtil;
import com.example.writeaopdemo.util.ReflectionUtil;
import org.apache.tools.ant.taskdefs.EchoXML;

import java.lang.reflect.Method;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Jet
 */
public class ApplicationContext {
    /**
     * 存放代理類的集合
     */
    public static ConcurrentHashMap<String,Object> proxyBeanMap = new ConcurrentHashMap<String, Object>();
    static {
            initAopBeanMap("com.example.writeaopdemo.domain");
    }

    /**
     * 初始化容器
     * @param basePath
     */
    public static void initAopBeanMap(String basePath){
        try{
            Set<Class<?>> classSet = ClassUtil.getClassSet(basePath);
            for(Class clazz : classSet){
                if(clazz.isAnnotationPresent(Aspect.class)){
                    Method[] methods = clazz.getMethods();
                    for(Method method : methods){
                        if(method.isAnnotationPresent(PointCut.class)){
                            //找到切點
                            PointCut pointCut = (PointCut)method.getAnnotations()[0];
                            String pointCutStr = pointCut.value();
                            //System.out.println("pointCutStr:" + pointCutStr);
                            String[] pointCutArr = pointCutStr.split("_");
                            //被代理的類名
                            String className = pointCutArr[0];
                            //System.out.println("className:" + className);
                            //被代理的方法名
                            String methodName = pointCutArr[1];
                           // System.out.println("methodName:" + methodName);

                            //根據切點 建立被代理物件
                            Object targeObj = ReflectionUtil.newInstance(className);
                            //根據切面類建立代理者
                            AbsMethodAdvance proxyer = (AbsMethodAdvance)ReflectionUtil.newInstance(clazz);
                            //設定代理的方法
                            proxyer.setProxyMethodName(methodName);

                            Object object = proxyer.createProxyObject(targeObj);

                            if(object != null){
                                proxyBeanMap.put(targeObj.getClass().getSimpleName().toLowerCase(),object);
                            }
                        }
                    }

                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

}

Main類執行

import com.example.writeaopdemo.ApplicationContext;
import com.example.writeaopdemo.domain.Test;

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args){
        //模擬容器初始化
        ApplicationContext applicationContext = new ApplicationContext();
        ConcurrentHashMap<String,Object> proxyBeanMap = ApplicationContext.proxyBeanMap;
        //生成代理物件，預設為該類名的小寫
        Test test =(Test)proxyBeanMap.get("test");
        test.doSomeThing();
        System.out.println("------------");
        test.doWithNotProxy();
    }
}