动态代理实现AOP

代理

代理顾名思义：代为处理。不是对目标对象的直接操做，而是经过代理对目标对象进行包装，此时能够在目标对象的基础上添加额外的操做以知足业务需求。图示

分类：动态代理、静态代理。

代理三要素：共同接口、真实对象、代理对象

引入代理的缘由：

在某些状况下，一个客户不想或者不能直接引用另外一个对象，而代理对象能够在客户端和目标对象之间起到中介的做用【解耦】。 

静态代理

public interface Action {
    public void doSomething();
}

public class Proxyc implements Action{
    Action realObject;
    public Proxyc(Action action) {
        realObject = action;
    }
    @Override
    public void doSomething() {
        System.out.println("被拦截前...");
        realObject.doSomething();
        System.out.println("被拦截后...");
    }

    public static void main(String[] args) {
        Proxyc proxy = new Proxyc(new RealObject());
        proxy.doSomething();
    }
}

优势：扩展原功能，不侵入代码

缺点：假若有10个不一样的实际对象，对应10个不一样的方法，该如何写呢？

1) 要么建立不一样的代理类，代理后这样：

proxy.doSomething()
proxy2.doSomething2()
proxy3.doSomething3()
...

问题：建立多个功能相似的代理类，仅传入的真实对象不一样

2) 要么建立一个代理，实现不一样的接口:

proxy.doSomething()
proxy.doSomething2()
proxy.doSomething3()
...

问题：代理类不断膨胀

动态代理

代理由静态转为静态源于静态代理引入的额外工做。

动态代理就是咱们上面提到的方案一，只不过这些proxy的建立都是自动的而且是在运行期生成的。

不少繁琐的编程能够用动态代理解决

实现方式

• 反射（依赖接口）
  • 　　优势：最小化依赖关系；平滑jdk升级；代码简单
• cglib等（依赖子类）
  • 　　优势：不限制实现接口；只操做关心的类；高性能

反射方式举例

public interface Action {
    public void doSomething();
}

public class RealObject implements Action{
    @Override
    public void doSomething() {
        System.out.println("I'm RealObject~");
    }
}

public class DynamicProxyHandler implements InvocationHandler {
    private Object realObject;

    public DynamicProxyHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object object, Method method, Object[] args) {
        Object result = null;
        try {
            result = method.invoke(realObject, args);
        } catch (InvocationTargetException|IllegalAccessException e) {
            e.printStackTrace();
        }
        return result;
    }

    public static void main(String[] args) {
        RealObject realObject = new RealObject();
        Action action = (Action) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Action.class},
                new DynamicProxyHandler(realObject));
        action.doSomething();
    }
}

经过Proxy.newProxyInstance()生成代理对象，须要传入3个参数：classLoader + 代理接口 + InvocationHandler实例,

其中InvocationHandler接口，该接口定义了一个invoke方法，proxy最是最终生成的一个代理实例，通常不会用到，参数method是被代理目标实例的某个具体的方法，经过它能够发起目标实例方法的反射调用；参数args是经过被代理实例某一个方法的入参，在方法反射调用时候使用，经过代理将横切逻辑代码和业务类的代码编织到了一块儿。

动态代理的应用场景

日志

监控

鉴权

......

AOP

切面编程，是对OOP(面向对象编程)的一种补充，解决OOP其对对于跨越不一样类、对象,纠缠逻辑变现的不足

AOP实例1

public interface Waiter {
    public void service();
}

public class ManWaiter implements Waiter{
    @Override
    public void service() {
        System.out.println("service...");
    }
}

 

public interface BeforeAdvice {
    public void before();
}

public interface AfterAdvice {
    public void after();
}

 

@Getter
@Setter
public class ProxyFactory {
    Object target;
    BeforeAdvice beforeAdvice;
    AfterAdvice afterAdvice;

    public Object createProxy() {
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (beforeAdvice != null) {
                    beforeAdvice.before();
                }
                Object result = method.invoke(target, args);
                afterAdvice.after();
                return result;
            }
        };
        Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return proxyObject;
    }

    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(new ManWaiter());
        proxyFactory.setBeforeAdvice(new BeforeAdvice() {
            @Override
            public void before() {
                System.out.println("Before Service.");
            }
        });
        proxyFactory.setAfterAdvice(new AfterAdvice() {
            @Override
            public void after() {
                System.out.println("After Service.........");
            }
        });
        Waiter waiter = (Waiter)proxyFactory.createProxy();
        waiter.service();
    }
}

 

AOP实例2

public interface UserService {
    public void service();
}

public class UserServiceImpl implements UserService{
    @Override
    public void service() {
        System.out.println("In Service.......");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Service end.");
    }
}

 

public class MethodPerformance {
    private long start;
    private long end;
    String serviceMethod;

    public MethodPerformance(String serviceMethod) {
        this.serviceMethod = serviceMethod;
        start = System.currentTimeMillis();
    }

    public void printPerformance() {
        end = System.currentTimeMillis();
        System.out.println(serviceMethod + " cost Time: " + (end - start));
    }
}

public class PerformanceMonitor {
    public static ThreadLocal<MethodPerformance> performanceThreadLocal = new ThreadLocal<>();

    public static void begin(String method) {
        System.out.println("Start monitor>>");
        MethodPerformance methodPerformance = new MethodPerformance(method);
        performanceThreadLocal.set(methodPerformance);
    }

    public static void end() {
        System.out.println("End monitor.");
        performanceThreadLocal.get().printPerformance();
    }
}

 

public class PerformanceHandler implements InvocationHandler {
    Object target;

    public PerformanceHandler(Object object) {
        target = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        Object result = null;
        try {
            PerformanceMonitor.begin(target.getClass().getName() + ":" + method.getName());
            result = method.invoke(target, args);
            PerformanceMonitor.end();
        } catch (IllegalAccessException| InvocationTargetException e) {
            e.printStackTrace();
        }
        return result;
    }

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        ClassLoader classLoader = userService.getClass().getClassLoader();
        Class[] interfaces = userService.getClass().getInterfaces();
        InvocationHandler invocationHandler = new PerformanceHandler(userService);
        UserService obj = (UserService) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        obj.service();
    }
}