Jdk动态代理个人简单梳理
java动态代理在Spring的AOP中可谓是被应用到了极致，一直不是很清楚，今天想复习一下设计模式，刚好看到动态代理一下就把我的思绪拉回到看AOP源码的时光了，说实话动态代理我用的太少了，于是今天小总结一下，来看看。
引入如下场景：房东想租房子，但是他只想租不想管其余的琐事，于是他找中介，把房子托给他，这个中介就是一个代理者。
静态代理，十分简单：就是代理者内部聚合一个接口，这个接口是房东和中介共有的，这样就实现了静态的代理，这里就不再赘述了，代码贴出来看一眼就懂了。
// 被代理类和代理类共同的操作
interface Action {
default void doOther() {
};
void display();
}
// 被代理类【房东】
class Host implements Action {
@Override
public void display() {
System.out.println("我是房东，我只想租房子，啥也不想管");
}
}
// 代理类【中介】
class HostProxy implements Action {
private Action action;
public HostProxy() {
action = new Action() {
@Override
public void display() {
System.out.println("do nothing...");
}
};
}
public HostProxy(Action action) {
this.action = action;
}
@Override
public void display() {
PostProcessorsBeforeAction();
action.display();
PostProcessorsAfterAction();
}
private void PostProcessorsBeforeAction() {
System.out.println("我来代理你做吧");
}
private void PostProcessorsAfterAction() {
System.out.println("代理执行后序到结束");
}
}
动态代理：
// 动态代理雏形...
Action host = new Host();
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("动态代理之前干事情");
host.display();
System.out.println("动态代理完成");
return null;
}
};
Action actionProxy = (Action) Proxy.newProxyInstance(Action.class.getClassLoader(), new Class[]{Action.class}, invocationHandler);
actionProxy.display();
个人写动态代理【简单版，有时间继续探讨】：
// 自己写一下动态代理
class DynamicProxy<T> {
public T getProxy(Class<?> clazz, T obj, Object... args){
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("动态代理之前干的...事情");
// 原方法调用（这里只测试有一个方法，我取出第一个就好）
// Method[] methods = obj.getClass().getMethods();
// methods.invoke(obj, args);
method.invoke(obj, args);
System.out.println("动态代理完成啦...");
return null;
}
};
T proxyInstance = (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, invocationHandler);
return proxyInstance;
}
}
// 动态代理
DynamicProxy<Action> dynamicProxy = new DynamicProxy();
Action proxy = dynamicProxy.getProxy(Action.class, new Host());
proxy.display();
动态代理稍微深入一些：
先不和Spring的Aop写的那么复杂，我先简单实现一下，其中NxjBefore就是前置方法，NxjAfter就是后置方法
// 定义这两个注解
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface NxjBefore {
}
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface NxjAfter {
}
// 接口
interface IMyReflect {
void display();
}
// 被代理类
class MyReflect implements IMyReflect{
@Override
public void display() {
System.out.println("执行方法");
}
}
class MyReflectTest{
/**
* 为了测试，包含注解有NxjBefore;NxjAfter这两个先测试
*/
@NxjBefore
public void test01() {
System.out.println("嗯哼，before啦");
}
@NxjAfter
public void test02() {
System.out.println("嗯哼，after啦");
}
}
// 自己写一下动态代理(大框和上方写的一样)
static class DynamicProxy<T> {
public T getProxy(Class<?> clazz, T obj, Object aop, Object... args){
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("动态代理之前干的...事情");
// 排好顺序
Map<Class<?>, List<Method>> chain = chain(aop.getClass().getMethods());
// 顺序调用(可以仿照Spring中AOP递归调用，这里我先简单测试一下)
List<Method> listBefore = chain.get(NxjBefore.class);
for (Method method1 : listBefore) {
method1.invoke(aop);
}
method.invoke(obj,args);
List<Method> listAfter = chain.get(NxjAfter.class);
for (Method method1 : listAfter) {
method1.invoke(aop);
}
System.out.println("动态代理完成啦...");
return null;
}
};
T proxyInstance = (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, invocationHandler);
return proxyInstance;
}
}
private static Map<Class<?>, List<Method>> chain(Method[] methods) {
Map<Class<?>, List<Method>> res = new HashMap<>();
List<Method> beforeList = new ArrayList<>();
List<Method> afterList = new ArrayList<>();
for (Method method : methods) {
Annotation[] annotations = method.getDeclaredAnnotations();
for (Annotation annotation : annotations) {
Class<? extends Annotation> aClass = annotation.annotationType();
if (aClass.equals(NxjBefore.class)) {
beforeList.add(method);
break;
} else if (aClass.equals(NxjAfter.class)) {
afterList.add(method);
}
}
}
res.put(NxjBefore.class, beforeList);
res.put(NxjAfter.class, afterList);
return res;
}
public static void main(String[] args) {
DynamicProxy<IMyReflect> dynamicProxy = new DynamicProxy();
IMyReflect proxy = dynamicProxy.getProxy(IMyReflect.class, new MyReflect(), new MyReflectTest());
proxy.display();
}
# 结果
动态代理之前干的...事情
嗯哼，before啦
执行方法
嗯哼，after啦
动态代理完成啦...
当然Spring中Aop中应用动态代理，方法执行是递归执行，大致过程为先通过方法获取链chain[此时代理对象内部方法就是按照注解标注的方式排序好的]，然后递归执行方法，由后往前，当是最后一个方法是调用invoke，然后依次弹栈执行。
一篇很好的文章，值的看看：https://www.cnblogs.com/gonjan-blog/p/6685611.html
