菲律宾太阳 1

前言

什么是java代理,为什么要学习java代理。在很多框架中都会用到,如Spring中的AOP、Hadoop中的RPC等

要了解Spring的AOP就必须要了解动态代理的原理,因为AOP就是基于动态代理实现的。

java中反射与动态代理是java程序员不可忽略的一门功课,关于其概念、基本使用方式,网上一大堆,本文主要讲解本人对于这两者的认识,以及关于开源项目中典型用法。

什么是JAVA代理

给某一个对象提供一个代理,并由代理对象控制对原对象的引用。

   
java.lang.reflect包下有个Proxy类,它正是构造代理类的入口,其中newProxyInstance就是创建代理对象的方法,这个方法需要三个参数:

Java反射机制:在程序运行时获取已知名称的类或已有对象的相关信息的一种机制,包括类的方法、属性、父类等,还包括实例的创建和实例类型的判断等。

代理的种类

代理分为静态代理和动态代理,静态代理是在编译时就将接口、实现类、代理类全部由程序员手动完成,且代理的类在程序运行之前就已经存在了。但如果我们需要很多的代理,每一个都这么手动的去创建实属浪费时间,而且会有大量的重复代码,此时我们就可以采用动态代理,动态代理可以在程序运行期间根据需要动态的创建代理类及其实例,来完成具体的功能。

        1.ClassLoader(用于加载代理类的loader);

是不是很抽象?来看个例子,在Spring中经常有如下的配置:

静态代理

定义一个PersonEntity实体

public class  PersonEntity{
    private String name;
    private Integer age;
    get,set方法省略
}

定义一个Person接口

public interface PersonService {
    public PersonEntity getPerson();
    public void personInfo(PersonEntity entity);
}

实现PersonService接口

public class PersonServiceImpl implements PersonService {
    private static PersonEntity entity=null;
    @Override
    public PersonEntity getPerson() {
        return createPerson();
    }
    @Override
    public void personInfo(PersonEntity entity) {
        System.out.println("person_name:"+entity.getName()+",person_age:"+entity.getAge());
    }
    public static PersonEntity createPerson(){
        if(entity==null){
            entity=new PersonEntity();
            return entity;
        }else{
            return entity;
        }
    }
}

调用PersonServiceImpl

public class Test{
    public static void main(String[] args) {
        PersonService pService = new PersonServiceImpl();
        PersonEntity entity=new PersonEntity();
        entity.setAge(22);
        entity.setName("youshh");
        pService.personInfo(entity);
    }
}

运行结果:

person_name:youshh,person_age:22

        2.Interfaces,是要被代理的那些接口;

<bean ></bean>

动态代理

动态代理的基础代码同静态代码一致,但是并不是通过new
的方式来获取接口而是通过重写InvocationHandler的invoke接口来实现代理功能(InvocationHandler是JDK的动态代理接口里面只有一个invoke方法,返回值为Object)
代理PersonProxyHandler的代码:

public class PersonProxyHandler implements InvocationHandler {
    private Object object;
    public PersonProxyHandler(Object object) {
        super();
        this.object = object;
    }
    /**
    * 继承InvocationHandler 代理接口, 实现invoke方法
    */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        System.out.println("before proxy ");
        Object p=method.invoke(object, args);
        System.out.println("after proxy");
        return p;
    }
}

调用

public class Test {
    public static void main(String[] args) {
        PersonService pService = new PersonServiceImpl();
        InvocationHandler handler =new PersonProxyHandler(pService);
        PersonService pService2 = (PersonService) Proxy.newProxyInstance(handler.getClass().getClassLoader(), pService.getClass().getInterfaces(), handler);
        PersonEntity entity=pService2.getPerson();
        entity.setAge(24);
        entity.setName("youshh");
        pService2.personInfo(entity);
    }
}

运行结果:

person_name:youshh,person_age:22

值得注意的是在invoke中如果return
null,那么在调用有返回值的方法时就获取不到其返回值,而最终获取到的是null,例如PersonEntity
entity=pService2.getPerson();在调用时
entity最终为null,所以在实际业务中invoke的是否需要返回值更具实际来定义。
从上面代码中可以看出 PersonService 是通过Proxy.newProxyInstance 生成的,

        3.InvocationHandler,用于执行除了被代理接口中方法之外的用户自定义操作(也是我们需要代理类的真正目的)。用户调用目标方法都被代理到InvocationHandler类中定义的唯一方法Invoke()中。

(在此不讨论具体Spring容器启动细节,只是讨论与反射相关的知识点。)

在proxy中的代码有什么样的呢?

为什么能通过Proxy的静态方法newProxyInstance获取到PersonService的实例呢?这个是通过JAVA的反射机制实现的。

//由于 Proxy 内部从不直接调用构造函数,所以 private
类型意味着禁止任何调用private Proxy() {}

//由于 Proxy 内部从不直接调用构造函数,所以 protected
意味着只有子类可以调用

protectedProxy(InvocationHandler h) {this.h = h;}

Proxy静态方法newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class[]interfaces,InvocationHandler h)    throwsIllegalArgumentException {//检查 h 不为空,否则抛异常if(h ==null) {thrownewNullPointerException();
}//获得与指定类装载器和一组接口相关的代理类类型对象Class cl =getProxyClass(loader, interfaces);//通过反射获取构造函数对象并生成代理类实例try{
    Constructor cons=cl.getConstructor(constructorParams);return(Object) cons.newInstance(newObject[] { h });
    }catch(NoSuchMethodException e) {thrownewInternalError(e.toString());
    }catch(IllegalAccessException e) {thrownewInternalError(e.toString());
    }catch(InstantiationException e) {thrownewInternalError(e.toString());
    }catch(InvocationTargetException e) {thrownewInternalError(e.toString());
    }
}

动态代理还有一种实现方式:cglib动态代理实现,据说它的运行速度要远远快于JDK的Proxy动态

这个目前还没进行深入研究

代理的目的就是调用目标方法时可以转而执行InvocationHandler类的invoke方法,所以在InvocationHandler上做文章就是Spring实现AOP的关键之处。这就是JAVA中JDK代理。

可以想象到的是Spring框架会读取上面的配置,获取类的名称。然后根据已知类的名称创建实例类型。是否很熟悉描述,在看看反射机制的描述。

总结

一个典型的动态代理创建对象过程可分为以下四个步骤:

1、通过实现InvocationHandler接口创建自己的调用处理器

 IvocationHandler handler = new InvocationHandlerImpl(...);

2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类

Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

3、通过反射机制获取动态代理类的构造函数,其参数类型是调用处理器接口类型

Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4、通过构造函数创建代理类实例,此时需将调用处理器对象作为参数被传入

Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

为了简化对象创建过程,Proxy类中的newInstance方法封装了2~4,只需两步即可完成代理对象的创建。

生成的ProxySubject继承Proxy类实现Subject接口,实现的Subject的方法实际调用处理器的invoke方法,而invoke方法利用反射调用的是被代理对象的的方法(Object
result=method.invoke(proxied,args))

第一次写文章,有写的不好的地方大家可以题出来。

这里其实运用到了一个设计模式:代理模式

看不懂?没事,下面一个实际的例子

设计模式主要分:动态代理和静态代理

 /** * 此字符串的获取你可以想象是从配置文件中,读取XMl,获取相关字符串。 **/String className = "com.linuer.test.Person"; Class cls = Class.forName(className);Object object = cls.newInstance(); //创建实例

静态代理:可以理解为对象由代理创建,在创建前后做一些事情,比如统计创建了多少对象,但静态代理只能创建一个或固定的几个对象。像如果是Spring中Bean,静态代理就明显不合适,因为这样不仅需要程序员手动创建大量的代理接口,而且也不能保证可扩展性。

上面的操作,用大白话说就是:根据一字符串
来得到类信息或者类方法,或者创建类实例。

为什么AOP选择使用动态代理实现:

        动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java
反射机制可以生成任意类型的动态代理类。java.lang.reflect
包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

发表评论

电子邮件地址不会被公开。 必填项已用*标注