代理模式是一种结构型模式，在client和使用的对象间新建一个代理类，通过代理类创建对象调用方法，

优势：代理类是实际类的替代类，能解决调用方与被调用方的耦合，代理也能增强被代理类(拓展一些功能)，如：在实现某类的功能时，需要打印日志(spring的AOP就是对动态代理模式的使用)

代理模式分类：

1，静态代理(也叫接口代理)：代理和被代理类都需要实现一个公共的接口，实例化在代理类的内部实现

2，动态代理：不需要实现公共接口，对象的实例化，由反射动态注入

问题：年过半百的WQL突然想到了一个遗憾，那就是他还没有女朋友，他决定去找个正常的女票谈恋爱

传统方法：

WQL自己主动的在复杂的社会中找到最合适的那个人

public class text {
    public static void main(String[] args) {
               WQL44 E=new WQL44(new nv());
               E.succeed();
    }
}
class WQL44{
    nv fuqing;
    public WQL44(nv fuqing) {
        this.fuqing = fuqing;
    }
    public void succeed(){
        fuqing.c();
    }
}

class  nv{
    public void c(){
        System.out.print("成功!!!");

    }

静态代理实现：

WQL在某征婚平台，发布了征婚公告，如果有配备的平台会提醒WQL

public class text {
    public static void main(String[] args) {

        WQL44 E=new WQL44(new Matchmakingplatform(new nv()));
               E.w();
    }
}
class WQL44{
    Matchmakingplatform a;
    public WQL44(Matchmakingplatform a) {
        this.a = a;
    }
    public void  w(){
        a.succeed();
    }}

    interface g{
    public void succeed();

   }

class Matchmakingplatform implements g{
   //聚合一个被代理对象
    g fuqing; //接口类型，都继承接口这样一个代理类可以代理多个类
    public Matchmakingplatform(g fuqing) {
        this.fuqing = fuqing;
    }
    public void succeed(){
//增强这个被代理类
        System.out.println("MVP");
        fuqing.succeed();
    }}

class  nv implements g{
    public void succeed(){
        System.out.print("成功!!!");

    }


}

动态代理：

代理模式模式本质上运用的就是反射，提供在程序运行过程中，反射创建对象，实现代理的效果

动态代理分为三类：

基于接口的代理：JDK代理（我们基于接口代理）

基于类的代理：cglib

java字节码实现：javasist

 

动态代理主要依赖java类中Proxy和invocationhandler这两个接口

两者的作用：

proxy：创建代理的实例对象

invocationhandler：代理实例关联的调用处理程序，通过它来调用方法

方式一：

interface Rent {
public void rents();
}


public class rent implements Rent {
@Override
public void rents() {
// TODO Auto-generated method stub
System.out.print("我要租房子！！！");
}
}

class proxyrent implements InvocationHandler{

private Rent H ;

public Rent getH() {
return H;
}

public void setH(Rent h) {
H = h;
}

/*参数说明：
* proxy：代理的对象
* method：代理的方法
* args：方法参数
*/
//生成代理实例
public Object rentproxy() {

return Proxy.newProxyInstance(this.getClass().getClassLoader(),H.getClass().getInterfaces(),this);
}

//处理代理实例并返回结果(相当于在代理实例上增强，在运行时反射)
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
Object a=method.invoke(H,args);
kk();
return a;
}

//其他增加项
public void kk() {

System.out.println("找中介！");

}

 

 

方式二：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class text2 {
    public static void main(String[] args) {

        WQL56 a=new WQL56(new nv1());
        Top as=(Top)a.Secceed();
        as.secceed();
    }
}

class WQL56{
  private Object NV;
    public WQL56(Object NV) {
        this.NV = NV;
    }

    public Object Secceed(){

        return Proxy.newProxyInstance(NV.getClass().getClassLoader(), NV.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
               System.out.println("asdad");
                Object a=method.invoke(NV,objects);
                return a;
            }
        });
  }
}

interface Top{
public void  secceed();
}

class nv1 implements Top{
    public  void secceed(){
        System.out.println("asd");
    }
}