java 代理

java的代理有两种： 静态代理和动态代理，在一些比较高级的功能中就会使用到java代理，这里复习一下java的代理。

代理的功能：可以做到: 修改function的参数和返回值，function执行前后添加部分功能

代理模式是常用的java设计模式，特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

静态代理

静态代理就是实现一个类Proxy, 类Proxy实现了类A的interface ICheckListener, 并在实现的代码里面调用类A的接口，对外提供Proxy， 不提供A，具体看代码。

interface ICheckListener() {
    void onCheck(int num);
}

class CheckImpl implements ICheckListener {
    @Overrude
    public void onCheck(int num) {
        if (num > 10) {
            Logger.i(TAG, "bigger than 10")
       } else {
            Logger.i(TAG, "smaller than 10");
       }
    }
}

Class CheckImplProxy implments ICheckListener {
     CheckImpl a;
     public CheckImplProxy(CheckImpl a) {
         this.a = a; 
    }
    @Override
    public void onCheck(int num) {
         num = num - 10;
         Logger(TAG, "begin to change");
         if (this.a != null) {
              a.onCheck(num);
         }
         Logger(TAG, "end to change");
    }
}

在使用到CheckImpl的实例的地方把CheckImpl替换成CheckImplProxy的实例，对外是无感知的行为，当调用onCheck()方法时，CheckImplProxy的实例就会将参数减少10 并且在调用开始和结束的地方都打上log。

实现静态代理，最主要的是找到想要替换的实例（通常是静态实例或者单例类），生成 hook后的实例，取代要替换的实例。

静态代理的缺点：

1. 由于代理类需要实现所有的原始类的方法，当接口出现变动时， 代理类同样需要跟着修改，这样就出现代码冗余以及代码维护不方便的问题
2. 一个代理类只能服务于一种类型的对象(例如CheckImpl)，当需要为另外的类(例如ShoppingImpl)实现代理类时，我们不得不重新编写新的代理类.

动态代理

所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理
在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

//interface
public interface IShopAction {
    void doShop(int count);
}


//impl
public class DynamicProxyExample implements IShopAction {
    public static String TAG = DynamicProxyExample.class.getSimpleName();
    @Override
    public void doShop(int count) {
        Log.d(TAG, "buy " +  count + " item in shop");
    }
}




//invocationHandler
public class ShopInvocationHandler implements InvocationHandler {
    Object target ;
    public ShopInvocationHandler(Object example) {
        target = example;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Log.d("cheng", "method name:"+method.getName() + " class name:" + proxy.getClass().getSimpleName() + " args length:"+ args.length);
        if ("doShop".equals(method.getName()) && proxy instanceof IShopAction) {
            Log.d("cheng", "proxy begin work");

            //如果是dynamicproxyexample 的doshop方法
            int num = (int)args[0];
            num = num / 2;
            //修改参数
            Log.d("cheng", num +"购买的商品数量");
            //执行购买操作
            Object result =  method.invoke(target, num);
            //操作完
            Log.d("cheng", "proxy end work");
            return result;
        }

        return null;
    }
}


//test
public class DynamicProxyExampleTest {
    public static void doShopActionTest() {
        DynamicProxyExample example = new DynamicProxyExample();
        InvocationHandler handler = new ShopInvocationHandler(example);
        IShopAction exampleProxy = (IShopAction) Proxy.newProxyInstance(example.getClass().getClassLoader(), example.getClass().getInterfaces(), handler);//这里转换类型只能强制转换为接口类型，不能转换为其他类型。
        exampleProxy.doShop(10);

        DynamicProxyExample example = new DynamicProxyExample();
        example.doShop(10);
    }
}

实现InvocationHandler的invoke方法，判断方法名以及接口名，如果是我们希望处理的方法以及接口，则获取方法名，参数名，在调用实际方法前，打印log日志，调用实际方法后，同样打印一条log日志，运行程序后，发现i的确走到了invocationHandler里面了。

以上就是jdk的动态代理， jdk的动态代理要求被代理的类实现了某个接口，如果需要被代理的类没有实现接口，则不能用这种方式实现动态代理， 可以使用cglib的动态代理。

refs:

• java 静动态代理
• cglib jdk动态代理