java类加载器-动态代理类-Properties类使用

1  java类加载器-动态代理类

(1)一共3中类加载器，AppClassLoader加载指定的类。java默认加载器

(2)Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

(3)BootstrapClassLoader 此加载器采用c++编写，一般开发中很少见。

作用：前后加一些代码。将你要使用的类，重新生成一个子类或本类，利用这个新生成的类做一些事情，比如在该类的方法前后加一些代码。

      能在运行过程中根据接口的类型动态的调用实现该接口的类

 

 

1.1代理类生命周期

    在一个类编译完成之后，下一步就需要开始使用类，如果要使用一个类，肯定离不开JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。

1、类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。 但是同一个类只会被类装载器装载以前

链接就是把二进制数据组装为可以运行的状态。

 

2、链接分为校验，准备，解析这3个阶段

校验一般用来确认此二进制文件是否适合当前的JVM（版本），

准备就是为静态成员分配内存空间，。并设置默认值

解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）

3、完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。

当没有任何引用指向Class对象时就会被卸载，结束类的生命周期

 

4、完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作

/**完成动态代理*/
public interface Subject {
	//定义项目接口
	public String say(String name,int age);	//表示
}

//定义真实项目
class RealSubject implements Subject{
	public String say(String name, int age) {
		return name+" "+age;
	}
}
class MyInvocationHandler implements InvocationHandler{
	private Object obj=null;
	//在代理实例上处理方法调用并返回结果
	public Object bind(Object obj) {
		this.obj=obj;
		//3、根据被代理对象产生一个代理
		/*第一个：用哪个classLoader来产生代理对象，当然要和被代理对象用同一个classLoader，不然互相之间访问不了
		 * 		产生的代理对象包含了被代理对象
		  第二个：产生的被代理对象，应该实现哪个接口，
第三个：当我产生这个代理之后，我要调用代理里面方法的时候，我要用哪一个handle处理*/

		return Proxy.newProxyInstance(obj.getClass().getClassLoader()
				, obj.getClass().getInterfaces(), this);
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object temp=method.invoke(this.obj, args);
		return temp;
	}
}
class hello{
	public static void main(String[] args) {
		//1、把下面被代理的对象交给InvocationHandler，只有交给它才知道被代理对象的方法
		MyInvocationHandler demo=new MyInvocationHandler();
		//2、被代理的对象RealSubject
		Subject sub=(Subject)demo.bind(new RealSubject());
		
		String info=sub.say("Rollen", 20);
		System.out.println(info);

	}
}

1.2 Properties属性文件使用—反射应用 

 

package cn.动态代理;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class ReflectApplyFactory {

}

interface fruit{
	public abstract void eat(); //吃
}
class Apple implements fruit{
	public void eat() {
		System.out.println("Apple");
	}
}
class Orange implements fruit{
	public void eat() {
		System.out.println("Orange");
	}
}
//构造工厂
class Factory{
	public static fruit getInstance(String fruitName) throws Exception{
		fruit fruit=null;
		/**1、工厂模式
		 *    添加一个子类就需要修改工厂*/
//		if ("Apple".equals(fruitName)) {
//			fruit=new Apple();
//		}if ("Orange".equals(fruitName)) {
//			fruit=new Orange();
//		}
		/**2、利用反射机制
		 *    添加任意多个子类的时候，工厂类就不需要修改。*/
		fruit=(fruit)Class.forName(fruitName).newInstance();
		
		return fruit;
	}   }

/**操作属性文件类*/
class Init{
	public static Properties getPro() throws Exception{
		Properties pro=new Properties();
		File file=new File("fruit.properties");
		//先从输入流中读，没读到就写，然后再加载到属性表中。
		if (file.exists()) {
			//从输入流中读取属性列表(键和元素对)
			pro.load(new FileInputStream(file));
		}else {
			pro.setProperty("apple", "cn.动态代理.Apple");
			pro.setProperty("orange", "cn.动态代理.Orange");
			//加载到 Properties 表中的格式.
			//将此 Properties 表中的属性列表（键和元素对）写入输出流。
			pro.store(new FileOutputStream(file), "Fruit Class");
		}
		return pro;
	}   }
class hellow1{
	public static void main(String[] args) throws Exception {
		Properties pro=Init.getPro();
		fruit fruit=Factory.getInstance(pro.getProperty("apple"));
		if (fruit!=null) {
			fruit.eat();
		}	}   }