类加载器：
作用：用于将硬盘中的java类的内容加载到内存中变成字节码，被jvm调用。通常字节码的原始信息放在硬盘上的classpath指定的目录下。
系统默认的类加载器：BootStrap（父亲）、ExtClassLoader（儿子）、AppClassLoader（孙子）。在加载时，有优先级，通常是只要顶层的类加载器能找到类的文件，就从顶层加载。这也就是下面提到的类加载器的委托机制。用老师的通俗易懂的话说：当所有祖宗类没有加载到类，回到发起者还加载不了，会抛出classNotFoundException，不是在找它的儿子类来加载因为没有getchild方法，即使有，有多个儿子，该找哪个儿子加载呢？
public class ClassLoaderTest {
public static void main(String[] args) {
ClassLoader loader= ClassLoaderTest.class.getClassLoader();//根据类获得一个加载器
while(loader!=null)
{
System.out.println(loader.getClass().getName());
loader=loader.getParent();
}
System.out.println(loader);
}
}
sun.misc.Launcher$AppClassLoader //BootStrap--顶级类加载器：类加载器本身也是Java类，因为它是Java类，本身也需要加载器加载，显然必须有第一个类加载器而不是java类的，这正是BootStrap。它是嵌
sun.misc.Launcher$ExtClassLoader //套在Java虚拟机内核中的，已启动即出现在虚拟机中，是用c++写的一段二进制代码。所以不能通过java程序获取其名字，获得的只能是null。
null(BootStrap)
类加载器之间的父子关系和管辖范围图：
类加载器的委托机制
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
1．首先当前线程的类加载器去加载线程中的第一个类。
2．如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
3．还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
每个类加载器加载类时，又先委托给其上级类加载器。
1．当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个 呢？
2．对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。
每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。
有一道面试题，能不能自己写个类叫java.lang.System，答：通常是不可以的，因为有委托机制原来从在classpath中的类文件被顶级类加载器加载，我们写的类被bootstrap加载器加载（lib/tr.jar），但是我们可以自己写一个类加载器不委托给它的上级，实现让自己的加载器加载。
编写自己的类加载器（自定义类加载器必须继承ClassLoader）
老师提到了两点还是有很大用处的：有包名的类不能加载无包名的类；类加载器不能加载这种非public的类。
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); 得到的是ClassLoaderAttachment这个名字
String destPath = destDir + "\\" + destFileName; 目录加上\\ClassLoaderAttachment，正好是一个目标的路径
FileOutputStream fos = new FileOutputStream(destPath); 写入到输出流
cypher(fis,fos); 调用加密 运行这个类的时候记得将参数设置进去run open dilog>>参数（ClassLoaderAttachment这个文件的完整路径，itcastlib)
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 这里提到了模板方法设计模式：父类都是loadclass都是一样的流程，但是子类干的过程是不一样的，就定义成抽象方法，在子类里面去实现
protected Class<?> findClass(String name) throws ClassNotFoundException {继承了classLoader并且要复写findClass()方法，因为loadClass会去委托他的上级去加载，最终是findClass()
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); 将内容转换成字节码 将一对二进制数据转换成Class文件
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public MyClassLoader(){
}
public MyClassLoader(String classDir){
this.classDir = classDir;
}
}
import java.util.Date;
public class ClassLoaderTest {
public static void main(String[] args) throws Exception {
//System.out.println(new ClassLoaderAttachment().toString()); 这里不打印"hello,itcast";？？？
System.out.println("xxx2");
Class clazz = new MyClassLoader("itcastlib").loadClass("cn.itcast.day2.ClassLoaderAttachment"); 有包名的类不能调用无包名的类
Date d1 = (Date)clazz.newInstance();
System.out.println(d1);
}
}
import java.util.Date;
public class ClassLoaderAttachment extends Date { 就是加密的这个类文件的
public String toString(){
return "hello,itcast";
}
}
一个类加载器的高级问题分析
编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader 。
父级类加载器加载的类无法引用只能被子级类加载器加载的类，原理如下图：
webappClassLoader>>StandardClassLoader>>AppClassLoader>>ExtClassLoader
代理：
程序中的代理：腰围已存在的具有相同接口的目标类的各个方法增加一些系统功能。例如：异常处理、日志、事务管理、计算方法和运行时间等等，你该怎么做？
代理类的优点：
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
目标类： 代理类：
class X{ class Xproxy{
void sayHello(){ void sayHello(){
syso:Hello; startTime
} X. sayHello();
} endTime;} }
一般用接口来引用其子类，如：Collectioncoll = new ArrayList();
代理架构图
AOP
系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示：
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
用具体的程序代码描述交叉业务：
method1 method2 method3
{ { {
------------------------------------------------------切面
.... .... ......
------------------------------------------------------切面
} } }
交叉业务的编程问题即为面向方面的编程（Aspect oriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
安全，事务，日志等功能要贯穿到好多个模块中，所以，它们就是交叉业务重要原则：不要把供货商暴露给你的客户
动态代理技术
1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
2、JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
3、JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
4、CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
5、代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
1）在调用目标方法之前
2）在调用目标方法之后
3）在调用目标方法前后
4）在处理目标方法异常的catch块中
分析JVM动态生成的类
总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
三个方面：
1、生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
2、产生的类字节码必须有个一个关联的类加载器对象；
3、生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
用newProxyInstance（）方法直接一步就创建出代理对象。
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
public static void main(String[] args) throws Exception{
Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); //用到了之前的代码Collection
System.out.println(clazzProxy1.getName()); 得到的class：$Proxy0
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----------");
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());
}
System.out.println("----------begin create instance object----------"); 创建实例对象用了三种方式
//Object obj = clazzProxy1.newInstance();
Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
class MyInvocationHander1 implements InvocationHandler{ 内部都要调用invoke，还要传三个参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1()); 这个MyInvocationHander1是在外部写好的
System.out.println(proxy1);
proxy1.clear();
//proxy1.size(); 因为，代理调用size方法，其实是调用了MyInvocationHandler1中的invoke，他的返回值是null
//System.out.println("111111111111111");
Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
});
final ArrayList target = new ArrayList();
Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size()); 3
System.out.println(proxy3.getClass().getName());
}
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;
}
}
总结分析动态代理类的统计原理和结构：
1、怎样将目标传进去：
1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。
2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。
3）让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。
2、动态代理的工作原理：
1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。
猜想分析动态生成的类的内部代码：
1、动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。
2、构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？
实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：
分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？
为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：
因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。
实现类似spring的可配置的AOP框架
工厂类BeanFactory：
1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。
2、getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类示例对象的getProxy方法返回的对象。
3、BeanFactory的构造方法接收代表配置文件的输入流对象的配置文件格式如下：
#xxx=java.util.ArrayList
xxx=cn.itcast.test3.aopframework.ProxyFactoryBean
xxx.advice=cn.itcast.test3.MyAdvice
xxx.target=java.util. ArrayList
注意：其中的#代表注释当前行。
4、ProxyFactoryBean充当封装成动态的工厂，需为工厂提供的配置参数信息包括：
目标（target）
通告（advice）
5、BeanFactory和ProxyFactoryBean：
1）BeanFactory是一个纯粹的bean工程，就是创建bean即相应的对象的工厂。
2）ProxyfactoryBean是BeanFactory中的一个特殊的Bean，是创建代理的工厂。
实现类似spring的可配置的AOP框架的思路：
1、创建BeanFactory类：
1）构造方法：接受一个配置文件，通过Properties对象加载InputStream流对象获得。
2）创建getBean(String name)方法，接收Bean的名字，从上面加载后的对象获得。
3）通过其字节码对象创建实例对象bean。
4）判断bean是否是特殊的Bean即ProxyFactoryBean，如果是，就要创建代理类，并设置目标和通告，分别得到各自的实例对象，并返回代理类实例对象。如果不是在返回普通类的实例对象。
2、创建ProxyFactoryBean(接口)，此处用类做测试，其中有一个getProxy方法，用于获得代理类对象。
3、对配置文件进行配置，如上面配置一样。
4、作一个测试类：AopFrameworkTest进行测试。
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import cn.itcast.day3.Advice;
public class BeanFactory {
Properties props = new Properties();
public BeanFactory(InputStream ips){
try {
props.load(ips);
} catch (IOException e) {
e.printStackTrace();
}
}
public Object getBean(String name){
String className = props.getProperty(name);
Object bean = null;
try {
Class clazz = Class.forName(className);
bean = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){
Object proxy = null;
ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
try {
Advice advice = (Advice)Class.forName(props.getProperty(name + ".advice")).newInstance();
Object target = Class.forName(props.getProperty(name + ".target")).newInstance();
proxyFactoryBean.setAdvice(advice);
proxyFactoryBean.setTarget(target);
proxy = proxyFactoryBean.getProxy();
} catch (Exception e) {
e.printStackTrace();
}
return proxy;
}
return bean;
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.itcast.day3.Advice;
public class ProxyFactoryBean {
private Advice advice;
private Object target;
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 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;
}
}
import java.io.InputStream;
import java.util.Collection;
public class AopFrameworkTest {
public static void main(String[] args) throws Exception {
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
((Collection)bean).clear();
}
}
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
