动态代理和反射

2017-04-10

1 反射

通过反射的方式可以获取class对象中的属性、方法、构造函数等

/**
 * Java反射测试
 * @author NikoBelic
 * @create 2017/4/10 14:19
 */
public class ReflectionTest<T>
{
    /**
     * 通过class类路径创建对象
     *
     * @param className 类的相对路径
     * @param params    构造器的参数
     * @param _private  是否使用私有构造函数
     * @Author SeawayLee
     * @Date 2017/04/10 14:27
     */
    public T getInstance(String className, Map<Object, Object> params, Boolean _private) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException, IOException
    {
        Class clazz = Class.forName(className);
        Class<?>[] paramTypes = new Class<?>[params != null ? params.size() : 0];
        Object[] paramValues = new Object[params != null ? params.size() : 0];
        Constructor constructor;
        T instance;
        if (params == null)
        {
            instance = (T) clazz.newInstance();
            Field name = clazz.getDeclaredField("name");
            Field age = clazz.getDeclaredField("age");
            name.setAccessible(true);
            age.setAccessible(true);
            name.set(instance, "默认name");
            age.set(instance, 99);
        } else
        {
            int index = 0;
            for (Map.Entry entry : params.entrySet())
            {
                paramTypes[index] = (Class<?>) entry.getKey();
                paramValues[index] = entry.getValue();
                index++;
            }
            constructor = !_private ? clazz.getConstructor(paramTypes) : clazz.getDeclaredConstructor(paramTypes);
            constructor.setAccessible(true); // 强制取消Java的权限检测
            instance = (T) constructor.newInstance(paramValues);
        }
        // 获取私有方法
        Method method = clazz.getDeclaredMethod("talk");
        method.setAccessible(true);
        Object invokeResult = method.invoke(instance);
        System.out.println("私有函数反射结果输出:" + invokeResult);
        // 获取类加载器
        System.out.println("类加载器：" + clazz.getClassLoader());
        // 获取接口
        System.out.println("接口：");
        for (Class c : clazz.getInterfaces())
             System.out.println(c);
        // 获取父类
        System.out.println("父类：" + clazz.getGenericSuperclass());
        // 获取静态资源文件
        byte[] buff = new byte[1024];
        clazz.getResourceAsStream("config.properties").read(buff);
        System.out.println("配置文件:" + new String(buff,"UTF-8"));
        return instance;
    }
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException, IOException
    {
        ReflectionTest<Person> ref = new ReflectionTest();
        // 构造参数
        Map<Object, Object> params = new HashMap<>();
        params.put(String.class, "NikoBelic");
        //params.put(Integer.class, 18);
        //Person p = ref.getInstance("reflection.Person", params, true); // 通过有参构造器创建实例
        Person p = ref.getInstance("reflection.Person", null, true); // 通过午餐构造器创建实例
        System.out.println(p);
    }
}

动态代理

假设在之前的代码调用阶段，我们用action调用service的方法实现业务即可。
由于之前在service中实现的业务可能不能够满足当先客户的要求，需要我们重新修改service中的方法，但是service的方法不只在我们这个模块使用，在其他模块也在调用，其他模块调用的时候，现有的service方法已经能够满足业务需求，所以我们不能只为了我们的业务而修改service，导致其他模块授影响。

那怎么办呢？

可以通过动态代理的方式，扩展我们的service中的方法实现，使得在原油的方法中增加更多的业务，而不是实际修改service中的方法，这种实现技术就叫做动态代理。
动态代理：在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。

例如下面的例子：

旧业务
- 买家调用action，购买衣服，衣服在数据库的标价为50元，购买流程就是简单的调用。
新业务
- 在原先的价格上可以使用优惠券，但是这个功能在以前没有实现过，我们通过代理类，代理了原先的接口方法，在这个方法的基础上，修改了返回值。

/**
 * 动态代理测试
 * @author NikoBelic
 * @create 2017/4/10 16:22
 */
public class ProductServiceProxy
{
    /**
     * 获取动态代理实例
     * @Author SeawayLee
     * @Date 2017/04/10 17:06
     */
    public ProductService getProxy(Class clazz,Class[] interfaces,Integer discount) throws ClassNotFoundException
    {
        Object proxy = Proxy.newProxyInstance(clazz.getClassLoader(), interfaces, (proxyObj, method, args) ->
        {
            Integer returnValue = (Integer) method.invoke(new ProductServiceImpl(), args);
            return returnValue - discount;
        });
        return (ProductService) proxy;
    }
    public static void main(String[] args) throws ClassNotFoundException
    {
        ProductServiceProxy proxy = new ProductServiceProxy();
        // 获取代理类
        ProductService productServiceProxy = proxy.getProxy(ProductServiceImpl.class,new Class[]{ProductService.class},40);
        System.out.println(productServiceProxy.getPrice());
    }
}