一些常用到的代码实现

于 2018-01-06 09:26:05 发布
阅读量327 收藏
点赞数

JDK动态代理技术

实例展示

1. 定义我们的代理接口

package com.proxy.demo1;

public interface MyProxy {

    void method1() throws InterruptedException;
    void method2() throws InterruptedException;
    void method3() throws InterruptedException;
}

2. 定义我们的被代理对象——庞大臃肿的“老类”

package com.proxy.demo1;
//这是我们项目中“历史悠久”的类，功能完整，有很多方法。现在我们需要为每个方法都实现性能统计
//我们的被代理类要实现我们的代理接口,总某种程度讲，这也是侵入式的。但是最微弱的侵入。
public class OldClass implements MyProxy {
    @Override
    public void method1() throws InterruptedException{
        System.out.println("正在处理业务逻辑1");
        Thread.sleep(100);//模拟处理业务逻辑4过程
        System.out.println("业务逻辑1处理完成");
    }
    @Override
    public void method2() throws InterruptedException{
        System.out.println("正在处理业务逻辑2");
        Thread.sleep(200);//模拟处理业务逻辑2过程
        System.out.println("业务逻辑2处理完成");
    }
    @Override
    public void method3() throws InterruptedException{
        System.out.println("正在处理业务逻辑3");
        Thread.sleep(300);//模拟处理业务逻辑3过程
        System.out.println("业务逻辑3处理完成");
    }
    //下面还有很多很多方法。。
}

3. 定义我们的invokationHandler

package com.proxy.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//这里我们使用了泛型，假设我们有很多的类都需要进行性能监控，就可以通过在创建本类对象时在泛型标识处改成对应需要监控的类即可。
//注意需要实现JDK反射包中的InvocationHandler接口
public class //这里我们使用了泛型，假设我们有很多的类都需要进行性能监控，就可以通过在创建本类对象时在泛型标识处改成对应需要监控的类即可。
//注意需要实现JDK反射包中的InvocationHandler接口<E> implements InvocationHandler {
    //需要被代理的对象
    private E target;

    public MyInvokationHandler(E target){
        this.target = target;
    }
    /**
     * @param：
    *  proxy : 在其上调用方法的代理实例
    *  method : 对应于在目标对象调用的方法。
    *  args : 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null
    *           基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。 
    *  @return  从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，
*           则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。
    *       如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException
    *       否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。 
    *  @throws  Throwable - 从代理实例上的方法调用抛出的异常。
    *        该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型
    *        或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。
    *            如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型.
    *            代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Long beginTime = System.currentTimeMillis();//记录开始时间
        //调用目标对象的方法，同时获取该方法的返回值，作为我们本代理方法(invoke)的返回值
        Object returnValue = method.invoke(target, args);//target为我们方法所在的目标类，args为方法参数
        System.out.println("方法" + method.getName() + "调用结束，耗时"+ (System.currentTimeMillis() - beginTime));
        return returnValue;
    }

}

从字面意思理解是InvocationHandler是调用处理器，在这里，它是一个方法调用处理器。更通俗来说，我们可以将它理解成一个拦截器，当我们调用被代理类中的方法时，就会被MyInvocationHandler拦截下来，再调用我们的invoke方法。

4. 测试方法

package com.proxy.demo1;

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

public class MainTest {
    public static void main(String args[]) throws InterruptedException{
        //新建我们的被代理对象
        OldClass oldClass = new OldClass();
        //创建我们的“拦截器”，并注入被代理对象
        InvocationHandler handler = new MyInvocationHandler<OldClass>(oldClass);
        /*getProxy返回一个指定接口的代理类实例，
        该接口可以将方法调用指派到指定的调用处理程序,这里是我们自定义的handler
        第一个参数 - 定义代理类的类加载器
        第二个参数 - 代理类要实现的接口列表
        第三个参数- 指派方法调用的调用处理程序 InvocationHandler
        */
        MyProxy myProxy = (MyProxy)Proxy.newProxyInstance(MyProxy.class.getClassLoader(),new Class[]{MyProxy.class},handler);

        myProxy.method1();
        myProxy.method2();
        myProxy.method3();
    }
}

5. 打印结果

正在处理业务逻辑1 
业务逻辑1处理完成 
方法method1调用结束，耗时101 
正在处理业务逻辑2 
业务逻辑2处理完成 
方法method2调用结束，耗时200 
正在处理业务逻辑3 
业务逻辑3处理完成 
方法method3调用结束，耗时301

我们通过代理类来调用OldClass的方法，实现了对OldClass类中所有方法耗时统计的性能监控功能，但我们并未在OldClass中嵌入任何相关的业务逻辑代码，唯一的修改就是实现了我们的代理接口。

实例分析

我们方法调用的核心实现在于使用invocationHandler，实际上，我们在通过代理接口调用被代理对象的方法如myProxy.method1()的时候，我们实际调用的是我们自定义的handler里面的invoke方法，只是，我们在invoke方法又根据传入对象（oldClass）和参数（这里没有传参），重新调用了我们oldClass里面的method1而已。而且通过这种动态代理，我们还需要修改我们的上层接口，比如我是在oldClassBoss中调用oldClass的method1方法的，现在要在我们的oldClassBoss中创建代理并通过myProxy.method1();来实现我们对原发的性能监控增强功能。这是我们需要明确的。

CGLib动态代理基本原理

源码实例展示

1. 定义被代理对象

我们的被代理对象：OldClass当然是不(能)变的啦。

public class OldClass {
    public void method1() throws InterruptedException{
        System.out.println("正在处理业务逻辑1");
        Thread.sleep(100);//模拟处理业务逻辑1过程
        System.out.println("业务逻辑1处理完成");
    }
    public void method2() throws InterruptedException{
        System.out.println("正在处理业务逻辑2");
        Thread.sleep(200);//模拟处理业务逻辑2过程
        System.out.println("业务逻辑2处理完成");
    }
    public void method3(String userName) throws InterruptedException{
        System.out.println("正在处理业务逻辑3");
        Thread.sleep(300);//模拟处理业务逻辑3过程
        System.out.println("业务逻辑3处理完成");
    }
    //下面还有很多很多。。
}

2. 定义代理生成工厂

public class ProxyFactory {
    private Enhancer enhancer = new Enhancer();//动态的类生成器
    public Object createSubObject(Class<?> clazz){
        enhancer.setSuperclass(clazz);//设置需要创建的类，这个类的父类是clazz类
        //当通过enhancer创建的类中的方法被调用时，该方法会被CallBack指定的对象拦截。
        enhancer.setCallbacks(new Callback[]{new MyTimeInterceptor(),new MyRecordInterceptor()});
        enhancer.setCallbackFilter(new MyCallBackFilter());//设置我们自定义的过滤器
        return enhancer.create();//通过字节码技术动态创建子类实例
    }
}

3. 定义增强拦截器

下面定义我们的两个CallBack实现类，一个负责拦截需要统计耗时的方法，另一个拦截需要进行日志记录的方法

1. 耗时统计拦截器

public class MyTimeInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object target, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {//拦截所有父类方法的调用
        Long beginTime = System.currentTimeMillis();//记录开始时间
        //调用目标对象的方法，同时获取该方法的返回值，作为我们本代理方法(invoke)的返回值
        Object returnValue = proxy.invokeSuper(target, args);//target为我们方法所在的目标类，args为方法参数
        System.out.println("方法" + method.getName() + "调用结束，耗时"+ (System.currentTimeMillis() - beginTime));
        return returnValue;
    }
}

2. 日志记录拦截器

public class MyRecordInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object target, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {// 拦截所有父类方法的调用
        System.out.println(args[0] + "在"
                + new SimpleDateFormat("yyyy-MM-dd HH-mm").format(new Date())
                + "调用了方法" + method.getName());
        Object returnValue = proxy.invokeSuper(target, args);// target为我们方法所在的目标类，args为方法参数
        return returnValue;
    }

}

4. 定义我们的拦截过滤器

public class MyCallBackFilter implements CallbackFilter{//需要实现特定接口

    @Override
    public int accept(Method method) {
        if("method3" .equals(method.getName())){//如果被拦截的方法名满足特定条件
            //这里的序号对应于enhancer.setCallbacks(new Callback[]{new MyTimeInterceptor(),new MyRecordInterceptor()})中的Callback数组的拦截器索引
            return 1;
        }else{
            return 0;
        }
    }
}

5. 测试方法

public static void main(String args[]) throws InterruptedException{
    ProxyFactory cgLibProxy = new ProxyFactory();//创建我们的代理类
    //通过enhancer创建我们的子类
    //因为oldClass是我们子类的父类，所以这里向上转型成功
    OldClass oldClass = (OldClass) cgLibProxy.createSubObject(OldClass.class);
    oldClass.method1();//调用方法
    oldClass.method2();//调用方法
    oldClass.method3("zenghao");//调用方法
}

6. 结果分析

运行5中的测试方法，控制台打印：

正在处理业务逻辑1 
业务逻辑1处理完成 
方法method1调用结束，耗时116 
正在处理业务逻辑2 
业务逻辑2处理完成 
方法method2调用结束，耗时201 
zenghao在2016-03-24 18-32调用了方法method3 
正在处理业务逻辑3 
业务逻辑3处理完成

在这里，我们的method1和method2还是被拦截下来统计耗时，但我们的method3就在调用前被做了日志记录了。

小结

使用CGlib来通过生成子类来完成代理，这样，我们就不用强迫我们的被代理类实现代理接口了，侵入性更低。而且，使用CGLib还能为我们的拦截方法实现智能过滤，相对于使用JDK的动态代理，还是优雅了很多。 
但在实际的应用场景中，如果我们每次使用AOP，都要进行如上所示一堆配置，还是挺繁琐的，但如果我们把配置的工作，交给spring完成，那么我们只要通过简洁的配置，就能轻松实现我们的动态代理。甚至结合上spring的许多特性，我们的代理功能还会更加的灵活强大。 
通过对JDK和CGLib动态代理的实例理解，我们对AOP有一个更全面而感性地认识，从下篇文章我们开始进入springAOP部分的学习分析。



kit_where
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值