黑马程序员-java基础加强(三)

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

类加载器：

类加载器即加载类的工具，作用是将.class文件从硬盘上加载进内存并作一些相应处理。
1.JVM中可以安装多个类加载器，系统默认三个主要类加载器 ，每个类负责加载特定位置的类：
这三个类加载器分别为：BootStrap，ExtClassLoader，AppClassLoader
它们依次成父子关系，BootStrap是根节点。
BootStrap管辖范围为JRE/lib/rt.jar。
ExtClassLoader管辖范围是：JRE/lib/ext/*.jar。
AppClassLoader管辖的范围是：CLASSPATH指定的所有jar或目录。

2.类加载器也是java类，因为其它是java类也要被一个类加载器加载，完成这个任务的正是：BootStrap

3.JVM中的所有类加载器采用具有父子关系的树形结构进行组织，在实例化每个类加载器对象时，需要为其指定

一个父级类加载器对象或者默认采用系统类加载器为其父级类加载器对象。

类加载器的委托机制：

1.首先当前线程的类加载器去加载线程中的第一个类
2.如果类A中引用了类B，JVM将使用加载类A的类加载器来加载类B
3.还可以直接调用ClassLoader.loaderClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又先委托给其上级类加载器，即当所有祖宗类加载器没有加载到类时，回到发起者类加载器，还加载不了，则抛出ClassNotFoundException，
不再去找发起者类加载器的儿子，因为没有getChild方法。

自定义类加载器：
1.自定义类加载器必须继承ClassLoader抽象类。

2.必须覆盖方法findClass(String name)，它使用指定的二进制名称查找类，并返回该类的Class对象。
 
练习：
编写一个对文件内容进行简单加密的程序，并写一个相应的类加载器区加载加密后的.class文件，加载过程中对它解密。

加密程序：

//要进行加密的类

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class ClassLoaderAttachment extends Date
{
	public String toString()
	{
		return "hello java";
	}
}</span>

//对ClassLoaderAttachment类的.class文件进行加密，.class文件放在‘g:\wokerspace1\self_learn\\bin\classLoader\’下，并将加密后的.class文件放在当前工程的loaderLib目录下

<span style="font-family: KaiTi_GB2312; font-size: 18px;">public class myClassLoader extends ClassLoader
{		
	public static void main(String[] args) throws Exception
	{
		String classFileName = "g:\\wokerspace1\\self_learn\\bin\\classLoader\\ClassLoaderAttachment.class"; //被加密类的.class文件路劲
		
		String destpath = "loaderLib\\ClassLoaderAttachment.class";					 //加密解后的.class文件路劲
		
		InputStream fis = new FileInputStream(classFileName);
		OutputStream fos = new FileOutputStream(destpath);
		
		cypher(fis, fos);									//加密程序进行加密
		
		fis.close();
		fos.close();	
	}
	

	private static void cypher(InputStream in, OutputStream out) throws Exception
	{
		int b = 0;
		while((b = in.read()) != -1)
		{
			out.write(b^0xff);
		}
	}
}</span>

//自定义类加载器，将loaderLib目录下的加密.class文件进行解密并加载进内存。

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class myClassLoader extends ClassLoader 
{
	private String classDir = null; //加密后的.class文件存放位置

	//main函数只用来加密，现在已经不需要
	
	/*	
	public static void main(String[] args) throws Exception
	{
		String classFileName = "g:\\wokerspace1\\self_learn\\bin\\classLoader\\ClassLoaderAttachment.class";
		
		String destpath = "loaderLib\\ClassLoaderAttachment.class";
		
		InputStream fis = new FileInputStream(classFileName);
		OutputStream fos = new FileOutputStream(destpath);
		
		cypher(fis, fos);
		
		fis.close();
		fos.close();	
	}
	*/
	
	
	
	public myClassLoader(String classDir)
	{
		this.classDir = classDir;
	}
	

	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException 
	{
		String classFileName = this.classDir+"\\"+name+".class";
		try 
		{
			InputStream fis = new FileInputStream(classFileName);
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			//解密函数和加密函数时同一个函数
			cypher(fis, bos);
			fis.close();
			//获得.class二进制文件的字节数组。
			byte[] buf = bos.toByteArray();
			//返回被加载类的Class对象
			return defineClass(buf, 0, buf.length); 				
		} catch (Exception e) 
		{
			System.out.println("xsfd");
		}
		return null;
	}



	private static void cypher(InputStream in, OutputStream out) throws Exception
	{
		int b = 0;
		while((b = in.read()) != -1)
		{
			out.write(b^0xff);
		}
	}
}</span>

//测试自定义类加载器

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class MainClass 
{

	public static void main(String[] args)  throws Exception
	{
		Class clazz = new myClassLoader("loaderLib").findClass("ClassLoaderAttachment"); //通过自定义类加载器获得被加载类Class对象
		Date date = (Date) clazz.newInstance();					//获得该类的一个实例对象
		System.out.println(date);						//打印
	}

}</span>

动态代理：

程序中的代理：
要为以存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如：异常处理，日志，计算方法的运行时间
事务管理等等。
根据代理的创建时期，分为静态代理和动态代理，动态代理就是代理类在程序运行期间运用反射机制动态创建而成。静态
代理的.class文件在程序运行前就已经存在。先来看一个静态代理的例子：

//需要实现的接口

<span style="font-family:KaiTi_GB2312;font-size:18px;">interface Sourceable
{
	public void method();
}</span>

//一个实现了公共接口的被代理的类

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Source implements Sourceable
{

	@Override
	public void method() 
	{
		System.out.println("the original method");
	}
}</span>

//实现了同一接口的代理类

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Proxy implements Sourceable
{
	private Source source;
	
	public Proxy()
	{
		this.source = new Source();	
	}

	@Override
	public void method() 
	{
		System.out.println("before.........do something");
		source.method();
		System.out.println("after..........do something");
	}
	
	
}</span>

从中可以看出，静态代理弄湿的每个代理类只能为一个接口服务，而且每个代理类除了接口不同以外其他的代码实现基本上没有太大的变动，
这会造成严重的代码重复。为解决这个问题，JVM为我们提供了动态代理技术。

动态代理技术：
1.要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方法将是一个非常麻烦的事情。
2.JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理。
3.JVM生成的动态代理必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类代理。

动态代理类要实现InvocationHandler接口，此接口中有一个方法：invoke(Object proxy,Method method,Object[] args),其中：
proxy:被代理的对象
method：被代理类中的方法
args：方法的参数

Proxy类是一个专门用来完成代理的操作类，其中有一个静态方法newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h),
该函数返回一个实现了一些接口的对象，这些接口即为被代理类所实现了的接口。其中：
loader：被代理对象的类加载器，即对象.getClass().getClassLoader().
interfaces:得到全部的接口
h：实现了InvocationHandler接口的对象。

写一个方法，该方法返回一个对象的代理，该代理能得到对象中所有方法的运行时间，方法实现：

<span style="font-family:KaiTi_GB2312;font-size:18px;">public static Object getProxy(Object target)
{
	Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new InvocationHandler() 
	{
			
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
		{
			long startTime = System.currentTimeMillis();
			Object revVal = method.invoke(target, args);
			try 
			{
					Thread.sleep((long)(Math.random()*1000));
			} 
			catch (Exception e) 
			{
				e.printStackTrace();
			}
			long endTime = System.currentTimeMillis();
			System.out.println(method.getName()+"   running time is : "+(endTime - startTime));
			return revVal;
		}
	});		
}</span>

注：

如果执行以下代码：
ArrayList<String> target = new ArrayList<String>();
Collection<String> proxyCollection = (Collection<String>)getProxy(target);
System.out.println(proxyCollection.getClass().getName());

控制台打印出的是:com.sun.proxy.$Proxy0

按理说代理执行任何方法都会交给InvocationHandler对象去调用invoke方法，因此上面应该打印出ArrayList的Class对象。

原因是代理类也是Object的子类，对Object继承过来的方法只将hashCode, equals和toString这三个方法交给InvocationHandler对象去
处理。其他的Object方法在调用时是调用代理类自己的。

实现类似spring的可配置AOP框架：
工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其中getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该实例对象的getProxy方法返回的对象，即动态代理。ProxyFactoryBean充当封装生成动态代理的工厂，该工厂需要提供被代理类对象来生成一个代理。

功能实现:
//通信契约接口，它包含代理所增强的被代理对象的方法的部分功能

<span style="font-family:KaiTi_GB2312;font-size:18px;">public interface Advice 
{
	public void beforeMethod();
	public void afterMethod();
}</span>

//实现了Advice接口的一个类

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class MyAdvice implements Advice
{

	@Override
	public void beforeMethod() {

		System.out.println("before.........method");
	}

	@Override
	public void afterMethod() {
		System.out.println("after...........method");
	}
	
}</span>

//ProxyFactoryBean的实现

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class ProxyFactroyBean
{
	private  Advice advice;   //传递一个Advice对象
	private  Object target;	  //需要被代理的对象
	
	public ProxyFactroyBean() {}

	public Object getProxy()
	{
		Object	proxy = Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(),new InvocationHandler() 
		{			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
			{
				Object revVal = null;
				long startTime = System.currentTimeMillis();
				advice.beforeMethod();	     //在调用被对象方法之前的处理
				revVal = method.invoke(target, args);
				advice.afterMethod();         //在调用被对象方法之后的处理
				long endTime = System.currentTimeMillis();
				System.out.println(method.getName()+" running time is : "+(endTime - startTime)+" millis");    //打印方法被执行的时间
				return revVal;
			}
		});
		return proxy;
	}	
	

	//设置advice
	public  void  setAdvice(Advice advice) {
		this.advice = advice;
	}

	//设置target
	public  void setTarget(Object target) {
		this.target = target;
	}
	
}</span>

//BeanFactory的实现，该类根据配置文件获得真正的目标类或代理类的实例对象

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class BeanFactory
{
	Properties props = new Properties();
	public BeanFactory(InputStream in)
	{
		try 
		{
			this.props.load(in);
		} 
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	
	public Object getBean(String name)
	{
		String className = this.props.getProperty(name);
		Object bean = null;
		try
		{
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();           //根据配置文件获得该类的一个实例对象
		} 
		catch (Exception e)
		{
			e.printStackTrace();
		} 
		if(bean instanceof ProxyFactroyBean)          //如果该类是ProxyFactroyBean，则获得一个代理并返回
		{
			Object proxy = null;
			ProxyFactroyBean proxyFactroyBean = (ProxyFactroyBean)bean;
			try 
			{
				Advice advice = (Advice)Class.forName(this.props.getProperty(name+".advice")).newInstance(); //获得实例对象advice
				Object target = Class.forName(this.props.getProperty(name+".target")).newInstance();         //获得实例对象target
				proxyFactroyBean.setAdvice(advice);          //设置advice的值
				proxyFactroyBean.setTarget(target);	    //设置target的值
				proxy = proxyFactroyBean.getProxy();        //获得target对象的代理
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
			return proxy;
		}
		//否则直接返回该实例对象
		return bean;
	}
}</span>

//我的配置文件(config.properties)
className=AOPspring.ProxyFactroyBean
#className=java.util.ArrayList
className.advice=AOPspring.MyAdvice
className.target=java.util.ArrayList

//测试

<span style="font-family:KaiTi_GB2312;font-size:18px;">public class AOPclass
{
	public static void main(String[] args) throws Exception
	{
		InputStream in = new FileInputStream("config.properties");  //获得配置文件的输入流
		BeanFactory bean = new BeanFactory(in);			   //获得BeanFactory对象			
		Object object = bean.getBean("className");                 //根据配置文件中的类名得到相应的一个实例对象
		((Collection)object).add(1);
	}
}</span>

程序运行结果为：
before.........method
after...........method
add running time is : 2 millis

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com