JAVA的动态代理

JAVA的动态代理模式，理解上要分开，一个是纯代理模式，另一个是动态反射。

例子定义了两个接口，飞行接口，扣篮接口，投篮接口，其中乔丹实现了这三个接口，科比只实现了投篮与扣篮两个接口。

动态代理，一句简单的话来讲，就是：
Proxy类为我们建立出一个实体类的副本a，该副本a只对外声明了实现类实现的所有接口中的方法，且副本中保存了一个invocationHandler的实现类b。
此时的a就是一个代理类，当用户拿a去调用接口的方法时（即代理模式），JVM会将该副本类a及用户要调用的方法名还有参数交由b，通过反射机制实现【动态】调用

/**
* 篮球运动员 投篮 的接口
* */
public interface PlayerShoot {
public void shoot();
}

/**
* 运动员飞行接口
* */
public interface PlayerFly {
public void fly();
}

/**
* 篮球运动员 扣篮 的接口
* */
public interface PlayerDunk {
public void dunk();
}

/**
* 迈克尔乔丹 实现了投篮和扣篮这两个接口
* */
public class MichaelJordan implements PlayerShoot, PlayerDunk,PlayerFly{

@Override
public void dunk() {
System.out.println("Michael Jordan Dunk!!!WOW!!!");
}

@Override
public void shoot() {
System.out.println("Michael Jordan Shoot!!!Got it!!!");
}

@Override
public void fly() {
System.out.println("Look at that,mj is flying.....");
}
}

/**
* 科比类，同样实现了扣篮与投篮两个接口
* */
public class Kobe implements PlayerShoot, PlayerDunk {

@Override
public void dunk() {
System.out.println("Kobe Dunk!!!WOW!!!Not in!!");
}

@Override
public void shoot() {
System.out.println("Kobe Shoot!!!Fuck hit the rim!!!");
}

}

/**
* 这个类不是代理对象，而是代理对象中方法的调用渠道
* */
public class GameHandle implements InvocationHandler {

private Object player;

public GameHandle(Object player){
this.player = player;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {

method.invoke(this.player, args);
return null;
}

public Object getPlayer() {
return player;
}

public void setPlayer(Object player) {
this.player = player;
}
}

public class GameStart {
/**
* JAVA的动态代理小结
*
* 1， 明确真实对象所具备的方法，即声明真实对象要实现的接口，起名曰 ability_interface
*
* 2, 明确真实对象所属类的方法的具体实现，即真实对象类要实现ability_interface中的所有方法，起名曰 ability_class
*
* 3，使用JVM的机制，实现接口InvocationHandler，实现类中必须实现invoke方法，起名曰inner_reflection
*
* 4，创建代理对象，使用Proxy.newProxyInstance方法，依次传递arg1,arg2,arg3，依次对应ability_class的classLoader，ability_interface中定义的方法，inner_reflection
* 此时，创建出的代理对象起名曰ProxyObject，简单理解起来，ProxyObject就是ability_class的一个副本，只不过，对外只公开ability_interface中定义的方法
*
* 注意：在创建ProxyObject的时候，JVM会将inner_reflection通过构造函数传递给ProxyObject，由此，ProxyObject就知道了由谁来通过反射机制调用其内的方法
*
* 5，此时，拿着ProxyObject就可以调用ability_interface中的方法了，参数由用户指定，而该方法的调用，则是由JVM将其传递给与ProxyObject中保存的inner_reflection
* 这里是通过反射机制来完成的，即将ProxyObject和其内要调用的方法名及用户指定的参数交由inner_reflection的invoke方法来调用
*
* 至此，就实现了通过JAVA的反射机制，针对不同真实对象的代理模式
*
* */
public static void main(String[] args) {

/**
* 这里有两个真实对象需要被代理，一个是乔丹，一个是科比
* */
MichaelJordan mj = new MichaelJordan();
Kobe kb = new Kobe();

Class<?> mjClass = mj.getClass();
Class<?> kbClass = kb.getClass();

/**
* 创建代理对象方法的调用渠道
* */
InvocationHandler bc = new GameHandle(kb);

/**
* 创建真实对象 科比 的代理对象
* */
Object actionkb = Proxy.newProxyInstance(kbClass.getClassLoader(), kbClass.getInterfaces(), bc);
/**
* 拿着科比的代理对象去调用科比已“具备的能力”，即其已实现的接口
* */
((PlayerDunk)actionkb).dunk();
((PlayerShoot)actionkb).shoot();

/**
* 现在需要代理 乔丹了，去创建出乔丹的代理对象
* */
((GameHandle)bc).setPlayer(mj);
Object actionmj = Proxy.newProxyInstance(mjClass.getClassLoader(), mjClass.getInterfaces(), bc);
/**
* 此时拿乔丹的代理对象去调用乔丹所具备的能力
* */
((PlayerDunk)actionmj).dunk();
((PlayerShoot)actionmj).shoot();
((PlayerFly)actionmj).fly();
}
}