高新技术知识点总结03

类加载器及其委托机制的深入分析、自定义类加载器的编写原理分析、编写对class文件进行加密的工具类、编写和测试自己编写的解密类加载器、类加载器的一个高级问题的实验分析：

 

类加载器

 

简要介绍什么是类加载器和类加载器的作用

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

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

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

 

类加载器的委托机制

 

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

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

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

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

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

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

对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。

 

编写自己的类加载器

 

知识讲解：

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

loadClass方法与findClass方法

defineClass方法

编程步骤：

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

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

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

实验步骤：

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

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

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

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

 

示例：

 

Java代码 

package cn.itcast.day2;

 

import java.util.Date;

 

public class ClassLoaderTest {

 

/**

* @param args

*/

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

// TODO Auto-generated method stub

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(newClassLoaderAttachment().toString());

System.out.println("xxx2");

Class clazz = new MyClassLoader("itcastlib").loadClass("cn.itcast.day2.ClassLoaderAttachment");

Date d1 = (Date)clazz.newInstance();

System.out.println(d1);

}

 

}

Java代码 

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{

 

/**

* @param args

*/

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

// TODO Auto-generated method stub

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(InputStreamips ,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 {

// TODO Auto-generated method stub

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) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

 

public MyClassLoader(){

 

}

 

public MyClassLoader(String classDir){

this.classDir = classDir;

}

}

Java代码 

package cn.itcast.day2;

 

 

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。

父级类加载器加载的类无法引用只能被子级类加载器加载的类。

 

分析代理类的作用与原理及AOP概念、创建动态类及查看其方法列表信息、创建动态类的实例对象及调用其方法、完成InvocationHandler对象的内部功能、分析InvocationHandler对象的运行原理、总结分析动态代理类的设计原理与结构、编写可生成代理和插入通告的通用方法、实现类似spring的可配置的AOP框架：

 

代理的概念与作用

 

生活中的代理

武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？

程序中的代理

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

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

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

 

AOP

 

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

安全 事务 日志

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

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

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

用具体的程序代码描述交叉业务：

method1 method2 method3

{ { {

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

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

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

} } }

交叉业务的编程问题即为面向方面的编程（Aspectoriented program ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

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

func1 func2 func3

{ { {

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

} } }

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

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

 

动态代理技术

 

要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

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

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

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

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

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

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

 

分析JVM动态生成的类

 

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

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

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

创建动态类的实例对象

用反射获得构造方法

编写一个最简单的InvocationHandler类

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

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

将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

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

三个方面：

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

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

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

用Proxy.newInstance方法直接一步就创建出代理对象。

 

猜想分析动态生成的类的内部代码

 

动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

构造方法接受一个InvocationHandler对象，接受对象了要干什么用呢？该方法内部的代码会是怎样的呢？

实现Collection接口的动态类中的各个方法的代码又是怎样的呢？InvocationHandler接口中定义的invoke方法接受的三个参数又是什么意思？图解说明如下：

 

Client程序调用objProxy.add(“abc”)方法时，涉及三要素：objProxy对象、add方法、“abc”参数

 

Class Proxy$ {

 add(Object object) {

return handler.invoke(Object proxy, Methodmethod, Object[] args);

 }

}

 

分析先前打印动态类的实例对象时，结果为什么会是null呢？调用有基本类型返回值的方法时为什么会出现NullPointerException异常？

分析为什么动态类的实例对象的getClass()方法返回了正确结果呢？

调用调用代理对象的从Object类继承的hashCode, equals, 或toString这几个方法时，代理对象将调用请求转发给InvocationHandler对象，对于其他方法，则不转发调用请求。

 

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

 

分析动态代理的工作原理图（见下页）

怎样将目标类传进去？

直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！

为bind方法增加一个Advice参数。

 

动态代理的工作原理图

 

 

实现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获取对象

 

传统线程机制的回顾

 

创建线程的两种传统方式

在Thread子类覆盖的run方法中编写运行代码

涉及一个以往知识点：能否在run方法声明上抛出InterruptedException异常，以便省略run方法内部对Thread.sleep()语句的try…catch处理？

在传递给Thread对象的Runnable对象的run方法中编写代码

总结：查看Thread类的run()方法的源代码，可以看到其实这两种方式都是在调用Thread对象的run方法，如果Thread类的run方法没有被覆盖，并且为该Thread对象设置了一个Runnable对象，该run方法会调用Runnable对象的run方法。

问题：如果在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，那么，线程运行时的执行代码是子类的run方法的代码？还是Runnable对象的run方法的代码？

涉及到的一个以往知识点：匿名内部类对象的构造方法如何调用父类的非默认构造方法。

多线程机制会提高程序的运行效率吗？为什么会有多线程下载呢？

定时器的应用

Timer类

TimerTask类

 

线程的同步互斥与通信

 

使用synchronized代码块及其原理

使用synchronized方法

分析静态方法所使用的同步监视器对象是什么？

wait与notify实现线程间的通信

 

线程的同步互斥的图文解说

 

多个线程访问共享对象和数据的方式

 

如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。

如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：

将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。

上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信。

极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。

 

 

ThreadLocal实现线程范围的共享变量

 

见下页的示意图和辅助代码解释ThreadLocal的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。

每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

ThreadLocal的应用场景：

订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。

银行转账包含一系列操作： 把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。

例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在哪个模块中getContext方法，拿到的都是同一个。

实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。

实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。

对基本类型的数据的封装，这种应用相对很少见。

对对象类型的数据的封装，比较常见，即让某个类针对不同线程分别创建一个独立的实例对象。

总结：一个ThreadLocal代表一个变量，故其中里只能放一个数据，你有两个变量都要线程范围内共享，则要定义两个ThreadLocal对象。如果有一个百个变量要线程共享呢？那请先定义一个对象来装这一百个变量，然后在ThreadLocal中存储这一个对象。

 

Java5中的线程并发库

 

看java.util.concurrent包及子包的API帮助文档

看concurrent包的帮助文档页面，对并发库中涉及的内容有一个总体上的介绍

了解java.util.concurrent.atomic包

查看atomic包文档页下面的介绍

通过如下两个方法快速理解atomic包的意义：

AtomicInteger类的boolean compareAndSet(expectedValue, updateValue);

AtomicIntegerArray类的int addAndGet(int i, int delta);

顺带解释volatile类型的作用，需要查看java语言规范。

了解java.util.concurrent.lock包

在下页通过案例详细讲解

 

线程池

 

线程池的概念与Executors类的应用

创建固定大小的线程池

创建缓存线程池

创建单一线程池

关闭线程池

shutdown与shutdownNow的比较

用线程池启动定时器

调用ScheduledExecutorService的schedule方法，返回的ScheduleFuture对象可以取消任务。

支持间隔重复任务的定时方式，不直接支持绝对定时方式，需要转换成相对时间方式。

 

Callable&Future

 

Future取得的结果类型和Callable返回的结果类型必须一致，这是通过泛型来实现的。

Callable要采用ExecutorSevice的submit方法提交，返回的future对象可以取消任务。

CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象。

好比我同时种了几块地的麦子，然后就等待收割。收割时，则是哪块先成熟了，则先去收割哪块麦子。

 

Lock&Condition实现线程同步通信

 

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

在等待 Condition 时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为 Condition 应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例，从中除了要体味算法，还要体味面向对象的封装。在传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。（如果只用一个Condition，两个放的都在等，一旦一个放的进去了，那么它通知可能会导致另一个放接着往下走。）

 

Semaphore实现信号灯

 

Semaphore可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。

Semaphore实现的功能就类似厕所有5个坑，假如有十个人要上厕所，那么同时能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中的任何一个人让开后，其中在等待的另外5个人中又有一个可以占用了。

另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。

单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

 

其他同步工具类

 

CyclicBarrier

表示大家彼此等待，大家集合好后才开始出发，分散活动后又在指定地点集合碰面，这就好比整个公司的人员利用周末时间集体郊游一样，先各自从家出发到公司集合后，再同时出发到公园游玩，在指定地点集合后再同时开始就餐，…。

CountDownLatch

犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。这直接通过代码来说明CountDownLatch的作用，这样学员的理解效果更直接。

可以实现一个人（也可以是多个人）等待其他所有人都来通知他，可以实现一个人通知多个人的效果，类似裁判一声口令，运动员同时开始奔跑，或者所有运动员都跑到终点后裁判才可以公布结果，用这个功能做百米赛跑的游戏程序不错哦！还可以实现一个计划需要多个领导都签字后才能继续向下实施的情况。

Exchanger

用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据。

 

可阻塞的队列

 

什么是可阻塞队列，阻塞队列的作用与实际应用，阻塞队列的实现原理。

阻塞队列与Semaphore有些相似，但也不同，阻塞队列是一方存放数据，另一方释放数据，Semaphore通常则是由同一方设置和释放信号量。

ArrayBlockingQueue

只有put方法和take方法才具有阻塞功能

用3个空间的队列来演示阻塞队列的功能和效果。

用两个具有1个空间的队列来实现同步通知的功能。

 

同步集合

 

传统集合类在并发访问时的问题说明，见附件

传统方式下用Collections工具类提供的synchronizedCollection方法来获得同步集合，分析该方法的实现源码。

传统方式下的Collection在迭代集合时，不允许对集合进行修改。

用空中网面试的同步级线程题进行演示

根据AbstractList的checkForComodification方法的源码，分析产生ConcurrentModificationException异常的原因。

Java5中提供了如下一些同步集合类：

通过看java.util.concurrent包下的介绍可以知道有哪些并发集合

ConcurrentHashMap

CopyOnWriteArrayList

CopyOnWriteArraySet

 

示例：

 

Java代码 

package cn.itcast.day3;

 

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 {

 

/**

* @param args

*/

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

// TODO Auto-generated method stub

Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);

System.out.println(clazzProxy1.getName());

 

System.out.println("----------beginconstructors 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 methodslist----------");

/*$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());

}

 

System.out.println("----------begincreate instance object----------");

//Object obj = clazzProxy1.newInstance();

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

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();

//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());

System.out.println(proxy3.getClass().getName());

}

 

private static ObjectgetProxy(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;

}

 

}

Java代码  

package cn.itcast.day3;

 

import java.lang.reflect.Method;

 

public interface Advice {

void beforeMethod(Method method);

void afterMethod(Method method);

}

Java代码 

package cn.itcast.day3;

 

import java.lang.reflect.Method;

 

public class MyAdvice implements Advice{

long beginTime = 0;

public void afterMethod(Methodmethod) {

// 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(Methodmethod) {

// TODO Auto-generated method stub

System.out.println("到传智播客来学习啦！");

beginTime = System.currentTimeMillis();

}

 

}

Java代码 

package cn.itcast.day3.aopframework;

 

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) {

// TODO Auto-generated catch block

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) {

// TODO Auto-generated catch block

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) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return proxy;

}

return bean;

}

}

Java代码 

package cn.itcast.day3.aopframework;

 

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(Adviceadvice) {

this.advice = advice;

}

 

public Object getTarget() {

return target;

}

 

public void setTarget(Objecttarget) {

this.target = target;

}

 

public Object getProxy() {

// TODO Auto-generated method stub

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;

}

 

}

Java代码 

package cn.itcast.day3.aopframework;

 

import java.io.InputStream;

import java.util.Collection;

 

public class AopFrameworkTest {

 

/**

* @param args

*/

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

// TODO Auto-generated method stub

InputStream ips =AopFrameworkTest.class.getResourceAsStream("config.properties");

Object bean = new BeanFactory(ips).getBean("xxx");

System.out.println(bean.getClass().getName());

((Collection)bean).clear();

}

 

}