黑马程序员_动态代理技术

 

-------------------------------------------------android培训、java培训期待与您交流！----------------------------------

一、概述

1.要为私法统中的各种接口的在增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类。

2.JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

3.JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

4.CGLIB库可以动态生成一个类的子类，一个类的子类也可用作该类的代理，所以，如果要为一个没实接口的类生成动态代理类，那么可以使用CGLIB库。

5.代理类的各个方中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1)在调用目标方法之前

2)在调用目标方法之后

3)在调用目标方法前后

4)在处理目标方未能异常的catch块中

 

public class CreateProxyClass {

    public static void main(String[] args) {

        //动态生成的类要类加载器加载

        Class<?> clazz=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);

        System.out.println(clazz.getName());

        System.out.println("-------------have Constructors------------------------");

        Constructor<?>[] constructors=clazz.getConstructors();

        for (Constructor<?> constructor : constructors) {

            //StringBuilder和StringBuffer

            //StringBuilder是在单线程效率高，而StringBuffer是在多线程效率高

            StringBuilder sb=new StringBuilder(constructor.getName());

            sb.append("(");

            Class<?>[] paramClazzs=constructor.getParameterTypes();

            for (Class<?>  paramClazz : paramClazzs) {

                sb.append(paramClazz.getName());

            }

            if(null!=paramClazzs&&paramClazzs.length!=0)

                sb.deleteCharAt(sb.length()-1);

            sb.append(")");

            System.out.println(sb.toString());

        }

        System.out.println("------------have Methods------------------");

        Method[] methods=clazz.getMethods();

        for (Method method : methods) {

            //StringBuilder和StringBuffer

            //StringBuilder是在单线程效率高，而StringBuffer是在多线程效率高

            StringBuilder sb=new StringBuilder(method.getName());

            sb.append("(");

            Class<?>[] paramClazzs=method.getParameterTypes();

            for (Class<?>  paramClazz : paramClazzs) {

                sb.append(paramClazz.getName());

            }

            if(null!=paramClazzs&&paramClazzs.length!=0)

                sb.deleteCharAt(sb.length()-1);

            sb.append(")");

            System.out.println(sb.toString());

        }

       

        System.out.println("----------------invoke method--------------");

       

        Collection<?> cons1=(Collection<?>)Proxy.newProxyInstance(Collection.class.getClassLoader(),new Class[]{Collection.class},new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args)

                    throws Throwable {

                return null;

            }

        });

       

        cons1.clear();//这行不报错，因为不要返回值

        //cons1.size();//这里报错是因为里面传过来为null，而这里又要一个int返回值

       

        /*class $Proxy0{

        *类部有一个接收InvocationHandler的实例引用

* InvocationHandler handler;

         * 内部动态类的方法写法,如:

         * int size()

         * {

         * //可见这里又调用我们写的invoke传入一些信息,如代理的方法名,这里this是cons1，即当前代理对象

         * return handler.invoke(this,this.getClass().getMethod("size"),null);

         * }

         * void clear()

         * {

         * handler.invoke(this,this.getClass().getMethod("clear"),null);

         * }

         * }

         */

       

        Collection cons2=(Collection)Proxy.newProxyInstance(Collection.class.getClassLoader(),new Class[]{Collection.class},new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args)

                    throws Throwable {

                System.out.println("正在调用……");

                List<String> list=new ArrayList<String>();//此ArrayList用于操作的对象

                return method.invoke(list, args);

            }

        });

        cons2.add("Em");

        System.out.println(cons2.size());//打印为0是因为每调用方法一次，就创建了ArrayList对象,放入成员变量即可

        System.out.println(cons2.getClass());//打印的getClass不是ArrayList的getClass是因为对于Object来说只有toStirng() hashCode() equals()有效

    }

}

二、轻量级Spring摸拟

1.FactoryBean

public class FactoryBean {

    private Properties props=new Properties();

    public FactoryBean(InputStream inputStream) {

        try {

            props.load(inputStream);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    public Object getBean(String name) throws Exception {

        Class<?> clazz=Class.forName(props.getProperty(name));

        Object bean=clazz.newInstance();

        //如果目标是动态代理类,那么对象由它来创建

        if(bean instanceof ProxyFactoryBean)

        {

            ProxyFactoryBean pfb=(ProxyFactoryBean)bean;

            //设置和加载目标和建议

            pfb.setTarget(Class.forName(props.getProperty(name+".target")).newInstance());

            pfb.setAdvice((Advice)Class.forName(props.getProperty(name+".advice")).newInstance());

            return pfb.getProxy();

        }

        return bean;

    }

}

2.ProxyFactoryBean

public class ProxyFactoryBean {

 

    private Advice advice;

    private Object target;

   

    public Advice getAdvice() {

        return advice;

    }

 

    public void setAdvice(Advice advice) {

        this.advice = advice;

    }

 

    public Object getTarget() {

        return target;

    }

 

    public void setTarget(Object target) {

        this.target = target;

    }

 

    public  Object getProxy() {

       return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args)

                    throws Throwable {

                advice.invokeMethodBrefore(method);

                Object renVal=method.invoke(target, args);

                advice.invokeMethodAfter(method);

                return renVal;

            }

        });

    }

 

}

3.MyAdvice

public class MyAdvice implements Advice {

 

    @Override

    public void invokeMethodBrefore(Method method) {

        System.out.println("Em");

 

    }

 

    @Override

    public void invokeMethodAfter(Method method) {

        System.out.println("Gm");

    }

 

}

4.配置文件(config.properties)

#xxx=java.util.ArrayList

xxx=spring.ProxyFactoryBean

xxx.advice=spring.MyAdvice

xxx.target=java.util.ArrayList

5.Test测试

public class Test {

    public static void main(String[] args) {

        try {

           

            FactoryBean fb=new FactoryBean(new FileInputStream("src/cofing.properties"));

            //如果返回是代理对象，不能直接转成那个类型，因为这个实例只是实现了一些接口,所以要转接口

            System.out.println((List)fb.getBean("xxx"));

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

 

 

-------------------------------------------------android培训、java培训期待与您交流！----------------------------------

 详细请查看：http://edu.csdn.net/heima