更新动态代理，更新动态代理实现AOP的例子

CodeCoderCoding · CodeCoderCoding · commit 2421f3d5e8b1 · 2021-09-20T19:13:22.000+01:00
diff --git a/README.md b/README.md
@@ -27,9 +27,9 @@ Java相关Demo代码实现
 - [ ] 同步与协作
 
 ### F 动态与函数式编程
-- [ ] 反射
-- [ ] 注解
-- [ ] 动态代理
+- [x] 反射
+- [x] 注解
+- [x] 代理（静态代理、JDK动态代理、CGlib动态代理）
 - [ ] 类加载机制
 - [ ] 函数式编程
 
diff --git a/src/FDynamic/Proxy/AOP/AOPMain.java b/src/FDynamic/Proxy/AOP/AOPMain.java
@@ -0,0 +1,12 @@
+package FDynamic.Proxy.AOP;
+
+
+public class AOPMain {
+	
+	public static void main(String[] args) {
+		
+		ServiceA a = CGLibContainer.getInstance(ServiceA.class);
+		a.callB();
+		
+	}
+}
diff --git a/src/FDynamic/Proxy/AOP/CGLibContainer.java b/src/FDynamic/Proxy/AOP/CGLibContainer.java
@@ -0,0 +1,182 @@
+package FDynamic.Proxy.AOP;
+
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.*;
+
+public class CGLibContainer {
+	public static enum InterceptPoint {
+		BEFORE, AFTER, EXCEPTION
+	}
+
+	//CGLibContainer在初始化的时候，会分析带有@Aspect注解的类，分析出每个类的方法在
+	//调用前、调用后、出现异常时该调用哪些方法，在创建该类的对象时，如果有需要被调用的方法，
+	//则创建一个动态代理对象。
+	static Class<?>[] aspects = new Class<?>[] { LogAspect.class, ExceptionAspect.class };
+
+	static Map<Class<?>, Map<InterceptPoint, List<Method>>> interceptMethodsMap = new HashMap<>();
+
+	static {
+		init();
+	}
+
+	/**
+	 * 对每个切面，即带有@Aspect注解的类cls，查找其before/after/exception方法，
+	 * 调用方法addInterceptMethod将其加入目标类的切点方法列表中
+	 */
+	private static void init() {
+		for (Class<?> cls : aspects) {
+			Aspect aspect = cls.getAnnotation(Aspect.class);
+			if (aspect != null) {
+				Method before = getMethod(cls, "before", new Class<?>[] { Object.class, Method.class, Object[].class });
+				Method after = getMethod(cls, "after",
+						new Class<?>[] { Object.class, Method.class, Object[].class, Object.class });
+				Method exception = getMethod(cls, "exception",
+						new Class<?>[] { Object.class, Method.class, Object[].class, Throwable.class });
+				Class<?>[] intercepttedArr = aspect.value();
+				for (Class<?> interceptted : intercepttedArr) {
+					addInterceptMethod(interceptted, InterceptPoint.BEFORE, before);
+					addInterceptMethod(interceptted, InterceptPoint.AFTER, after);
+					addInterceptMethod(interceptted, InterceptPoint.EXCEPTION, exception);
+				}
+			}
+		}
+	}
+
+	private static Method getMethod(Class<?> cls, String name, Class<?>[] paramTypes) {
+		try {
+			return cls.getMethod(name, paramTypes);
+		} catch (NoSuchMethodException e) {
+			return null;
+		}
+	}
+
+	/**
+	 *
+	 * @param cls
+	 * @param point
+	 * @param method
+	 */
+	private static void addInterceptMethod(Class<?> cls, InterceptPoint point, Method method) {
+		if (method == null) {
+			return;
+		}
+		Map<InterceptPoint, List<Method>> map = interceptMethodsMap.get(cls);
+		if (map == null) {
+			map = new HashMap<>();
+			interceptMethodsMap.put(cls, map);
+		}
+		List<Method> methods = map.get(point);
+		if (methods == null) {
+			methods = new ArrayList<>();
+			map.put(point, methods);
+		}
+		methods.add(method);
+	}
+
+	/**
+	 * 得到响应的切面
+	 * @param cls
+	 * @param point
+	 * @return
+	 */
+	static List<Method> getInterceptMethods(Class<?> cls,
+			InterceptPoint point) {
+		Map<InterceptPoint, List<Method>> map = interceptMethodsMap.get(cls);
+		if (map == null) {
+			return Collections.emptyList();
+		}
+		List<Method> methods = map.get(point);
+		if (methods == null) {
+			return Collections.emptyList();
+		}
+		return methods;
+	}
+
+	/**
+	 * 根据原始类的实际类型查找应该执行的before/after/exception方法列表，在调用原始方法前
+	 * 执行before方法，
+	 */
+	static class AspectInterceptor implements MethodInterceptor {
+		@Override
+		public Object intercept(Object object, Method method, 
+				Object[] args, MethodProxy proxy) throws Throwable {
+			//执行before方法
+			List<Method> beforeMethods = getInterceptMethods(
+					object.getClass().getSuperclass(), InterceptPoint.BEFORE);
+			for (Method m : beforeMethods) {
+				m.invoke(null, new Object[] { object, method, args });
+			}
+
+			try {
+				// 调用原始方法
+				Object result = proxy.invokeSuper(object, args);
+
+				// 执行after方法
+				List<Method> afterMethods = getInterceptMethods(
+						object.getClass().getSuperclass(), InterceptPoint.AFTER);
+				for (Method m : afterMethods) {
+					m.invoke(null, new Object[] { object, method, args, result });
+				}
+				return result;
+			} catch (Throwable e) {
+				//执行exception方法
+				List<Method> exceptionMethods = getInterceptMethods(
+						object.getClass().getSuperclass(), InterceptPoint.EXCEPTION);
+				for (Method m : exceptionMethods) {
+					m.invoke(null, new Object[] { object, method, args, e });
+				}
+				throw e;
+			}
+		}
+	}
+
+	/**
+	 * 如果类型cls不需要增强，则直接调用cls.newInstance()，否则使用cglib创建动态代理，
+	 * callback为AspectInterceptor
+	 * @param cls
+	 * @param <T>
+	 * @return
+	 * @throws InstantiationException
+	 * @throws IllegalAccessException
+	 */
+	private static <T> T createInstance(Class<T> cls) 
+			throws InstantiationException, IllegalAccessException {
+		if (!interceptMethodsMap.containsKey(cls)) {
+			return (T) cls.newInstance();
+		}
+		Enhancer enhancer = new Enhancer();
+		enhancer.setSuperclass(cls);
+		enhancer.setCallback(new AspectInterceptor());
+		return (T) enhancer.create();
+	}
+
+	/**
+	 * getInstance方法调用createInstance创建实例
+	 * @param cls
+	 * @param <T>
+	 * @return
+	 */
+	public static <T> T getInstance(Class<T> cls) {
+		try {
+			T obj = createInstance(cls);
+			Field[] fields = cls.getDeclaredFields();
+			for (Field f : fields) {
+				if (f.isAnnotationPresent(SimpleInject.class)) {
+					if (!f.isAccessible()) {
+						f.setAccessible(true);
+					}
+					Class<?> fieldCls = f.getType();
+					f.set(obj, getInstance(fieldCls));
+				}
+			}
+			return obj;
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+}
diff --git a/src/FDynamic/Proxy/AOP/ExceptionAspect.java b/src/FDynamic/Proxy/AOP/ExceptionAspect.java
@@ -3,6 +3,9 @@
 import java.lang.reflect.Method;
 import java.util.Arrays;
 
+/**
+ * ExceptionAspect是一个切面，负责ServiceB的异常切面
+ */
 @Aspect({ ServiceB.class })
 public class ExceptionAspect {
 	public static void exception(Object object,
diff --git a/src/FDynamic/Proxy/AOP/LogAspect.java b/src/FDynamic/Proxy/AOP/LogAspect.java
@@ -3,6 +3,9 @@
 import java.lang.reflect.Method;
 import java.util.Arrays;
 
+/**
+ * LogAspect就是一个切面，负责ServiceA和ServiceB的日志切面，即为这两个类增加日志功能
+ */
 @Aspect({ ServiceA.class, ServiceB.class })
 public class LogAspect {
 
diff --git a/src/FDynamic/Proxy/AOP/SimpleSingleton.java b/src/FDynamic/Proxy/AOP/SimpleSingleton.java
