黑马程序员_Java学习日记26_高新技术5
----------------------android培训、java培训、期待与您交流！ ---------------------
1.类加载器
简要介绍类加载器的概念和作用
Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader
类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap。
Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
//如下代码说明放置在不同位置的类确实由不同的类加载器加载的：
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。
//用下面的代码让查看类加载器的层次结构关系
ClassLoader loader = ClassLoaderTest.class.getClassLoader();
//打印出当前的类装载器，及该类装载器的各级父类装载器
while(loader != null)
{
System.out.println(loader.getClass().getName());
loader = loader.getParent();
}
BootStrap----》JRE/lib/rt.jar
|
ExtClassLoader---》JRE/lib/ext/*.jar
|
AppClassLoader---》ClASSPATH指定的所有jar或目录
|---MyClassLoader
|---ItcastClassLoader---》itcast指定的特殊目录
System的classLoader是AppClassLoader。
类加载器的委托机制
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载？
首先当前线程的类加载器去加载线程中的第一个类。
如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时，又先委托给其上级类加载器。
当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，不知道找哪一个。
对着类加载器的层次结构图和委托加载原理，先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader。
每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。
有一道面试，能不能自己写个类叫java.lang.System，为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，也就是总是使用爸爸们能找到的类，这样总是使用java系统提供的System。把先前编写的类加入到jdk的rt.jar中，会有怎样的效果？不行!不能随意将自己的class文件加入进rt.jar文件中的。
package cn.itcast.day2;
import java.util.Date;
public class ClassLoaderTest {
public static void main(String[] args) throws Exception {
System.out.println(
ClassLoaderTest.class.getClassLoader().getClass().getName()
);
System.out.println(
System.class.getClassLoader()
);
System.out.println("xxx");
ClassLoader loader = ClassLoaderTest.class.getClassLoader();
while(loader != null){
System.out.println(loader.getClass().getName());
loader = loader.getParent();
}
System.out.println(loader);
//System.out.println(new ClassLoaderAttachment().toString());
System.out.println("xxx2");
Class clazz = new MyClassLoader("itcastlib").loadClass("cn.itcast.day2.ClassLoaderAttachment");
Date d1 = (Date)clazz.newInstance();
System.out.println(d1);
}
} 编写自己的类加载器
知识讲解：
自定义的类加载器的必须继承ClassLoader，实现loadClass方法与findClass方法，defineClass方法
编程步骤：
编写一个对文件内容进行简单加密的程序。
编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。
实验步骤：
对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： java MyClassLoader MyTest.class F:\itcast
运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。
package cn.itcast.day2;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader extends ClassLoader{
public static void main(String[] args) throws Exception {
String srcPath = args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
String destFileName = srcPath.substring(srcPath.lastIndexOf('\\')+1);
String destPath = destDir + "\\" + destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
private static void cypher(InputStream ips ,OutputStream ops) throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
private String classDir;
@Override
protected Class findClass(String name) throws ClassNotFoundException {
String classFileName = classDir + "\\" + name.substring(name.lastIndexOf('.')+1) + ".class";
try {
FileInputStream fis = new FileInputStream(classFileName);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
cypher(fis,bos);
fis.close();
System.out.println("aaa");
byte[] bytes = bos.toByteArray();
return defineClass(bytes, 0, bytes.length);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public MyClassLoader(){
}
public MyClassLoader(String classDir){
this.classDir = classDir;
}
}
程序中的代理
要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等。
编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
用具体的程序代码描述交叉业务：
method1 method2 method3
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面
} } }
交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务。
重要原则：不要把供货商暴露给你的客户
动态代理技术
要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类太累！
JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。（这个版本的JDK是第三方库，下个版本的JDK就可能变为官方库！）
代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1.在调用目标方法之前
2.在调用目标方法之后
3.在调用目标方法前后
4.在处理目标方法异常的catch块中
注：：一个示意代码进行辅助说明，例如
Class proxy{
void sayHello(){
……….
try{
target.sayHello();
}catch(Exception e){
………..
}
………….
}
}
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy1.getName());
System.out.println("----------begin constructors list----------");
/*$Proxy0()
$Proxy0(InvocationHandler,int)*/
Constructor[] constructors = clazzProxy1.getConstructors();
for(Constructor constructor : constructors){
String name = constructor.getName();
StringBuilder sBuilder = new StringBuilder(name);
sBuilder.append('(');
Class[] clazzParams = constructor.getParameterTypes();
for(Class clazzParam : clazzParams){
sBuilder.append(clazzParam.getName()).append(',');
}
if(clazzParams!=null && clazzParams.length != 0)
sBuilder.deleteCharAt(sBuilder.length()-1);
sBuilder.append(')');
System.out.println(sBuilder.toString());
}
System.out.println("----------begin methods list----------");
/*$Proxy0()
$Proxy0(InvocationHandler,int)*/
Method[] methods = clazzProxy1.getMethods();
for(Method method : methods){
String name = method.getName();
StringBuilder sBuilder = new StringBuilder(name);
sBuilder.append('(');
Class[] clazzParams = method.getParameterTypes();
for(Class clazzParam : clazzParams){
sBuilder.append(clazzParam.getName()).append(',');
}
if(clazzParams!=null && clazzParams.length != 0)
sBuilder.deleteCharAt(sBuilder.length()-1);
sBuilder.append(')');
System.out.println(sBuilder.toString());
}1.创建动态类的实例对象
2.用反射获得构造方法
3.编写一个最简单的InvocationHandler类（只实现其空方法。。。）
4.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
5.打印创建的对象和调用对象的没有返回值的方法和getClass方法，调用其他有返回值的方法报告了异常。
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
//用内部类的方式实现InvocationHandler接口的实例
class MyInvocationHander1 implements InvocationHandler{
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
return null;
}
}
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());
System.out.println(proxy1);
proxy1.clear();
//proxy1.size();//用匿名内部类的方式实现InvocationHandler接口，并直接创建动态类，invoke方法简单实现，实现空方法 Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null;
}
});总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
a.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
b.产生的类字节码必须有一个关联的类加载器对象；
c.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
用Proxy.newInstance方法直接一步就创建出代理对象。
Collection proxy= (Collection)constructor.newInstance(new InvocationHandler(){
@Override
//这里的三个参数正好就是proxy.add(obj)中的三部分 。
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return null;
}
});分析InvocationHandler对象的运行原理
猜想分析动态生成的类的内部代码
动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：
Client程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象（Object proxy）、add方法（Method method）、“abc”参数（Object[] args）
Class Proxy$ {
add(Object object) {
return handler.invoke(Object proxy, Method method, Object[] args);
}
}
分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会出现NullPointerException异常？
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
调用调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。
$Proxy0 implements Collection
{
InvocationHandler handler;
public $Proxy0(InvocationHandler handler)
{
this.handler = handler;
}
//生成的Collection接口中的方法的运行原理
int size()
{
return handler.invoke(this,this.getClass().getMethod("size"),null);
}
void clear(){
handler.invoke(this,this.getClass().getMethod("clear"),null);
}
boolean add(Object obj){
handler.invoke(this,this.getClass().getMethod("add"),obj);
}
}分析动态代理的工作原理图:
怎样将目标类传进去？
直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
public class ProxyTest {
public static void main(String[] args) throws Exception{
final Collection target = new ArrayList();
Collection proxy = getProxy(target,new Advice(){
public void afterMethod() {
System.out.println("end............");
}
public void beforeMethod() {
System.out.println("start.........");
}
});
proxy.add("aa");
System.out.println(proxy.size());
//proxy.clear();
System.out.println(proxy.toString());
System.out.println(((ArrayList)target).get(0));
}
private static Collection getProxy(final Collection target ,final Advice advice)
throws NoSuchMethodException, InstantiationException,
IllegalAccessException, InvocationTargetException {
Class clazz1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
class MyInvocationHander implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
advice.beforeMethod();
Object retVal = method.invoke(target, args);
advice.afterMethod();
return retVal;
}
}
//Collection proxy = (Collection)clazz.newInstance();
Constructor constructor = clazz1.getConstructor(InvocationHandler.class);
Collection proxy = (Collection)constructor.newInstance(new MyInvocationHander());
return proxy;
}
}把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！
为bind方法增加一个Advice参数。
public class ProxyTest {
public static void main(String[] args) throws Exception{
final ArrayList target = new ArrayList();
Collection proxy = (Collection)getProxy(target,new MyAdvice());
proxy3.add("zioxx");
System.out.println(proxy.size());
System.out.println(proxy.getClass().getName());
}
private static Object getProxy(final Object target,final Advice advice) {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
/*new Class[]{Collection.class},*/
target.getClass().getInterfaces(),
new InvocationHandler(){
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 proxy;
}
}
interface Advice {
void beforeMethod(Method method);
void afterMethod(Method method);
}
class MyAdvice implements Advice {
long beginTime = 0;
public void afterMethod(Method method) {
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));
System.out.println("end........");
}
public void beforeMethod(Method method) {
System.out.println("start......");
beginTime = System.currentTimeMillis();
}
}实现AOP功能的封装与配置
工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice
ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标，通知
编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象
-----------------------android培训、java培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net/heima