java代理

1、静态代理

运行之前，代理类就已经存在了

接口类Airplane，实现一个接口、

public interface Airplane {
//定义了一个功能
String buyTicket(String name);
}

目标类Csair，实现具体功能，也叫委托类

public class Csair implements Airplane{
//重写了接口类的功能
public String buyTicket(String name){
return name+",no:"+Math.random();
}
}

代理类Fliggy，调用Csair类的功能

public class Fliggy implements Airplane {
Airplane csAir;

public Fliggy(){
//构造器内实例化目标类，之后可以在重写的时候调用目标类的方法
csAir = new Csair();
}
//重写了功能，并且使用接口调用了父类的子类
public String buyTicket(String name){
return csAir.buyTicket(name);
}
}

运行类Main

public class Main {
public static void main(String[] args) {
/*这里是通过目标类直接实例化对象调用*/
Airplane csair = new Csair();
System.out.println(csair.buyTicket("tom"));

/*这里是通过接口类调用目标类*/
Airplane fliggy = new Fliggy();
System.out.println(fliggy.buyTicket("jack"));
}
}

2、动态代理

代理类在运行时创建，动态代理，代理类并不是在java代码中定义，而是在运行时产生

接口类Airplane，实现一个接口，这里不执行任何功能，仅做框架

public interface Airplane {
String buyTicket(String name);
}

目标类Csair，实现具体功能

public class Csair implements Airplane{
//重写了接口类的功能
public String buyTicket(String name){
return name+",no:"+Math.random();
}
}

动态代理类jdkProxy

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

public class JdkProxy<T> implements InvocationHandler {
T target;

public Object JdkProxy(T target){ //绑定代理
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}

public Object invoke(Object proxy, Method method,Object[] args) throws Throwable{ //呼叫函数
Object res = method.invoke(target,args);
return res;
}
}

运行类Main

import java.lang.ref.SoftReference;

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

Csair csair = new Csair();

JdkProxy appProxy = new JdkProxy();
Airplane airProxy = (Airplane) appProxy.JdkProxy(csair); //传递给绑定，告诉他绑定到哪个类中，invoke会自动完成调用

String res = airProxy.buyTicket("tom"); //利用动态代理呼叫函数
System.out.println(res);
}
}