Proxy设计模式

代理模式为其他对象提供一个代理以控制对某个对象的访问。

为了行为的一致性，代理类与委托类通常会实现相同的接口。

代理模式与适配器、装饰者模式的区别：

代理模式与适配器、装饰者模式，都包装了一个内部对象，对请求进行，但是他们有本质的区别：

装饰者模式，扩展了包装对象的行为和责任。包装对象与被包装对象实现了相同的接口，即有共同的行为。
适配器模式，扩展了包装对象的行为和责任。但是进行了接口转换。
代理模式，未扩展行为和责任，是控制对象的访问。包装对象与被包装对象实现了相同的接口。

按照代理的创建时期，代理类可以分为两种：

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

动态：在程序运行时运用反射机制动态创建而成

Java静态代理

    //real Subject
    public class UserManagerImpl implements UserManager {  
      
        @Override  
        public void addUser(String userId, String userName) {  
            System.out.println("UserManagerImpl.addUser");  
        }  
      
        @Override  
        public void delUser(String userId) {  
            System.out.println("UserManagerImpl.delUser");  
        }  
      
        @Override  
        public String findUser(String userId) {  
            System.out.println("UserManagerImpl.findUser");  
            return "张三";  
        }  
      
        @Override  
        public void modifyUser(String userId, String userName) {  
            System.out.println("UserManagerImpl.modifyUser");  
      
        }  
    }  



   //Proxy
    public class UserManagerImplProxy implements UserManager {  
      
        // 目标对象  
        private UserManager userManager;  
        // 通过构造方法传入目标对象  
        public UserManagerImplProxy(UserManager userManager){  
            this.userManager=userManager;  
        }  
        @Override  
        public void addUser(String userId, String userName) {  
            try{  
                    //添加打印日志的功能  
                    //开始添加用户  
                    System.out.println("start-->addUser()");  
                    userManager.addUser(userId, userName);  
                    //添加用户成功  
                    System.out.println("success-->addUser()");  
                }catch(Exception e){  
                    //添加用户失败  
                    System.out.println("error-->addUser()");  
                }  
        }  
      
        @Override  
        public void delUser(String userId) {  
            userManager.delUser(userId);  
        }  
      
        @Override  
        public String findUser(String userId) {  
            userManager.findUser(userId);  
            return "张三";  
        }  
      
        @Override  
        public void modifyUser(String userId, String userName) {  
            userManager.modifyUser(userId,userName);  
        }  
      
    }  



    //Client 使用代理
    public class Client {  
      
        public static void main(String[] args){  
            //UserManager userManager=new UserManagerImpl();  
            UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());  
            userManager.addUser("1111", "张三");  
        }  
    }

代理模式的缺点

代理类与委托类实现了相同接口，接口修改会导致所有实现了接口的代理类修需要修改。
代理类仅能服务于某个接口，如果多个接口实现需要代理功能，则必须为所有接口创建代理类。即静态代理只能服务于某个特定接口。

JDK动态代理

静态代理一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持


    //Object proxy:被代理的对象  
    //Method method:要调用的方法  
    //Object[] args:方法调用时所需要参数  
    public interface InvocationHandler {  
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
    }  




//java.lang.reflect.Proxy  类：

    //CLassLoader loader:类的加载器  
    //Class<?> interfaces:得到全部的接口  
    //InvocationHandler h:得到InvocationHandler接口的子类的实例  
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

示例代码：

public interface UserManager {

	void addUser(String userId, String userName);

	void delUser(String userId);

	String findUser(String userId);

	void modifyUser(String userId, String userName);

}


public class UserManagerImpl implements UserManager {

	 @Override  
	    public void addUser(String userId, String userName) {  
	        System.out.println("UserManagerImpl.addUser");  
	    }  
	  
	    @Override  
	    public void delUser(String userId) {  
	        System.out.println("UserManagerImpl.delUser");  
	    }  
	  
	    @Override  
	    public String findUser(String userId) {  
	        System.out.println("UserManagerImpl.findUser");  
	        return "张三";  
	    }  
	  
	    @Override  
	    public void modifyUser(String userId, String userName) {  
	        System.out.println("UserManagerImpl.modifyUser");  
	  
	    }  
}




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

public class LogHandler implements InvocationHandler{
	// 目标对象  
    private Object targetObject;  
    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。              
    public void setTarget(Object targetObject){  
        this.targetObject=targetObject;   
    }  
    
    @Override  
    //关联的这个实现类的方法被调用时将被执行  
    /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        System.out.println("start-->>");  
        for(int i=0;i<args.length;i++){  
            System.out.println(args[i]);  
        }  
        Object ret=null;  
        try{  
            /*原对象方法调用前处理日志信息*/  
            System.out.println("satrt-->>");  
              
            //调用目标方法  
            ret=method.invoke(targetObject, args);  
            /*原对象方法调用后处理日志信息*/  
            System.out.println("success-->>");  
        }catch(Exception e){  
            e.printStackTrace();  
            System.out.println("error-->>");  
            throw e;  
        }  
        return ret;  
    }  
}



public class UserManagerTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		UserManager userManager = new UserManagerImpl();
		LogHandler logHandler=new LogHandler(); 
		logHandler.setTarget(userManager);
		  //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    
        //根据传入的目标返回一个代理对象  
		UserManager proxy =(UserManager) Proxy.newProxyInstance(
				//第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  
				userManager.getClass().getClassLoader() 
				//第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  
				,userManager.getClass().getInterfaces()
				//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  
				,logHandler);  
		 
		proxy.addUser("1111", "张三");  
        
	}

}

cglib代理

Java静态代理与JDK动态代理要求目标对象实现了一个接口，如果目标对象没有实现接口，则不可以使用动态代理。此时可以使用Cglib代理来创建一个代理对象。

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

代码示例:

目标对象类:UserDao.java

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {

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

Cglib代理工厂:ProxyFactory.java

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}

测试类:

/**
 * 测试类
 */
public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}

在Spring的AOP编程中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理

Javal动态代理