黑马程序员-代理和AOP

       ------------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
 
         纠结了2周的代理, 终于在今晚告一段落了,  废话不多说,开始总结:

        所谓的代理，其实就是通过一个对象去调用其封装好的某一个方法，它在其他类的各个方法中增加了一些系统功能，例如，异常处理、日志、计算方法的运行时间、事物管理、等等。

        通常情况下，我们都是采用动态代理，我们可以自定义一个目标类，借由代理类来实现它。

        编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。

        如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

        代理分为两种，静态代理以及动态代理
        
        静态代理：
        系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，也就是说，我们需要一个个的将类写死，比如说要实现什么样的接口，接口里所带的参数等等， 要写死，这样很不利于开发。
        
        动态代理：
        于是就产生出了动态代理的概念，由我们自己去配置一个类，交由Java虚拟机去识别。（请看概念）
        JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
        JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
        代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
        1.在调用目标方法之前
        2.在调用目标方法之后
        3.在调用目标方法前后
        4.在处理目标方法异常的catch块中
  
        获取代理类

//需要一个类加载器,和一个类实现的接口

Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);   //打印结果是 $Proxy0

 

       获取代理类的构造方法

        Constructor[] constructors = clazzProxy1.getConstructors(); //返回代理类里的所有构造方法

        

        for(Constructor constructor : constructors){

            

            String name = constructor.getName(); //返回构造方法的方法名

            

            StringBuilder sBuilder = new StringBuilder(name); //由于不知道是不是有参的, 所以手动拼写代码

            

            sBuilder.append('(');

            

            Class[] clazzParams = constructor.getParameterTypes(); //返回构造方法的参数类型

            

            for(Class clazzParam : clazzParams){

                

                sBuilder.append(clazzParam.getName()).append(',');

                

            }

            

            if(clazzParams!=null && clazzParams.length != 0)  // 个人认为可以将这部放在前面先判断

            

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

                

            sBuilder.append(')');

            

            System.out.println(sBuilder.toString());//拼接成一个构造方法  xxx(xx);

            

            //这里打印的结果是$Proxy0(java.lang.reflect.InvocationHandler)  

            

            //InvocationHandler 是每一个代理处理程序所实现的一个接口,

            

            //也就是说代理要处理程序,就必须实现InvocationHandler接口

            

        }

 

        返回代理类里的各个方法

        for(Method method : methods){

            

            String name = method.getName();

            

            StringBuilder sBuilder = new StringBuilder(name);

            

            sBuilder.append('(');

            

            Class[] clazzParams = method.getParameterTypes();

            

            for(Class clazzParam : clazzParams){

                

                sBuilder.append(clazzParam.getName()).append(',');

                

            }

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

            

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

                

            sBuilder.append(')');

            

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

            

        }  //代码同构造方法  不做解释

         
        创建代理的实例化对象  以Collection 为例
    

 

    class MyInvocationHander1 implements InvocationHandler{

        

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

                    throws Throwable {

                        

                // TODO Auto-generated method stub

                return null;

            }

        

        }

        Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());

        

        //用代理获取实例对象必须传入InvocationHandlder接口,

        

        //因为InvocationHandlder是调用处理程序实现的接口。

        

        System.out.println(proxy1);

        

        proxy1.clear();

        

//      proxy1.size();  //有返回值的方法不能被成功调用,因为invoke方法返回的是null值

 

 

        Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){ //匿名内部类写法

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

                    throws Throwable {

                        

                return null;

            }

            

        });  //同上 不解释

 

 
 

/*

    代理类实现的三个步骤, 第一,必须是有代理类的目标实例对象。 第二，代理类的类加载器。 第三，代理类的实现接口

*/

Collection proxy3 = (Collection)Proxy.newProxyInstance(

    

                Collection.class.getClassLoader(),   //目标类的类加载器

                

                new Class[]{Collection.class},  //目标类

                

                new InvocationHandler(){

                    

                    ArrayList target = new ArrayList();   

                    

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

                            throws Throwable {

                        

                        System.out.println("我是ArrayList的HashCode: "+target.hashCode());

                        

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

                        

                        System.out.println(retVal.getClass().getName());

                        

                        return retVal;                      

                    }

                }

                );

        

        proxy3.add("zxx"); //每add一次就调用一次invoke方法

        

        proxy3.add("lhm");

        

        proxy3.add("bxd");

        

        System.out.println(proxy3.size());

        

        //System.out.println(proxy3.getClass().getName());());

        

        //从object继承的方法只有hashCode equals toString派发给InvocationHandler去做。 

 

        为代理添加一些自定义的功能，那么，这个接口我们可以自定义，比如：计算方法的时间
        首先需要一个接口。

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() {

        

        // TODO Auto-generated method stub

        Object proxy3 = Proxy.newProxyInstance(

            

                target.getClass().getClassLoader(), //目标的类加载器

                

                target.getClass().getInterfaces(),//由于是代理, 一定有一个目标实现的接口, 至少一个

                

                new InvocationHandler(){

                

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

                            throws Throwable {

                        advice.beforeMethod(method); //自定义接口的方法,

                        

                        //这里的invoke,延续了代理类的方法,如果代理类调用了set方法, 那么

                        

                        //在这里会继续将set方法引入给目标类使用

                        

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

                        

                        advice.afterMethod(method); //自定义接口的方法

                        

                        return retVal;                      

                        

                    }

                }

                );

        return proxy3;

    }

}

 
 AOP的定义
Spring框架里有一个AOP的概念， 所以的AOP，是面向切面的编程， 也就是说，在框架的基础上添加事物等一系列的功能。

 
根据配置文件获取到动态代理的例子:

 

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() {  //同上, 不解释

        Object proxy3 = Proxy.newProxyInstance(

            

                target.getClass().getClassLoader(),

        

                target.getClass().getInterfaces(),

                

                new InvocationHandler(){

                

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

                            throws Throwable {

                        advice.beforeMethod(method);

                        

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

                        

                        advice.afterMethod(method);

                        

                        return retVal;                      

                        

                    }

                }

                );

        return proxy3;

    }

 

 

 

public class BeanFactory {

    

    Properties props = new Properties();

    

    public BeanFactory(InputStream ips){

        

        try {

            

            props.load(ips);  //读取配置文件

            

        } catch (IOException e) {

            

            e.printStackTrace();

        }

    }

    

    public Object getBean(String name){ //要获取到目标类的配置的名字

        

        String className = props.getProperty(name); 

        

        Object bean = null;

        

        try {

            

            Class clazz = Class.forName(className); //生成一个实例, 如果这个实例是个代理类的话, 那么转入代理方法,

            

            //如果不是,返回BEAN

            

            bean = clazz.newInstance();

            

        } catch (Exception e) {

            

            e.printStackTrace();

        } 

        

        if(bean instanceof ProxyFactoryBean){

            

            Object proxy = null;

            

            ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean; //先将目标类强转成代理类

            

            try {

                

                //然后获取到接口的实例

                

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

                

                //获取目标类的实例

                

                Object target = Class.forName(props.getProperty(name + ".target")).newInstance();

                

                //在代理类里将接口与目标类作为变量传入, 所以这里只需要set就可以执行代理类里的方法

                

                proxyFactoryBean.setAdvice(advice);

                

                proxyFactoryBean.setTarget(target);

                

                //执行代理类的方法,方法在上面

                

                proxy = proxyFactoryBean.getProxy();

                

            } catch (Exception e) {

                

                e.printStackTrace();

                

            }

            

            return proxy;

            

        }

        

        return bean;

        

    }

    

}

 
 

------------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

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