类加载器和代理

最新推荐文章于 2022-11-02 10:10:43 发布

置顶 qqwqw23232

最新推荐文章于 2022-11-02 10:10:43 发布

阅读量337

点赞数

分类专栏：黑马程序员学习日志

本文链接：https://blog.csdn.net/zhangsan212/article/details/8851180

版权

黑马程序员学习日志专栏收录该内容

10 篇文章 0 订阅

订阅专栏

------- android培训、 java培训、期待与您交流！------

一, 类加载器

1类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。

一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。

2Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader

类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。

Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

1.  逐一编写如下代码来说明放置在不同位置的类确实由不同的类加载器加载的：
	System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
	 //将上面语句的测试类改为System则抛NullPointerException，这两个类存放位置不同
	System.out.println(System.class.getClassLoader().getClass().getName());
	改为System.out.println(System.class.getClassLoader());打印的结果为null。

3类加载器之间的父子关系和管辖范围

Bootstrap ClassLoader ->JRE/lib/rt.jar

↑
Extension ClassLoader ->JRE/lib/ext/*.jar

↑
ApplicationClassLoader ->ClassPath指定的所有jar或目录。

/ \
MyClassLoader itcastClassLoader->指定的特殊目录

.用下面的代码让查看类加载器的层次结构关系
		ClassLoader loader = ClassLoaderTest.class.getClassLoader();
		//打印出当前的类装载器，及该类装载器的各级父类装载器
		while(loader != null)
		{
			System.out.println(loader.getClass().getName());
			loader = loader.getParent();
		}

4类加载器的委托机制

当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？

首先当前线程的类加载器去加载线程中的第一个类。

如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又先委托给其上级类加载器。

当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？

每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。

能不能自己写个类叫java.lang.System，为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，也就是总是使用爸爸们能找到的类，这样总是使用java系统提供的System

5编写自己的类加载器

知识讲解：

自定义的类加载器的必须继承ClassLoader

loadClass方法与findClass方法

defineClass方法

编程步骤：

编写一个对文件内容进行简单加密的程序。

编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。

编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。

实验步骤：

对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： java MyClassLoader MyTest.classF:\itcast

运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTestF:\itcast

用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。

删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。

import java.io.*;
import java.lang.reflect.*;
public class MyClassLoader extends ClassLoader
{
	private String path = null;
	public MyClassLoader(String path) throws Exception//检查文件是否存在
	{
		File f = new File(path);
		if(!f.isDirectory())
		{
			throw new RuntimeException(path + " is not a directory");
		}
		this.path = path;
	}
	
	public Class findClass(String name)
	{
		try
		{
			File f = new File(path,name.substring(name.lastIndexOf('.')+1) + ".class");
			FileInputStream fis = new FileInputStream(f);
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			cypher(fis,bos);
			byte [] buf = bos.toByteArray();
			fis.close();
			bos.close();
			return defineClass(name,buf,0,buf.length);
		}catch(Exception e)
		{
			throw new ClassNotFoundException(name + " is not found!");
		}
		return null;
	}

	
	public static void cypher(InputStream istream,OutputStream ostream) throws Exception
	{
		
		
		int b = 0;
		while((b = istream.read()) != -1)
		{
			ostream.write(((byte)b) ^ 0xff);
		}
	}

	public static void main(String [] args) throws Exception
	{

		
		if(!args[0].endsWith("class"))
		{
			ClassLoader loader = new MyClassLoader(args[1]);
			Class cls = loader.loadClass(args[0]);
			Method m = cls.getMethod("test");
			
			m.invoke(cls.newInstance());
			return;
			
		}
		else
		{		
			FileInputStream fis = new FileInputStream(args[0]);		
			File f = new File(args[1], new File(args[0]).getName());
			FileOutputStream fos = new FileOutputStream(f);		
			cypher(fis,fos);
			fis.close();
			fos.close();
		}
	}

测试类

class MyTest
{
	public void test()
	{
		System.out.println("hello world");
	}
}

二,代理Proxy

代理的概念与作用

程序中的代理

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

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

如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，

实例：

    target：   
     class T   
     {  
       void print()  
       {  
         System.out.println("target");  
       }  
     }  
       
    proxy：  
    TProxy  
     {  
       void print()  
       {  
         start;  
         T.print();  
         end;  
       }   
     }

AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面

交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），

AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的

使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术
动态代理技术

JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

分析 JVM 动态生成的类

l创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

l编码列出动态类中的所有构造方法和参数签名

l编码列出动态类中的所有方法和参数签名

l创建动态类的实例对象

用反射获得构造方法

编写一个最简单的InvocationHandler类

调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去

打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

将创建动态类的实例对象的代理改成匿名内部类的形式编写

让jvm创建动态类及其实例对象，需要给它提供哪些信息

•生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；

•产生的类字节码必须有个一个关联的类加载器对象；

•生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

.  Class clazz = Proxy.getProxyClass(ProxyTest.class.getClassLoader(), Collection.class);
     System.out.println(clazz.getName());

	Method[] methods = clazz.getMethods();
		for(Method m:methods)
		{
			System.out.println(m.getName());
		}
		
 		Constructor[] contructors = clazz.getConstructors();
		for(Constructor c:contructors)
		{
			System.out.print(c.getName());
			StringBuilder sb = new StringBuilder();
			sb.append('(');
			Class[] paramTypes = c.getParameterTypes();
			for(Class paramType:paramTypes)
			{
				sb.append(paramType.getName());
				sb.append(',');
			}
			if(paramTypes.length>1)
				sb.deleteCharAt(sbf.length()-1);
			sb.append(')');
			System.out.println(sb.toString());

得到构造方法，创建对象， .用Constructor创建代理类实例:因为需要用到InvocationHandler接口类型的参数，可以先定义一个内部实现类.

Constructor constructor = clazz.getConstructor(InvocationHandler.class);

private class MyInvocationHandler implements InvocationHandler {

  publicObject invoke(Object proxy, Method method, Object[] args)

  throwsThrowable {

  returnnull;

  }
	Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler1());

也可以直接用匿名内部类在参数列表上实现接口。

Collection proxy= (Collection)constructor.newInstance(new InvocationHandler(){
			@Override
				
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				return null;
			}
			
		});

2.直接用Proxy的静态方法newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

   Collection proxy=(Collection)Proxy.newProxyInstance(  
            Collection.class.getClassLoader(),   
            new Class[]{Collection.class},  
            new InvocationHandler(){  
                ArrayList target= new ArrayList();  
                public Object invoke(Object proxy, Method method,  
                        Object[] args) throws Throwable {  
                    long startTime = System.currentTimeMillis();  
                    Object retVal = method.invoke(target, args);  
                    long endTime = System.currentTimeMillis();  
                    System.out.println(method.getName()+"  running time:"+(endTime - startTime));  
                    return retVal;                        
                }  
                  
            });  
    proxy.add("a");  
    proxy.add("b");  
    proxy.add("c");  
    System.out.println(proxy.size());  



让动态生成的类成为目标类的代理

动态代理类的用Proxy.newProxyInstance()方法生成，执行要再传入两个参数：要代理的目标target和增加的系统功能的封装对象（advice），让动态生成的类成为目标的代理

public class ProxyTest {

	
	public static void main(String[] args) throws Exception{
		
		Class clazz = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println(clazz.getName());
		
		final Collection target = new ArrayList();
		
		Collection proxy = getProxy(target,new Advice(){
		public void afterMethod() 
	 	{
		System.out.println("after");
			}	public void beforeMethod() {
		System.out.println("before");				
	}
});
		proxy.add("aa");
		proxy.add("bb");
		System.out.println(proxy.size());
		//proxy.clear();
		System.out.println(proxy.toString());		
		System.out.println(((ArrayList)target).get(0));
	}

privatestatic Collection getProxy(finalCollection target ,final Advice advice) throws Exception 
 {  
Class clazz1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); 
   class MyInvocationHanderimplements InvocationHandler {  public Object invoke(Object proxy, Method method,Object[] args)  throws Throwable {
  advice.beforeMethod();
 Object retVal = method.invoke(target, args); 
 advice.afterMethod();  return retVal;  
}  }    
 Constructor constructor =clazz1.getConstructor(InvocationHandler.class);
 Collection proxy = (Collection)constructor.newInstance(new MyInvocationHander()); 
 return proxy;   }  }

实现 AOP 功能的封装与配置

工厂类 BeanFactory 负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其 getBean 方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是 ProxyFactoryBean ，则直接返回该类的实例对象，否则，返回该类实例对象的 getProxy 方法返回的对象。

l BeanFactory 的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

  #xxx=java.util.ArrayList

  xxx=cn.itcast.ProxyFactoryBean

  xxx.target=java.util.ArrayList

  xxx.advice=cn.itcast.MyAdvice

ProxyFacotryBean 充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？

目标

通知 l 编写客户端应用：

编写实现 Advice 接口的类和在配置文件中进行配置

调用 BeanFactory 获取对象

public class BeanFactory {
		public static void main(String[] args) {
		InputStream ips = BeanFactory.class.getResourceAsStream("config.properties");
		BeanFactory beanFactory = new BeanFactory(ips);
		Object obj = beanFactory.getBean("xxx");
		System.out.println(obj.getClass().getName());
		System.out.println(obj.toString());		
	}

	private InputStream ips = null;
	private Properties props = new Properties();
	
	public BeanFactory(InputStream ips){
		this.ips = ips;
		try {
			props.load(ips);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	Object getBean(String beanName){
		Object obj = null;
		try {
			String className = props.getProperty(beanName);
			Class clazz = Class.forName(className);
			obj = clazz.newInstance();
			if(obj instanceof ProxyFactoryBean){
				ProxyFactoryBean factoryBean = (ProxyFactoryBean)obj;
				String adviceName = props.getProperty(beanName + ".advice");
				String targetName = props.getProperty(beanName + ".target");
				factoryBean.setAdvice((Advice)Class.forName(adviceName).newInstance());
				factoryBean.setTarget(Class.forName(targetName).newInstance());
				obj = factoryBean.getProxy();
			}
		} catch (Exception e) {
						e.printStackTrace();
		}
		return obj;
	}
}
/**
ProxyFactoryBean类代码
*/
 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.Collection;

public class ProxyFactoryBean {
	Advice advice = null;
	Object target = null;
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	
    public Object getProxy(){
        Object proxy=Proxy.newProxyInstance(
                target.getClass().getClassLoader, 
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        adivce.beforeMethod(method);
                        Object retVal=method.invoke(target, args);
                        return retVal;
                    }
                });
        return proxy;
    

}
	
public class MyAdvice implements Advice{
public void afterMethod() 
{
System.out.println("after");
}
public void beforeMethod() 
{
System.out.println("before");
}}

qqwqw23232

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
类加载器和代理

------- android培训、java培训、期待与您交流！------一,类加载器1类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。 2Java虚拟机中可以安装多个类加载器，系统默认三个主
复制链接

扫一扫