黑马程序员_Java高新技术——类加载器，代理

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

类加载器的概念：

类加载器就是加载类的工具，JVM在运行的时候需要加载类的class文件进内存，生成类的字节码文件。

加载class文件并生成类的字节码文件的过程就是由类加载器来完成的。

因为类加载器本身也是java类，而任何的java类都需要被加载器加载，所以必然会有一个类加载器不是java类，

它就是Bootstrap。JVM中还内置了两个类加载器：ExtClassLoader和AppClassLoader，它们由Bootstrap加载。

类加载器的委托机制：

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

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

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

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

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

AppClassLoader-->ExtClassLoader-->BootStrap

当所有上级类加载器没有加载到类，会回到发起者类加载器，还加载不了，则抛ClassNotFoundException。

自定义类加载器：

模板方法设计模式：

父类-->loadClass

子类1（自己干）

子类2（自己干）

原理：

继承ClassLoader为了保留原来的委托机制，不覆盖loadClass方法，直接继承自父类。

只需要覆盖findClass方法，

此方法中使用defineClass方法返回一个class。

实现步骤：

对ClassLoaderAttachment.class文件进行加密，

加密结果存放到另外一个目录ClassLoaderlib文件夹下，

需要用自定义的类加载器才能加载。

/**
* 测试类
* @author 张熙韬
*
*/
public class ClassLoaderAttachment extends Date {
public String toString(){
return "hello!";
}
}

/**
* 类加载器
* @Author 张熙韬
*/
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 is,OutputStream os) throws Exception{
int len=-1;
while((len=is.read())!=-1){
os.write(len^0xff);
}
}

private String classDir;

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {

String classFileName=classDir+"\\"+name+".class";

try {
FileInputStream fis=new FileInputStream(classFileName);
ByteArrayOutputStream bos=new ByteArrayOutputStream();
cypher(fis, bos);
System.out.println("我的类加载器");
fis.close();
byte[] bytes=bos.toByteArray();
return defineClass(bytes, 0, bytes.length);
} catch (Exception e) {
// TODO: handle exception
}
return super.findClass(name);
}

public MyClassLoader(){

}
public MyClassLoader(String classDir){
this.classDir=classDir;
}

}

一个基于javaWeb的类加载器的高级应用：

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

response.setContentType("text/html");
PrintWriter out = response.getWriter();
ClassLoader loader=this.getClass().getClassLoader();
while(loader!=null){
out.println(loader.getClass().getName()+"<br>");
loader=loader.getParent();
}
//		out.println(loader.getClass().getName()+"<br>");

out.close();
}

}

========================================================================================

代理

面向方面编程（AOP）：

系统中可能存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：

安全 事务 日志

StudentService ------|----------|------------|-------------

CourseService ------|----------|------------|-------------

MiscService ------|----------|------------|-------------

AOP（Aspect oriented program ），面向方面的编程的目标就是要使交叉业务模块化。

可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

------------------------------------------------------切面

func1 func2 func3

{ { {

.... .... ......

} } }

------------------------------------------------------切面

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

代理：应用程序出了当前类能提供的功能外，有时需要一些其他的额外功能，比如安全、日志等，这时需要用代理类。

小知识点串讲：StringBuffer和StringBuilder的简单区别

在单线程的时候，StringBuilder的效率高，多线程的时候应该使用StringBuffer!

Proxy类和InvacationHandler接口提供了生成动态代理的功能。

1.getProxyClass()方法：创建动态代理类的字节码。

Proxy.getProxyClass(loader, interfaces)：接收两个参数，loader指定动态代理类的类加载器，interfaces指定动态代理类要实现的接口。返回Class对象。

2.newProxyInstance()方法：创建动态代理类的示例。

Proxy.newProxyInstance(loader, interfaces, h)

：接收三个参数，loader指定动态代理类的类加载器，interfaces指定动态代理类要实现的接口，h指定 与动态代理类关联的InvacationHandler对象。

代码示例：

private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = 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 {

/*long beginTime = System.currentTimeMillis();
Object retVal = method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));
return retVal;*/

advice.beforeMethod(method);
Object retVal = method.invoke(target, args);
advice.afterMethod(method);
return retVal;

}
}
);
return proxy3;
}

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

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

InvocationHandler类里面只复写了Object里面的equals，toString，hashCode方法。

代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

动态代理的工作原理：当调用代理的各个方法时，会把请求传递给由代理类传递进来的InvacationHandler对象。InvacationHandler对象通过invoke()方法把请求分给目标对象的各个方法。

为了让代码更加的灵活，需要将目标类传入代理的Invoke方法中，需要把target和系统代码封装成对象，抽到InvocationHandler外面，之后通过参数的方法传递进去。getProxy（tarket，advice）

代码示例：

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

public class MyAdvice implements Advice {
long beginTime = 0;
public void afterMethod(Method method) {
// TODO Auto-generated method stub
System.out.println("潇洒哥从黑马毕业上班啦！");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + " running time of " + (endTime - beginTime));

}

public void beforeMethod(Method method) {
// TODO Auto-generated method stub
System.out.println("潇洒哥到黑马来学习啦！");
beginTime = System.currentTimeMillis();
}

}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------