12.、JAVA基础&高新技术

最新推荐文章于 2024-10-09 11:13:12 发布

码到功成技术汇

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量897

点赞数

文章标签： java string object class 编译器 eclipse

本文链接：https://blog.csdn.net/chenxingsheng_heima/article/details/7539895

版权

12.、JAVA基础&高新技术

1、eclipse的使用技巧

IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程，一般来说一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件，资源文件等用一个工程进行管理。（在这里可以看看以前工作间中的某个工程的结构），在不使用工程管理的情况下，如果一个项目中包括多个Java源文件，编程人员需要精心维护这些源文件之间、以及源文件与其它文件的目录关系，需要逐一编译这些源文件，需要手工启动运行编译后的结果。如果将一个程序的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件的位置和相互关系。工程中有哪几个源文件、启动类是哪个、启动参数设置等配置信息在工程中都记录。

一个workspace可以包含多个project，一个workspace保留了eclipse的一套环境选项的配置，例如，所使用的javac和java命令，等等，细节请查看window->preferences。如果要为eclispe再配置一套环境选项，可以再创建一个workspace。Package explorer视图窗口中的filters菜单项，可以显示空的父包（此功能默认是关闭的）。

2.eclipse配置技巧：

一个Perspective代表了若干个view的集合，如何显示各种view。

设置单个工程的javac和java，选择工程，右键->properties可以设置javac，右键->run asàopen run dialog可以设置java。

    先用新的工作间，然后创建新工程，默认的语言即为5.0。先使用Integer  x = 3;调整编译器的语法版本为1.4，看到eclipse窗口报错了。然后将这个工程的语言设置为6.0，马上又看到bad version .class运行错误了，这是因为myeclise自带的java为1.5 。然后再将整个工作间的javac设置为6.0（eclipse自带的是jdk1.5），然后看新建工程的javac，也随之改成了6.0，运行则又报bad version .class错误。将工程的编译语言再单独改为5.0，运行则没了问题。整个工作间的语言设置为6.0后，再将整个工作间的java也设置为自己安装的java6。

5.快捷键使用技巧：

快捷键的位置：General->keys，设置alt+/键进行内容提示时，要注意解除alt+/键原来的绑定关系，直接输入alt+/就可以找到它的绑定关系，删除绑定关系时也可以使用remove binding这个按钮，课后必须教会大家在eclipse中。代码模板的设置位置：java->editor->Templates

画一个Editorà（.java）àCompileàRun的过程图，讲课会更加直观和形象了，也更有利于建立一种配置eclipse的感觉。

2、静态导入：

import语句可以导入一个类或某个包中的所有类

import static语句导入一个类中的某个静态方法或所有静态方法

语法举例：

import static java.lang.Math.sin;

import static java.lang.Math.*;

4、可变参数

一个方法接受的参数个数不固定，例如：

System.out.println(countScore(2,3,5));

System.out.println(countScore(1,2,3,5));

可变参数的特点：

只能出现在参数列表的最后；这个要记住

...位于变量类型和变量名之间，前后有无空格都可以;

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

举例代码：

public static void main(String[] args) {

System.out.println(add(1,2,3,5));

System.out.println(add(2,3,5));

}

public static int add(int x,int ...args) {

int sum = x;

for(int i=0;i<args.length;i++) {

sum += args[i];

}

return sum;

}

5、增强For循环

语法：

for ( type 变量名：集合变量名 )  { … }

注意事项：

迭代变量必须在( )中定义！

集合变量可以是数组或实现了Iterable接口的集合类

举例：

public static int add(int x,int ...args) {

int sum = x;

for(int arg:args) {

sum += arg;

}

return sum;

}

6、基本数据类型的自动拆箱与装箱

自动装箱：

Integer num1 = 12;

自动拆箱：

System.out.println(num1 + 12);

基本数据类型的对象缓存：

Integer num1 = 12;

Integer num2 = 12; 这块相等，<=127都是真的

System.out.println(num1 == num2);

Integer num3 = 129;                这块不相等，因为是对象

Integer num4 = 129;

System.out.println(num3 == num4);

Integer num5 = Integer.valueOf(12);

Integer num6 = Integer.valueOf(12)  ;   这块的道理同上

System.out.println(num5 == num6);

7、枚举

1、为什么要有枚举

问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段2、无法实现这一目标。

用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。

私有的构造方法

每个元素分别用一个公有的静态成员变量表示

可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。

3、枚举的基本应用

举例：定义一个Weekday的枚举。

扩展：枚举类的values,valueOf,name,toString,ordinal等方法（记住，讲课时要先于自定义方法前介绍，讲课更流畅）

总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象，例如可以调用WeekDay.SUN.getClass().getName和WeekDay.class.getName()。

枚举类的实例对象个数是有限的，就是那些成员，可以在枚举类的构造方法中加入监控语句，看到这几个实例对象被创建出来的过程。

如果想在一个类中编写完各个枚举类和测试调用类，那么可以将枚举类定义成调用类的内部类。

4、枚举的高级应用

枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

带构造方法的枚举

构造方法必须定义成私有的

如果有多个构造方法，该如何选择哪个构造方法？

枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

带方法的枚举

定义枚举TrafficLamp

实现普通的next方法

实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。

增加上表示时间的构造方法

枚举只有一个成员时，就可以作为一种单例的实现方式。

8、反射的基石àClass类

对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？

人àPerson

Java类àClass

Class类代表Java类，它的各个实例对象又分别对应什么呢？

对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

如何得到各个字节码对应的实例对象（ Class类型）

类名.class，例如，System.class

对象.getClass()，例如，new Date().getClass()

Class.forName("类名")，例如，Class.forName("java.util.Date");

九个预定义Class实例对象：

参看Class.isPrimitive方法的帮助

Int.class == Integer.TYPE

数组类型的Class实例对象

Class.isArray()

9.反射概述

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

1、Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：

例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：

例子：     Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

//获得方法时要用到类型

创建实例对象：

通常方式：String str = new String(new StringBuffer("abc"));

反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));

//调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：

例子：String obj = (String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

2、Field类代表某个类中的一个成员变量

演示用eclipse自动生成Java类的构造方法

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。

示例代码：

ReflectPoint point = new ReflectPoint(1,7);

Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");

System.out.println(y.get(point));

//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");

Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");

x.setAccessible(true);

System.out.println(x.get(point));

3、Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：     Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式： System.out.println(charAt.invoke(str, 1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)

Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

代码举例：

定义一个person

public class Person {

public String name;

private int age;

public Person(){

System.out.println("person  run");

}

public Person(String name){

System.out.println("hahahahah");

this.name = name;

}

public void show(){

System.out.println("person show run...");

}

public static void staticShow(){

System.out.println("person static show run");

}

public void paramShow(String name,int age){

System.out.println("person paramshow run....."+name+":"+age);

}

private void privateShow(){

System.out.println("person private show");

}

}

public class ReflectDemo {

/**

* @param args

* @throws ClassNotFoundException

*/

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

/*

* 获取字节码文件对象的三种方式：

* 1，通过Object中的getClass方法获取。

* 这种方式：必须要创建指定类的对象，再用该对象调用getClass()方法来完成获取。

*

* 2，通过每一个具体数据类型的具备的class静态属性就可以完成该类型的Class对象的获取

* 这种方式：必须要明确具体的类型，比如Person 。

*

* 3，使用Class类中的方法。forName就可以完成Class对象的获取。

*  这种方式：不需要知道具体类型，只要知道名字，就会根据名称去加载指定的类文件。

*  这样更为方便扩展性更强。

*/

getClassObject_3();

}

public static void getClassObject_3() throws ClassNotFoundException {

Class clazz = Class.forName("cn.itcast.c.bean.Person");//注意：必须写类的全名称：包名.类名

System.out.println(clazz);

}

public static void getClassObject_2() {

// 2，通过每一个具体数据类型的具备的class静态属性就可以完成该类型的Class对象的获取

Class c = Person.class;

Class c1 = int.class;

}

public static void getClassObject_1(){

// 1，通过Object中的getClass方法获取。

// Person p = new Person();

// Class c1 = p.getClass();

// Person pp = new Person();

// Class c2 = pp.getClass();

// System.out.println(c1==c2);//

}

}

public class ReflectDemo2 {

private static  String person_string = "cn.itcast.c.bean.Person";

/**

* @param args

* @throws Exception

*/

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

getPrivateFieldDemo();

}

/*

* 获取私有字段。

*/

private static void getPrivateFieldDemo() throws Exception {

Class clazz = Class.forName(person_string);

Field field = clazz.getDeclaredField("age");

// System.out.println(field);

Object obj = clazz.newInstance();

// 取消对权限的检查。暴力访问

field.setAccessible(true);

field.set(obj,68);

Object value = field.get(obj);

System.out.println("value="+value);

}

public static void getPublicFieldDemo() throws Exception {

Class clazz = Class.forName(person_string);

Field field = clazz.getField("name");

//获取字段值。但是对于非静态的字段必须要有所属的对象。

// 既然需要该类对象，就可以通过Class类中的newInstance方法来完成。该类实例的创建。

Object obj = clazz.newInstance();

//给指定字段赋值。

field.set(obj,"旺财");

Object value = field.get(obj);

System.out.println("value="+value);

}

/*

* 获取指定名称的字段。

*/

/*

* 获取指定的字节码文件中的属性。字段.

*/

public static void getFieldsDemo() throws ClassNotFoundException {

// 1,获取指定名称字节码文件对象。

Class clazz = Class.forName(person_string);

// 2,通过该字节码文件对象的方法获取字节码文件中的字段

Field[] fields = clazz.getFields();

fields = clazz.getDeclaredFields();

for(Field field : fields){

System.out.println(field);

}

}

}

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

public class ReflectDemo3 {

private static  String person_string = "cn.itcast.c.bean.Person";

/**

* @param args

* @throws Exception

*/

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

getConsDemo();

}

/*

* 获取类中的构造函数，来对指定类进行对象的初始化。

*/

public static void getConsDemo() throws Exception{

Class clazz = Class.forName(person_string);

// Object obj = clazz.newInstance();    //这是无参的获取方法

/*

* 为了通过指定构造器创建该类对象，就需要先获取指定的构造器。

*/

Constructor cons = clazz.getConstructor(String.class);

Object obj  = cons.newInstance("小强");

Field field = clazz.getField("name");

Object value = field.get(obj);

System.out.println("value="+value);

}

}

public class ReflectDemo4 {

private static  String person_string = "cn.itcast.c.bean.Person";

/**

* @param args

* @throws Exception

*/

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

getPrivateMethodDemo();

}

/*

* 获取一个私有方法。

*/

public static void getPrivateMethodDemo() throws Exception{

Class clazz = Class.forName(person_string);

Method method = clazz.getDeclaredMethod("privateShow", null);

Object obj = clazz.newInstance();

method.setAccessible(true);

method.invoke(obj, null);

}

/*

* 获取一个静态方法。

*/

public static void getStaticMethodDemo() throws Exception{

Class clazz = Class.forName(person_string);

Method method = clazz.getMethod("staticShow",null);

method.invoke(null, null);

}

/*

* 获取一个带参数的方法

*/

public static void getParamMethodDemo() throws Exception{

Class clazz = Class.forName(person_string);

Method method = clazz.getMethod("paramShow", String.class,int.class);

Object obj = clazz.newInstance();

method.invoke(obj, "小明",89);

}

/*

* 获取指定方法。无参数。

*/

public static void getMethodDemo() throws Exception{

Class clazz = Class.forName(person_string);

Method method = clazz.getMethod("show", null);

Object obj = clazz.newInstance();

method.invoke(obj, null);

}

/*

* 获取指定类中的所有方法。

*/

public static void getMethodsDemo() throws Exception{

Class clazz = Class.forName(person_string);

Method[] methods = clazz.getMethods();

methods = clazz.getDeclaredMethods();

for(Method method : methods){

System.out.println(method);

}

}

}

10、用反射方式执行某个类中的main方法

目标：

写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？

问题：

启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});

mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

我给你的数组，你不会当作参数，而是把其中的内容当作参数。

Class clazz = Class.forName(arg[0]);

Method mMain = clazz.getMethod("main", String[].class);

mMain.invoke(null,new Object[]{new String[]{"aaa","bbb"}});

mMain.invoke(null,(Object)new String[]{"aaa","bbb"});

class TestArrayArguments {

public static void main(String [] args)

{

for(String arg:args)

{

System.out.println("----------" + arg + "----------");

}

}

}

11、数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作。

思考题：怎么得到数组中的元素类型？

Object[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。

main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)

1.

看Class类帮助文档开始部分的介绍。

String[] a1 = new String[8];

String[] a2 = new String[9];

String[][] a3 = new String[6][4];

().getName());

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

System.out.println(a1.getClass() == a2.getClass());

System.out.println(a1.getClass() == a3.getClass());

2.

看getSuperClass方法的帮助

System.out.println(a1.getClass().getSuperclass().getName());

3.

int[] a = new int[3];

Object obj = a;

//Object[] obj1 = a //有错！

Object[] obj3 = a1

Object obj4 = a3;

if(obj4 instanceof String[][]){

System.out.println(obj1.getClass().isArray());

}

**在这里分析研究Arrays.asList()方法处理int[]和String[]时的差异，以及Arrays.deepToString()方法不能处理int[]，但能处理String[]的原因。

4.

private static void printObject(Object obj) {

if(obj.getClass().isArray()){

int len = Array.getLength(obj);

for(int i=0;i<len;i++) {

System.out.println(Array.get(obj, i));

}

} else {

System.out.println(obj);

}

}

5.bject[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成new String[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x = “abc”。

main.invoke(null, (Object)(new Object[]{“aaa”,“xxx”}));不能调用public static void main(String [] args)

1.

看Class类帮助文档开始部分的介绍。

String[] a1 = new String[8];

String[] a2 = new String[9];

String[][] a3 = new String[6][4];

().getName());

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

System.out.println(a1.getClass() == a2.getClass());

System.out.println(a1.getClass() == a3.getClass());

2.

看getSuperClass方法的帮助

System.out.println(a1.getClass().getSuperclass().getName());

3.

int[] a = new int[3];

Object obj = a;

//Object[] obj1 = a //有错！

Object[] obj3 = a1

Object obj4 = a3;

if(obj4 instanceof String[][]){

System.out.println(obj1.getClass().isArray());

}

**在这里分析研究Arrays.asList()方法处理int[]和String[]时的差异，以及Arrays.deepToString()方法不能处理int[]，但能处理String[]的原因。

4.

private static void printObject(Object obj) {

if(obj.getClass().isArray()){

int len = Array.getLength(obj);

for(int i=0;i<len;i++) {

System.out.println(Array.get(obj, i));

}

} else {

System.out.println(obj);

}

}

5.

需要取出每个元素对象，然后再对各个对象进行判断，因为其中每个具体元素的类型都可以不同，例如Object[] x = new Object[]{“abc”,Integer.Max}。

需要取出每个元素对象，然后再对各个对象进行判断，因为其中每个具体元素的类型都可以不同，例如Object[] x = new Object[]{“abc”,Integer.Max}。

12、反射的作用à实现框架功能

框架与框架要解决的核心问题

我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？

因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

综合案例

先直接用new  语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。

然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。

引入了elipse对资源文件的管理方式的讲解。

13、内省à了解JavaBean

JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，大家觉得这些方法的名称叫什么好呢？JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。

setId()的属性名àid

isLast()的属性名àlast

setCPU的属性名是什么?àCPU

getUPS的属性名是什么？àUPS

总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。

一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！好处如下：

在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！

14、注解介绍及属性

什么是注解的属性

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是培训的学生，否则，就不是。如果还想区分出是培训哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")

定义基本类型的属性和应用属性：

在注解类中增加String color();

@MyAnnotation(color="red")

用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

MyAnnotation a = (MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);

System.out.println(a.color());

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象

为属性指定缺省值：

String color() default "yellow";

value属性：

String value() default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。

代码示例：

首先是简单介绍三种普通注解@Deprecated，@SuppressWarnings，@Override的使用。

ANNOTAON_TYPE
          注释类型声明
CONSTRUCTOR
          构造方法声明
FIELD
          字段声明（包括枚举常量）
LOCAL_VARIABLE
          局部变量声明
METHOD
          方法声明
PACKAGE
          包声明
PARAMETER
          参数声明
TYPE


然后是自定义注解，在注解中增加各种属性，其中value属性比较特殊，可以直接写数值。注解还可以加注解，比如用来定义注解作用是什么时期（class时期，运行时期，还是编译时期），还可以定义注解可以放在什么地方（是类上，方法上，还是包上等），有下面几种地方

定义注解如下：
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import part01.EnumTest;

//注解的注解，元注解
//注意RetentionPolicy.RUNTIME,RetentionPolicy.SOURCE,RetentionPolicy.CLASS区别。
@Target({ElementType.METHOD,ElementType.TYPE})//ElementType是枚举enum类型,表示注解可以加在那些地方。
@Retention(RetentionPolicy.RUNTIME)//比如RetentionPolicy.RUNTIME就是一个value属性值，只是此属性值是枚举类型。
public @interface PartAnnotation {
    String color() default "blue";
    //value属性很特殊，当没有其他属性，或者其他属性已经设置默认值之后，在使用注解，设定value属性值的时候，不需要写value=XXX，只需要写XXX。
    String value();
    int[] arrayAttr() default {2,8};
    EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;
    MetaAnnotation annotationAttr() default @MetaAnnotation("will");
    Class classAttr() default String.class;

}

使用注解的类，还可以判断是否带有某种注解，调用注解的各个属性，如下

import java.lang.annotation.Annotation;

@PartAnnotation(classAttr=Integer.class,annotationAttr=@MetaAnnotation("girl"),color="yellow",value="abc",arrayAttr={1,6})
public class AnnotationTest {
    /**
     * @param args
     */
    @PartAnnotation("abc")
    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.runFinalizersOnExit(true);
        //System.out.println(SuppressWarnings.class.getName());

        //检查注释PartAnnotation
        if(AnnotationTest.class.isAnnotationPresent(PartAnnotation.class)){
            PartAnnotation pa1=(PartAnnotation)AnnotationTest.class.getAnnotation(PartAnnotation.class);
            System.out.println(pa1);
            System.out.println(pa1.arrayAttr().length);
            System.out.println(pa1.lamp().nextLamp().name());
            System.out.println(pa1.annotationAttr().value());
            System.out.println(pa1.classAttr().getName());
        }
    }
    @Deprecated
    public static void sayHello() {
        System.out.println("hello java");
    }

}
15、泛型概述：

Jdk 1.5以前的集合类中存在什么问题

ArrayList collection = new ArrayList();

collection.add(1);

collection.add(1L);

collection.add("abc");

int i = (Integer) collection.get(1);//编译要强制类型转换且运行时出错！

Jdk 1.5的集合类希望你在定义集合时，明确表示你要向集合中装哪种类型的数据，无法加入指定类型以外的数据

ArrayList<Integer> collection2 = new ArrayList<Integer>();

collection2.add(1);

/*collection2.add(1L);

collection2.add(“abc”);*///这两行代码编译时就报告了语法错误

int i2 = collection2.get(0);//不需要再进行类型转换

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

ArrayList<Integer>中的<>念着typeof

ArrayList称为原始类型

参数化类型与原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？

原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，写了就是明知故犯

Vector<Object> v = new Vector<String>(); //也错误!

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

Vector<Integer> vectorList[] = new Vector<Integer>[10];

1、泛型中的通配符

问题：

定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？

错误方式：

public static void printCollection(Collection<Object> cols) {

for(Object obj:cols) {

System.out.println(obj);

}

/* cols.add("string");//没错

cols = new HashSet<Date>();//会报告错误！*/

}

正确方式：

public static void printCollection(Collection<?> cols) {

for(Object obj:cols) {

System.out.println(obj);

}

//cols.add("string");//错误，因为它不知自己未来匹配就一定是String

cols.size();//没错，此方法与类型参数没有关系

cols = new HashSet<Date>();

}

总结：

使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

2、泛型中的？通配符的扩展

限定通配符的上边界：

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界：

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();

提示：

限定通配符总是包括自己。

?只能用作引用，不能用它去给其他变量赋值

Vector<? extends Number> y = new Vector<Integer>();

Vector<Number> x = y;

上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，

只能通过强制类型转换方式来赋值。

4、泛型集合类的综合案例

能写出下面的代码即代表掌握了Java的泛型集合类：

HashMap<String,Integer> hm = new HashMap<String,Integer>();

  hm.put("zxx",19);

  hm.put("lis",18);



  Set<Map.Entry<String,Integer>> mes= hm.entrySet();

  for(Map.Entry<String,Integer> me : mes) {

   System.out.println(me.getKey() + ":" + me.getValue());

  }

5、类型参数的类型推断

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

swap(new String[3],3,4)   à    static <E> void swap(E[] a, int i, int j)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

add(3,5)   à static <T> T add(T a, T b)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

fill(new Integer[3],3.5f)   à static <T> void fill(T[] a, T v)

当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

int x =(3,3.5f)   à static <T> T add(T a, T b)

参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

copy(new Integer[5],new String[5]) à static <T> void copy(T[] a,T[]  b);

copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);

6、定义泛型类型

如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

public class GenericDao<T> {

private T field1;

public void save(T obj){}

public T getById(int id){}

}

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;

new genericDao<String>();

注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

7\通过反射获得泛型的参数化类型

示例代码：

Class GenericalReflection {

  private Vector<Date> dates = new Vector<Date>();

  public void setDates(Vector<Date> dates) {

    this.dates = dates;

  }

  public static void main(String[] args) {

   Method methodApply = GenericalReflection.class.getDeclaredMethod("applyGeneric", Vector.class);

   ParameterizedType pType = (ParameterizedType)

                    (methodApply .getGenericParameterTypes())[0];

            System.out.println("setDates("

                    + ((Class) pType.getRawType()).getName() + "<"

                    + ((Class) (pType.getActualTypeArguments()[0])).getName()

                    + ">)" );

  }

}

泛型DAO的应用：

public abstract class DaoBaseImpl<T> implements DaoBase<T> {

protected Class<T> clazz;

public DaoBaseImpl() {

Type type = this.getClass().getGenericSuperclass();

ParameterizedType pt = (ParameterizedType) type;

this.clazz = (Class) pt.getActualTypeArguments()[0];

System.out.println("clazz = " + this.clazz);

}

}

public class ArticleDaoImpl extends DaoBaseImpl<Article> implements ArticleDao {

}

16、类加载器

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

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

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

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

17 类加载器之间的父子关系和管辖范围图

18\类加载器的委托机制

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

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

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

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

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

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

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

19编写自己的类加载器

知识讲解：

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

loadClass方法与findClass方法

defineClass方法

编程步骤：

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

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

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

实验步骤：

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

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

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

删除CLASSPATH环境下的类文件，再执行上一

20 类加载器的高级问题分析

编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。

把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。

把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader 。

父级类加载器加载的类无法引用只能被子级类加载器加载的类，原理如下图：

21、代理的概念与作用

生活中的代理

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

程序中的代理

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

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

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

AOP

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

                              安全       事务         日志

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

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

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

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

method1         method2          method3

{                      {                       {

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

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

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

}                       }                       }

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

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

func1         func2            func3

{             {                {

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

}             }                }

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

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

22 、动态代理技术

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

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

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

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

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

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

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

23\分析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, Method method, Object[] args);

}

}

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

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

怎样将目标类传进去？

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

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

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

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

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

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

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

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

接口

import java.lang.reflect.Method;

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

}

传入的对象

import java.lang.reflect.Method;

public class MyAdvice implements Advice {

    long beginTime=0;
    @Override
    public void beforeMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("好好学习");
        beginTime=System.currentTimeMillis();

    }

    @Override
    public void afterMethod(Method method) {
        // TODO Auto-generated method stub
        System.out.println("天天向上");
        long endTime=System.currentTimeMillis();
        System.out.println(method.getName() + ":runing time of"    + (beginTime - endTime));

    }

}

自定义代理类的过程

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.util.Iterator;

public class ProxyTest {
    /**
     * @param args
     * @throws Exception
     */
    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("---------------");
        Constructor[] constructors=clazzProxy1.getConstructors();
        for (Constructor con : constructors) {
            String name=con.getName();
            StringBuilder sb=new StringBuilder(name);
            sb.append('(');
            Class[] clazzParams=con.getParameterTypes();
            for (Class clazzParam : clazzParams) {
                sb.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null&&clazzParams.length!=0)
                sb.deleteCharAt(sb.length()-1);
            sb.append(')');
            System.out.println(sb.toString());
        }

        System.out.println("---------------");

        Method[] methods=clazzProxy1.getMethods();
        for (Method meth : methods) {
            String name=meth.getName();
            StringBuilder sb=new StringBuilder(name);
            sb.append('(');
            Class[] clazzParams=meth.getParameterTypes();
            for (Class clazzParam : clazzParams) {
                sb.append(clazzParam.getName()).append(',');
            }
            if(clazzParams!=null&&clazzParams.length!=0)
                sb.deleteCharAt(sb.length()-1);
            sb.append(')');
            System.out.println(sb.toString());
        }

        System.out.println("---------------");

        //使用clazzProxy1类得到构造方法
        Constructor con2=clazzProxy1.getConstructor(InvocationHandler.class);

        //使用构造方法产生实例对象1
        class MyInvocationHandler1 implements InvocationHandler{
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // TODO Auto-generated method stub
                return null;
            }
        }
        Collection proxy1=(Collection) con2.newInstance(new MyInvocationHandler1());

        //使用构造方法产生实例对象2
        //使用匿名内部类
        Collection proxy2=(Collection) con2.newInstance(new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // TODO Auto-generated method stub
                return null;
            }
        });

        final ArrayList target=new ArrayList();
        //使用Proxy的静态方法来创建代理类实例对象，而且加入其他方法
        Collection proxy3 = (Collection) getProxy(target,new MyAdvice());
        proxy3.add("zhangsan");
        proxy3.add("lisi");
        proxy3.add("wangwu");
        System.out.println(proxy3.size());


    }

    private static Object getProxy(final Object target,final Advice advice) {
        Object proxy3=Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler(){
            @Override
            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() + ":runing time of"    + (beginTime - endTime));
                return retVal;*/

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

}

一个类似spring的可配置的AOP框架，来创建目标类或者代理类的实例对象并通过配置文件来实现切换

使用一个类来实现切换条件的定义，从配置文件得到字符串，通过流对象。

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import part03.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 rfb=(ProxyFactoryBean)bean;
            try {
                Advice advice=(Advice)Class.forName(props.getProperty(name+".advice")).newInstance();
                Object target=Class.forName(props.getProperty(name+".target")).newInstance();
                rfb.setAdvice(advice);
                rfb.setTarget(target);
                proxy=rfb.getProxy();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return proxy;
        }
        return bean;
    }

}

代理类的定义

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import part03.Advice;

public class ProxyFactoryBean {
    private Object target;
    private Advice advice;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Advice getAdvice() {
        return advice;
    }

    public void setAdvice(Advice advice) {
        this.advice = advice;
    }

    public Object getProxy() {
        // TODO Auto-generated method stub
        Object proxy3=Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler(){
                @Override
                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() + ":runing time of"    + (beginTime - endTime));
                    return retVal;*/

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

}

总的控制类如下

import java.io.InputStream;

public class AopFrameWorkTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 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());

    }

}