静态代理与动态代理

    代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 
    按照代理的创建时期，代理类可以分为两种。 
    静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
    动态代理：在程序运行时，运用反射机制动态创建而成。

    我们先来看一下静态代理的代码实现！

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;

//接口
public interface UserManager {
        //添加用户的方法
	public void addUser(String userId, String userName);
	
}</span></span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;

//真实对象   实现了UserManager接口
public class UserManagerImpl implements UserManager {

	//实现了添加用户方法
	public void addUser(String userId, String userName) {
		//System.out.println("start-->>addUser() userId-->>" + userId);
		try {
			System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
			
			//System.out.println("success-->>addUser()");
		}catch(Exception e) {
			e.printStackTrace();
			//System.out.println("error-->>addUser()");
			throw new RuntimeException();
		}	
	}

}</span></span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;

//代理类
public class UserManagerImplProxy implements UserManager {

	private UserManager userManager;
	
	public UserManagerImplProxy(UserManager userManager) {
		this.userManager = userManager;
	}
	//代理方法
	public void addUser(String userId, String userName) {
		try {
			System.out.println("start-->>addUser() userId-->>" + userId);
			userManager.addUser(userId, userName);
			System.out.println("success-->>addUser()");
		}catch(Exception e) {
			e.printStackTrace();
			System.out.println("error-->>addUser()");
		}	
	}
}</span></span></span>

<span style="font-size:18px;"><span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;

public class Client {

	/**
	 * 客户端条用
	 */
	public static void main(String[] args) {
		//UserManager userManager = new UserManagerImpl();
		UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
		userManager.addUser("0001", "张三");
	}
}
</span></span></span>

 

    通过代码我们可以看到，只要每个代理对象实现被代理类的接口，然后做一些增强就可以了！但是我们又发现了，每个被代理类必须要要有一个代理类，而且这个代理类和真实类要实现同一个接口！每个代理类只能为一个接口服务，那么如果有多个接口的话，我们可以想象会有多少个代理类啊！所以动态代理产生了！

    JDK动态代理中包含一个类和一个接口： 
    InvocationHandler接口： 
    public interface InvocationHandler { 
         public Object invoke(Object proxy,Method method,Object[] args) throwsThrowable; 
    } 
    参数说明： 
        Objectproxy：指被代理的对象。 
        Methodmethod：要调用的方法 
        Object[]args：方法调用时所需要的参数 

     可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。 

     Proxy类： 
     Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法： 
     public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces, 
     InvocationHandler h) throws IllegalArgumentException 
     参数说明： 
         ClassLoader loader：类加载器 
         Class<?>[] interfaces：得到全部的接口 
         InvocationHandler h：得到InvocationHandler接口的子类实例 

    Ps:类加载器 
    在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器; 
    Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
    Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
    AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。 

    动态代理

    与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

 

<span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;
//接口
public interface UserManager {

	public void addUser(String userId, String userName);
}
</span></span>

<span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;
//接口实现
public class UserManagerImpl implements UserManager {

	public void addUser(String userId, String userName) {
		//System.out.println("start-->>addUser() userId-->>" + userId);
		try {
			System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
			
			//System.out.println("success-->>addUser()");
		}catch(Exception e) {
			e.printStackTrace();
			//System.out.println("error-->>addUser()");
			throw new RuntimeException();
		}	
	}
}</span></span>

    动态代理实现类，大家要仔细的看

<span style="font-size:18px;"><span style="font-size:18px;">package com.bjpowernode.pattern;

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

public class LogHandler implements InvocationHandler {
	
	private Object targetObject;
	
	public Object newProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
							   targetObject.getClass().getInterfaces(), this);
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("start-->>" + method.getName());
		for (int i=0; i<args.length; i++) {
			System.out.println(args[i]);
		}
		Object ret = null;
		try {
			//调用目标方法
			ret = method.invoke(targetObject, args);
			System.out.println("success-->>" + method.getName()); 
		}catch(Exception e) {
			e.printStackTrace();
			System.out.println("error-->>" + method.getName());
			throw e;
		}
		return ret;
	}

}</span></span>

 

<span style="font-size:18px;">package com.bjpowernode.pattern;

public class Client {

	/**
	 * 客户端调用
	 */
	public static void main(String[] args) {
		LogHandler logHandler = new LogHandler();
		UserManager userManager = (UserManager)logHandler.newProxyInstance(new UserManagerImpl());
		//userManager.addUser("0001", "张三");
		//userManager.delUser("0001");
		String name = userManager.findUser("0001");
		System.out.println("Client.main() --- " + name);
	}
}</span>

    大家仔细看代码是否发现了如果一个类没有接口的话，那么可能用动态代理是不是就有些不符合了呢！那么这时候又出现了cglib！ 在下篇博客中家那个为大家介绍一下cglib！