Java 代理模式 （二） 动态代理

代理模式

　　代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。

　　这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。

 

代理模式的关键点： 代理对象与目标对象。

动态代理，

         1）代理对象，不需要实现接口；

         2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);

         3)  动态代理也称 JDK代理和接口代理；

 

JDK中生成代理对象的API：

|-- Proxy

         static Object newProxyInstance(

ClassLoader loader,       指定当前目标对象使用类加载器

 Class<?>[] interfaces,     目标对象实现的接口的类型

InvocationHandler h       事件处理器

)  

代码示例：

1、目标对象须实现的接口
package org.fkjava.b_dynamic;

public interface IUserDao {
    
    void save();
}

2、目标对象,实现接口
package org.fkjava.b_dynamic;
public class UserDaoImpl implements IUserDao{

    @Override
    public void save() {
        System.out.println("-----已保存数据-----");    
    }

}

3、使用代理工厂，生产代理对象
package org.fkjava.b_dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 这是一个代理工厂，用来生产代理对象
 * 给所有的dao创建代理对象[动态代理]
 *        代理对象不需要实现接口
 */
public class ProxyFactory {
    
    //通过构造器维护一个目标对象,这里用Object,表示可以给所有的目标对象生产代理对象
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    
    // 给目标对象，生成代理对象 
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //当前目标对象使用类加载器
                target.getClass().getInterfaces(), //目标对象要实现的接口的类型
                new InvocationHandler() { //事件处理器
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        
                        System.out.println("开启事务");
                        
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        
                        System.out.println("提交事务");
                        
                        return returnValue;
                    }
                });
    }
}

4、测试动态代理类
package org.fkjava.b_dynamic;
public class Test_dynamic {
    public static void main(String[] args) {
        //目标对象  
        IUserDao target = new UserDaoImpl();
        System.out.println(target.getClass());//【原始的类型 class cn.itcast.b_dynamic.UserDao】
        
        //通过代理工厂给目标对象创建代理对象 
        //proxy对象是在内存中生成的代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());// class $Proxy0   内存中动态生成的代理对象
        
        //执行方法 [代理对象]
        proxy.save();
    }
}

　　5、输出结果：

　　　　class org.fkjava.b_dynamic.UserDaoImpl
　　　　class com.sun.proxy.$Proxy0
　　　　开启事务
　　　　-----已保存数据-----
　　　　提交事务

 

动态代理总结：

         代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
         (class  $Proxy0  implements IuserDao)

思考：

         有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？

         Class  UserDao{}

         // 子类的方式

         Class subclass  extends  UserDao{}                                           

         以子类的方式实现(cglib代理)