黑马程序员——枚举和动态代理

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

枚举

在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。
例如：星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。

按照上面的思想，我们使用普通类来实现枚举的功能：

示例：

package com.leaf.test;
//普通的类实现枚举的功能
public abstract class WeekDay {
	private WeekDay(){}
	
	public final static WeekDay SUN = new WeekDay(){
		public WeekDay nextDay(){
			return MON;
		}
	};
	public final static WeekDay MON = new WeekDay(){
		public WeekDay nextDay(){
			return SUN;
		}
	};
	//用抽象方法来抽取每个子类的相同的方法
	public abstract WeekDay nextDay();
//	可以使用抽象方法将大量的if else语句转换为独立的类
//	public WeekDay nextDay(){
//		if(this == SUN){
//			return MON;
//		}else {
//			return SUN;
//		}
//	}
	public String toString(){
		return this==SUN?"SUN":"MON";
	}
}	

上面的代码实现了WeekDay这个类只有两个子类，MON和SUN，定义不了其他的实例。

但是使用上面的代码太过麻烦，那真正的枚举是什么样的呢？

package com.leaf.test;
/*
 * 如果在程序设计的时候，发现你定义的类超出了枚举的定义范围
 * 编译源程序的时候就发现程序不合法，是程序不能编译通过
 * 
 * 使用普通类的方式实现枚举的功能
 * 
 * 枚举只有一个成员时，就可以作为一个单例来使用
 */
public class EnumDemo {
	public static void main(String[] args) {
		WeekDay weekDay = WeekDay.SUN;
		WeekDay weekDay1 = WeekDay.SAT;
		System.out.println(weekDay1);
		System.out.println(weekDay1.name());
		System.out.println(weekDay1.ordinal());
		System.out.println(WeekDay.valueOf("SUN"));
		System.out.println(WeekDay.values().length);
	}
	public enum WeekDay{
		//枚举的元素列表必须定义在第一行
		SUN(1),MON,TUE,WED,THI,FRI,SAT;//如果没有后面东西，最后这个；可以不写
		//不写（param）会自动使用空参数的构造方法，加上（1）可以调用带参数的构造方法
		private WeekDay(){
			System.out.println("null");
		}
		private WeekDay(int day){
			System.out.println("param");
		}
	}

上面的代码实现了普通类定义的枚举的内容

下面展示一般情况下能用到的较复杂的枚举：

示例：

public enum TrafficLamp{
		RED(30) {
			@Override
			public TrafficLamp nextLamp() {
				return GREEN;
			}
		},
		GREEN (30){
			@Override
			public TrafficLamp nextLamp() {
				return YELLOW;
			}
		},
		YELLOW (10){
			@Override
			public TrafficLamp nextLamp() {
				return RED;
			}
		};
		private int time;
		private TrafficLamp(int time){
			this.time = time;
		}
		public abstract TrafficLamp nextLamp();
	}
}

上面的代码实现了每个TrafficLamp对象有一个time属性，每隔time时间就变成下一个lamp状态。

动态代理：

程序中的代理：

要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如：异常处理，日志，计算方法的运行时间等。

要怎么做呢？

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

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

从图中看出，本来Client要寻找目标类Target来运行功能，但是现在不这样做，要使用代理类Proxy来帮忙寻找目标类Target，这样，我们只要通过修改代理类读取的配置文件就能修改Target，这样大大方便了系统的维护。

 

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

一、Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Objectobj,Method method,Object[] args）。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

二、Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h）：构造函数。

Static Class getProxyClass (ClassLoaderloader,Class[] interfaces）：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoaderloader,Class[] interfaces,InvocationHandler h）：返回代理类的一个实例，返回后的代理类可以当作被代理类使用（可使用被代理类的在Subject接口中声明过的方法）。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

示例：

package com.leaf.proxy;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class ProxyTest {

	/**
	 * @param args
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 * @throws InvocationTargetException
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
		
		Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		Constructor constructor =  clazzProxy.getConstructor(InvocationHandler.class);
		//产生代理实例对象的三种方式：
		//第一种方式：创建一个类实现InvocationHandler接口，再创建实例对象时，将刚刚创建的类当做参数传入
		Collection proxy1 = (Collection) constructor.newInstance(new MyInvocationHandler());
		
		proxy1.add("a");
		System.out.println(proxy1);
		//第二种方式：实例化代理实例时，使用匿名内部类的方法，将参数InvocationHandler的子类传入
		Collection proxy2 = (Collection) constructor.newInstance(new InvocationHandler(){

			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {

				return null;
			}
		});
		//第三种方式：使用Proxy的静态方法newProxyInstance，分别传入 classloader  interface  InvocationHandler实现类
		Collection proxy3 = (Collection)Proxy.newProxyInstance(
				Collection.class.getClassLoader(),
				new Class[]{Collection.class},
				new InvocationHandler(){

					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						
						return null;
					}
				});
	}
}

class MyInvocationHandler implements InvocationHandler {
	//假如要使用代理类，要创建一个目标类
	Collection target = new ArrayList();
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		Object obj = method.invoke(target, args);
		return obj;
	}

}

分析InvocationHandler对象的运行原理：

我们先写一个示例来看看InvocationHandler中有什么内容：

package com.leaf.proxy;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class GetProxyContent {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Class clazz = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		Constructor[] constructors = clazz.getConstructors();
		for(Constructor constructor :constructors){
			StringBuilder sBuilder = new StringBuilder(clazz.getName());
			Class[] pTypes = constructor.getParameterTypes();
			for(Class pType : pTypes){
				sBuilder.append(pType.getName()+",");
			}
			if(pTypes.length!=0)
				sBuilder.deleteCharAt(sBuilder.length()-1);
			
			System.out.println(sBuilder.toString());
		}
		Method[] methods = clazz.getMethods();
		for(Method method :methods){
			StringBuilder sBuilder1 = new StringBuilder(clazz.getName()+":");
			sBuilder1.append(method.getName()).append('(');
			Class[] pTypes =method.getParameterTypes();
			for(Class pType : pTypes){
				sBuilder1.append(pType.getName()+",");
			}
			if(pTypes.length!=0)
				sBuilder1.deleteCharAt(sBuilder1.length()-1);
			sBuilder1.append(')');
			System.out.println(sBuilder1.toString());
		}
		
	}
}

result：

动态生成的类实现了Collection接口（可以实现若干个接口），生成的类有Collection接口中的所有方法和如下的接收InvocationHandler参数的构造方法；构造方法接受一个InvocationHandler对象，接受对象要做什么呢？？？

实现Collection接口中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的Invoke方法接收的三个参数是什么？

图解说明：

示例：

为被需要代理的类添加一个时间计算功能

写一个接口，定义需要的功能

package com.leaf.proxy;

import java.lang.reflect.Method;

public interface Advice {
	
	void afterMethod(Method method);
	void beforeMethod(Method method);
}

写一个类实现之前的接口，并对方法进行定义

package com.leaf.proxy;

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
	long startTime;
	@Override
	public void beforeMethod(Method method) {
		startTime = System.currentTimeMillis();
	}

	@Override
	public void afterMethod(Method method) {
		long endTime = System.currentTimeMillis();
		System.out.println(method.getName()+":"+(endTime - startTime));
		
	}
}

使用定义的功能：

package com.leaf.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.TreeSet;

public class ProxyTest1 {

	/**
	 * 为被需要代理的类添加一个时间计算功能
	 * @param args
	 */
	public static void main(String[] args) {
		
		final List target = new ArrayList();
		Collection col = (Collection)getProxy(target,new MyAdvice());
		col.add("abc");
		final TreeSet target1 = new TreeSet();
		Collection col1 = (Collection)getProxy(target1,new MyAdvice());
		col1.add("qwe");
		col1.add("rty");
		col1.add("qwe");
		
		System.out.println(col);
		System.out.println(col1);
	}

	private static Object getProxy(final Object target,final Advice advice) {
		
		Object clazzProxy = (Object)Proxy.newProxyInstance(
				target.getClass().getClassLoader(), //类加载器，一般情况下传入目标类的类加载器
				target.getClass().getInterfaces(),//目标类实现的接口
				new InvocationHandler() {//new一个InvocationHandler
					@Override
					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 clazzProxy;
	}

}

result：