码迷,mamicode.com
首页 > 其他好文 > 详细

动态代理

时间:2016-09-26 12:39:31      阅读:151      评论:0      收藏:0      [点我收藏+]

标签:

增强的手段
1、继承
*被增强对象不能变
*增强内容不能变
2.装饰者模式
*被增强对象可变
*但增强内容不可变
3.动态代理
*被增强对象可变
*增强内容可变

 

首先一个方法:

Proxy.newProxyInstance(ClassLoader classLoader,Class[] interfaces,invocationHandler h);

1、方法作用:动态创建实现了interfaces数组中所有指定接口的实现类对象!

参数:

1、ClassLoader:类加载器
它是用来加载类的,把.class文件加载到内存形成Class对象!
2、Class[] interfaces:指定要执行的接口
3、invocationHandler:代理对象的所有方法(个别方法不执行)都会调用InvocationHandler的invoke方法

 

第一个测试类:

package com.itcast.demo1;

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

import org.junit.Test;

public class Demo1 {
    @Test
    public void fun1(){
        /*
         * 三大参数
         * 1.ClassLoader
         * 方法需要动态生成一个类,这个类实现了A、B接口,然后创建这个类的对象!
         * 需要生成一个类,这个类也需要加载到方法区中,谁来加载,当然是ClassLoader
         *
         * 2.Class[] interfaces
         * 它是要实现的接口们
         * 
         * 3.InvocationHandler
         * 它是调用处理器
         * 敷衍它
         * 
         * 代理对象的所有方法都是调用invocationHandler的invoke方法
         */
        ClassLoader loader=this.getClass().getClassLoader();
        InvocationHandler h=new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("你好,动态代理!");
                return null;
            }
        };
        //使用三大参数创建代理对象
        Object o=Proxy.newProxyInstance(loader, new Class[]{A.class,B.class}, h);
        
        //强转成A和B类型,成功了!
        A a=(A) o;
        B b=(B) o;
        a.a();
        b.b();
        a.aa();
        b.bb();
        System.out.println(a.getClass().getName());
        
    }
}
interface A{
    public void a();
    public void aa();
}
interface B{
    public void b();
    public void bb();
}

证实几点:

  1、该方法生成了实现指定接口的代理对象。

  2、代理类的几乎所有方法的执行都是调用invocation的invoke方法。

  3、类加载器使用this.getClass().getClassLoader()得到。

 

动态代理的作用
最终是学习AOP(面向切面编程),它与装饰者模式有点相似,它比装饰者模式还要灵活!

 

方法:

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

这个invoke方法什么时候被调用!
1、在代理对象呗创建时?错误的
2、在调用代理对象所实现接口中的方法时?正确的!

*Object proxy:当前对象,即代理对象!在调用谁的方法!
*Method method:当前被调用的方法(目标方法)
*Object[] args:实参!

 

实现

(*被增强对象可变*但增强内容不可变):

package com.itcast.demo2;
//服务员
public interface Waiter {
    //服务
    public void server();

}

package com.itcast.demo2;

public class ManWaiter implements Waiter {

    @Override
    public void server() {
        System.out.println("服务中!");
    }

}

package com.itcast.demo2;

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

import org.junit.Test;
/**
 * 我们必须要掌握的是当前这个案例!
 * @author Administrator
 *
 */
public class Demo2 {

    @Test
    public void fun1(){
        Waiter manWaiter=new ManWaiter();
        /*
         * 给出三个参数,来调用方法得到代理对象
         */
        ClassLoader loader=this.getClass().getClassLoader();
        Class[] interfaces={Waiter.class};
        InvocationHandler h=new WaitInvocationHanlder(manWaiter); //被增强的目标对象
        Waiter waiter=(Waiter) Proxy.newProxyInstance(loader, interfaces, h);
        
        waiter.server();//前面加你好,后面加再见
    }
    
}
class WaitInvocationHanlder implements InvocationHandler{
    private Waiter waiter;//目标对象
    public WaitInvocationHanlder(Waiter waiter){
        this.setWaiter(waiter);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("你好!");
        this.waiter.server();//调用目标对象的方法
        System.out.println("再见!");
        return null;//return 的值是执行的方法的返回值,这个方法的proxy表示的是本代理对象,所以不能使用method.invoke(proxy,args).这样会走死循环。
    }

    public void setWaiter(Waiter waiter) {
        this.waiter = waiter;
    }

    public Waiter getWaiter() {
        return waiter;
    }
    
}

 

 

使用工厂模式,实现增强内容也可变。

目标对象:被增强的对象
代理对象:需要增强的对象,
目标:

  执行前增强

  执行后增强

 

package com.itcast.demo3;
/**
 * 前置增强
 */
public interface BeforeAdvice {
    public void before();

}

package com.itcast.demo3;
/*
 * 后置增强
 */
public interface AfterAdvice {
    
    public void after();
}

package com.itcast.demo3;

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

/**
 * 它用来生成代理对象
 * 它需要所有的参数
 *     *目标对象
 *  *增强
 */
/**
 * 1、创建代理工厂
 * 2、改工厂设置三样东西:
 *     *目标对象setTargetObject
 *     *前置增强:setBeforeAdvice
 *     *后置增强:setAfterAdvice
 * 3、调用createProxy()得到代理对象
 *     *执行代理对象方法时:
 *         执行BeforeAdvice的before()
 *         目标对象的目标方法
 *         执行AfterAdvice的after()
 */
public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前置增强
    private AfterAdvice afterAdvice;//后置增强
    public Object getTargetObject() {
        return targetObject;
    }
    
    /**
     * 用来生成代理对象
     * @return
     */
    public Object createProxy(){
        /*
         * 给出三大参数
         */
        ClassLoader loader=this.getClass().getClassLoader();
        Class[] interfaces=targetObject.getClass().getInterfaces();
        InvocationHandler h=new InvocationHandler() {
            
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                /*
                 * 在调用代理对象的方法时,执行这里的内容
                 */
                //执行前置增强
                if(beforeAdvice!=null){
                    beforeAdvice.before();
                }
            Object result=method.invoke(targetObject, args);//执行目标对象的目标方法
                //执行后置增强
                if(afterAdvice!=null){
                    afterAdvice.after();
                }
                //返回目标对象中的返回值
                return result;
            }
        };
        
        //得到代理对象
        Object obj=Proxy.newProxyInstance(loader, interfaces, h);
        
        //返回代理
        return obj;
    }
    
    
    
    public void setTargetObject(Object targetObject) {
        this.targetObject = targetObject;
    }
    public BeforeAdvice getBeforeAdvice() {
        return beforeAdvice;
    }
    public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
        this.beforeAdvice = beforeAdvice;
    }
    public AfterAdvice getAfterAdvice() {
        return afterAdvice;
    }
    public void setAfterAdvice(AfterAdvice afterAdvice) {
        this.afterAdvice = afterAdvice;
    }
    

}

主要代码就这些:

这里实现增强内容可变的方法是代理对象的执行体令它是可变的,所以使用工厂进行创建,进行了一些包装操作。我们必须透彻理解如何进行的增强,增强的步骤等。

难点在于:

  1、思路。明确知道自己需要什么怎么办。

  2、proxy中的invoke方法的书写。

动态代理

标签:

原文地址:http://www.cnblogs.com/aigeileshei/p/5908533.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!