简介：
他是指一个对象A通过持有另一个对象B，能够具备B同样的行为的模式，在jdk的动静代理中，B往往实现了一些接口，A也会去实现接口，然而实际上B是真正的接口的实现类，而A是通过B和接口等等一些参数生成的一个类（也就是代理类），它不仅具备与B同样的行为，它还能够加强B，在调用B的办法前后都做些其余的事件，实际上能够了解为把本人交给他人，让他人来管制本人的行为。最平凡的利用应该就是spring的aop了，而代理又分为动静代理和动态代理，上面咱们便一一来介绍。
应用场景：
这玩意儿的利用曾经很宽泛了，比方aop是吧 :)，当你想在调用一个办法的前后干点啥的时候，比方记录日志等，应用代理总比改每个办法的代码来的不便一些
动态代理：
当时由码农编写好代码，也就是在编译时就曾经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就曾经生成
模式实例：
写一个简略的动态代理的例子。我这儿举一个比拟毛糙的例子，一个不欠缺的坦克大战小游戏，如果我要在测试的时候记录一下坦克什么时候开动、什么时候进行，然而我不能再回过头去源代码外面增加这些代码。那该怎么办呢，如果咱们应用代理，该怎么操作呢，请听如下解说。
1、Movable 接口
interface Movable{
void move();
}2、Tank 坦克类
因为坦克类代码过多，咱们就简略模仿一下坦克的挪动，Tank类实现Movable接口。Tank能够具体实现挪动的动作。
public class Tank implements Movable {
/**
* 模仿坦克挪动了一段时间
*/
@Override
public void move() {
System.out.println("Tank moving claclacla......");
try{
Thread.sleep(new Random().nextInt(10000));
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) {
new TankTimeProxy(new TankLogProxy(new Tank())).move();
}
}3、TankLogProxy 代理类
TankLogProxy，这个类也实现了Movable接口，然而还另外持有一个Movable(持有Movable的起因是能够对实现了Movable的一系列类做代理操作，比方Tank)。
/** * 坦克代理类，也实现了Movable接口，保留一个Tank实体，这样既能够代理坦克产生行为
* */
class TankLogProxy implements Movable {
Tank t;
public TankLogProxy(Tank t) {
this.t = t;
}
@Override
public void move() {
System.out.println("start moving......");
t.move();
System.out.println("stopped");
}
}4、测试
public static void main(String[] args) {
new TankLogProxy(new Tank()).move();
}这里并没有间接调用Tank（被代理对象）来执行挪动的行为，而是通过代理对象来代理执行。这就是代理模式。
在jdk中，代理模式最次要的就是有一个公共接口（Movable），一个具体的类（Tank），一个代理类（TankLogProxy）,代理类持有具体类的实例，代为执行具体类实例办法。那么咱们在代理过程中就能够加上一些其余用处。就这个例子来说，咱们能够在坦克开动之前和完结之后进行一系列的日志记录，通过代理模式很轻松就能办到
长处
1、 协调调用者和被调用者，在肯定水平上升高了零碎的耦合度。
2、 在代理的过程中咱们能够对被代理对象做一些加强
毛病
1、因为在客户端和实在主题之间减少了代理对象，因而有些类型的代理模式可能会造成申请的处理速度变慢。
2、动态代理对一些简单的类可能显得不是很灵便
动静代理：
后面介绍了动态代理，尽管动态代理模式很好用，然而动态代理还是存在一些局限性的，比方应用动态代理模式须要程序员手写很多代码。一旦须要代理的类中办法比拟多，或者须要同时代理多个对象的时候，这无疑会减少很大的复杂度。
代理类在程序运行时创立的代理形式被成为动静代理。 咱们下面动态代理的例子中，代理类(TankLogProxy)是当时定义好的，在程序运行之前就曾经编译实现。然而动静代理，代理类并不是在Java代码中定义的，而是在运行时依据咱们在Java代码中的“批示”动静生成的。相比于动态代理， 动静代理的劣势在于能够很不便的对代理类的函数进行对立的解决，而不必批改每个代理类中的办法
模式实例：
在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口能够生成JDK动静代理类和动静代理对象
1、Movable 接口
interface Movable{
void move();
}2、Tank 坦克类
因为坦克类代码过多，咱们就简略模仿一下坦克的挪动，Tank类实现Movable接口。Tank能够具体实现挪动的动作。
public class Tank implements Movable {
/**
* 模仿坦克挪动了一段时间
*/
@Override
public void move() {
System.out.println("Tank moving claclacla......");
try{
Thread.sleep(new Random().nextInt(10000));
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) {
new TankTimeProxy(new TankLogProxy(new Tank())).move();
}
}3、TimeProxy 实现InvocationHandler接口
class TimeProxy implements InvocationHandler{
Movable m;
public TimeProxy(Movable m) {
this.m = m;
}
public void before(){
System.out.println("method start..");
}
public void after(){
System.out.println("method stop..");
}
/** *Object proxy是生成的代理对象, Method method是Movable接口的move，通过反射获取, Object[] args是实在对象中调用办法的参数 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object o = method.invoke(m,args);
after();
return o;
}
}4、测试
public static void main(String[] args) {
Tank tank = new Tank();
/**
生成代理对象
Tank.class.getClassLoader():应用哪个类加载器来加载生成的代理对象
new Class[]{Movable.class}:被代理类实现了哪些接口
new TimeProxy(tank):代理的具体逻辑解决
*/
Movable m = (Movable) Proxy.newProxyInstance(Tank.class.getClassLoader(),
new Class[]{Movable.class},
new TimeProxy(tank));
m.move();
}动静代理的劣势在于能够很不便的对代理类的办法进行对立的解决，而不必批改每个代理类中的办法。因为所有被代理执行的办法，都是通过在InvocationHandler中的invoke办法调用的，所以咱们只有在invoke办法中对立解决，就能够对所有被代理的办法进行雷同的操作了。
动静代理原理图：
cglib：生成代理
package com.mashibing.proxy.cglib;
import java.lang.reflect.Method;
import java.util.Random;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class Main {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Tank.class);
enhancer.setCallback(new TimeMethodInterceptor());
Tank tank = (Tank)enhancer.create();
tank.move();
}
}
class TimeMethodInterceptor implements MethodInterceptor{
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println(o.getClass().getSuperclass().getName());
System.out.println("before");
Object result = null;
result = methodProxy.invokeSuper(o,objects);
System.out.println("after");
return result;
}
}
class Tank{
public void move() {
System.out.println("Tank moving claclacla...");
try{
Thread.sleep(new Random().nextInt(10000));
} catch (Exception e){
e.printStackTrace();
}
}
}总结：jdk的动静代理，总的来说
1、Proxy通过传递给它的参数（interfaces/invocationHandler）生成代理类$Proxy0
2、Proxy通过传递给它的参数（ClassLoader）来加载生成的代理类$Proxy0的字节码文件
参考大神之作：https://www.cnblogs.com/java-chen-hao/p/10643744.html
发表回复