jdk动态代理的简单实现

动态代理

• 通过jdk的反射机制，创建对象的能力，创建的对象是代理类对象，不用创建相关的类文件。

• 作用

  • 控制访问
  • 功能增强

• 实现

  • jdk动态代理：要求目标类和代理类实现相同的接口。
  • cglib动态代理：要求目标类可以被继承，即不能被final修饰，做法是生成目标类的增强的子类。

• JDK动态代理实现

  • 创建功能类接口

    package com.lzx.service;
    
    public interface Sell {
        float sell(int num);
    }
    

  • 创建目标类实现功能接口

    package com.lzx.factory;
    
    import com.lzx.service.Sell;
    
    public class Factory implements Sell {
        @Override
        public float sell(int num) {
            return 12.0f;
        }
    }
    

  • 创建InvocationHandler接口的实现类，重写invoke方法，完成代理类的功能：调用目标类的方法，增强功能。

    import com.lzx.service.Sell;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class MyHandler implements InvocationHandler {
        private Sell target = null;
    
        public MyHandler(Sell target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //目标方法调用
            Object res = method.invoke(target, args);
            //功能增强。
            if(res!=null){
                float f = (float) res;
                f = 2 * f;
                res = f;
            }
            return res;
        }
    }
    

  • 使用Proxy类的静态方法，创建代理类对象，将返回值转为接口类型，最后调用方法。

    package com.lzx.test;
    
    import com.lzx.factory.Factory;
    import com.lzx.handler.MyHandler;
    import com.lzx.service.Sell;
    
    import java.lang.reflect.Proxy;
    
    public class Test {
        public static void main(String[] args) {
            //创建目标类对象
            Sell factory = new Factory();
            MyHandler handler = new MyHandler(factory);
            //生成代理类对象
            Object obj = Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), handler);
            Sell proxy = (Sell) obj;
            //调用增强的目标类方法
            float res = proxy.sell(1);
            System.out.println(res);
        }
    }