-------android培训、java培训、期待与您交流-------
01由内省IntroSpector引出JavaBean
IntroSpector：即内省，是对内部进行检查，了解更多的底层细节。
内省的作用：主要针对JavaBean进行操作。
JavaBean（存在于java.bean包中）
1）JavaBean是一种特殊的Java类，主要用于传递数据信息，这种Java类中的方法主要用于访问私有的字段，且方法都符合某种特殊的命名规则。
2）它是一种特殊的Java类，其中的方法名称等，都符合特殊的规则。只要一个类中含有get和set打头的方法，就可以将其当做JavaBean使用。
作用：
如果要在两个模板之间传递多个信息，可将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO），这些信息在类中用私有字段来储存，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。
命名方式：
JavaBean的属性是根据其中的setter和getter方法来确定的，而不是依据其中的变量，如方法名为setId，则中文意思是设置Id，getId也是如此；去掉前缀，剩余部分就是属性名称，如果剩余部分的第二个字母小写，则把剩余部分改为小写。如：getAge/setAge-->age；gettime-->time；setTime-->time；getCPU-->CPU。
总之、一个类被当做JavaBean使用时，JavaBaan的属性是根据方法名推断出来的，它根本看不到Java类内部的成员变量。
JavaBean的好处：
一个符合JavaBean特点的类当做普通类一样可以使用，但是把它当做JavaBean类用肯定有好处的：
1）在JavaEE开发中，经常要使用JavaBean。很多环境就要求按JavaBean的方式进行操作，别人都这么用，那么就必须要求这么做。
2）JDK中提供了对JavaBean进行操作的API，这套API称为内省，若要自己通过getX的方式来访问私有x，可用内省这套API，操作JavaBean要比使用普通的方式更方便。
public static void main(String[] args) throws Exception {
ReflectPoint pt1 = new ReflectPoint(3,5);
String propertyName = "x";
PropertyDescriptor pd = //内省的方式 属性描述符：PropertyDescriptor get属性信息
new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = pd.getReadMethod();
Object retVal = methodGetX.invoke(pt1);
System.out.println(retVal);
Object value = 7;
PropertyDescriptor pd2 = //set属性信息
new PropertyDescriptor(propertyName,pt1.getClass());
Method methodSetX = pd2.getWriteMethod();
methodSetX.invoke(pt1,value);
System.out.println(pt1.getX());
}
//上面的get或set代码分别通过选中要重构的代码，通过右击选重构获得get和set方法：
public static void main(String[] args) throws Exception {
ReflectPoint pt1 = new ReflectPoint(3,5);
String propertyName = "x";
Object retVal = getProperty(pt1, propertyName); //内省方式: 通过get和set方法获取属性值
System.out.println(retVal);
Object value = 7;
setProperty(pt1, propertyName, value);
System.out.println(pt1.getX());
}
private static void setProperty(Object rf, String propertyName, //设置属性值的方法此处的类型为Object
Object value) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
PropertyDescriptor pd = //创建属性描述符对象，将属性名称和加载文件等信息写入其中
new PropertyDescriptor(propertyName,rf.getClass());
Method methodSetX = pd.getWriteMethod(); //通过反射的方法类Method，获取属性所对应的set方法
methodSetX.invoke(rf, value);
}
private static Object getProperty(Object rf, String propertyName) //获取属性值的方法
throws IntrospectionException, IllegalAccessException,
InvocationTargetException { //创建属性描述符对象，获取属性所对应的名称和加载文件等信息
PropertyDescriptor pd =
new PropertyDescriptor(propertyName,rf.getClass());
Method methodGetX = pd.getReadMethod(); //通过反射的方法类Method，获取属性所对应的get方法
Object retVal = methodGetX.invoke(rf);
return retVal;
}
} 02对JavaBean的复杂内省操作
1、在IntroSpector类中有getBeanInfo(Class cls)的方法。
2、获取Class对象的Bean信息，返回的是BeanInfo类型。
3、BeanInfo类中有getPropertyDescriptors()的方法，可获取所有的BeanInfo的属性信息，返回一个PropertyDescriptor[]。
4、在通过遍历的形式，找出与自己想要的那个属性信息。
03BeanUtils工具包
1、BeanUtils等工具包都是有阿帕奇提供的，为了便于开发。
2、好处：
1）提供的set或get方法中，传入的是字符串，返回的还是字符串，因为在浏览器中，用户输入到文本框的都是以字符串的形式发送至服务器上的，所以操作的都是字符串。也就是说这个工具包的内部有自动将整数转换为字符串的操作。
2）支持属性的级联操作，即支持属性链。如可以设置：人的脑袋上的眼镜的眼珠的颜色。这种级联属性的属性连如果自己用反射，那就很困难了，通过这个工具包就可以轻松调用。
3、可以和Map集合进行相互转换：可将属性信息通过键值对的形式作为Map集合存储（通过staticjava.util.Map describe(java.lang.Object bean)的方法），也可以将Map集合转换为JavaBean中的属性信息（通过static voidpopulate(java.lang.Object bean, java.util.Map properties)的方法）
假定有个birthday的私有属性
private Date birthday = new Date();
set方法：
BeanUtils.setProperty(pt1”birthday.time”,”111”)
get方法：
String value = BeanUtils.getProperty(pt1,”x”)
1）BeanUtils是以字符串的形式进行操作的
2）PropertyUtils是以传入值本身的类型进行操作的。
04了解和入门注解应用
概述
1、注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则没有某种标记。
2、以后，java编译器、开发工具和其他应用程序就可以用反射来了解自己的类及各种元素上有无何种标记，有什么标记，就会做出相应的处理。
3、标记可以加在包、类、字段、方法、方法参数，以及局部变量上等等。
4、在java.lang包中提供了最基本的annotation，即注解。
5、格式：@注解类名()。
如果有属性，则在括号中加上属性名（可省略）和属性值。
java中三种最基本的注解
1、@SuppressWarning(”deprecation”)--->压制警告
SupressWarning 是告知编译器或开发工具等提示指定的编译器警告；
”deprecation”是告知具体的信息即方法已过时。
2、@Deprecated--->提示成员等已经过时，不再推荐使用。
源代码标记@Deprecated是在JDK1.5中作为内置的annotation引入的，用于表明类(class)、方法(method)、字段(field)已经不再推荐使用，并且在以后的JDK版本中可能将其删除，编译器在默认情况下检测到有此标记的时候会提示警告信息。
例如：假定之前的某个类升级了，其中的某个方法已经过时了，不能够将过时的方法删除，因为可能会影响到调用此类的这个方法的某些程序，这时就可以通过在方法上加这个注解。
3、@Override--->提示覆盖（父类方法）
加上此注解，，可对自己类中的方法判断是否是要覆盖的父类的方法，典型的例子即在集合中覆盖equals(Object obj)方法，其中的参数类型必须是Object，才能被覆盖，若不是，加上此注解就会提示警告。
05注解的定义与反射调用
1、定义格式：@interface 名称{statement}
2、元注解（注解的注解）
一个注解有其生命周期（Retetion）和存放的位置（Taget），这就可以通过元注解说明。
1）Retetion：用于说明注解保留在哪个时期，加载定义的注解之上。
一个注解的生命周期包含：
java源程序--(javac)-->class文件--(类加载器)-->内存中的字节码
第一、当在源程序上加了注解，javac将java源程序编译为class文件，可能会把源程序中的一些注解去掉，进行相应的处理操作，当我们拿到源程序的时候，就看不到这些注解了。
第二、假设javac把这些注解留在了源程序中（或者说留在了class文件中），当运行此class文件的时候，用类加载器将class文件调入内存中，此时有转换的过程，即把class文件中的注解是否保留下来也不一定。
注意：class文件中不是字节码，只有把class文件中的内部加载进内存，用类加载器加载处理后（进行完整的检查等处理），最终得到的二进制内容才是字节码。
Reteton（枚举类）取值：
Retetion.Policy.SOURSE：java源文件时期，如@Overried和@SuppressWarning
Retetion.Policy.CLASS： class文件时期（默认阶段）
Retetion.Policy.RUNTIME：运行时期，如@Deprecated
2）Taget：用于说明注解存放在哪些成分上，默认值是任何元素
其值可设置为枚举类ElementType类中的任何一个，包括：包、字段、方法、方法参数、构造器、类等值。取值为：
PACKAGE(包声明)
FIELD(字段声明)
ANNOTATION_TYPE(注释类型声明)
CONSIRUCTOR(构造器声明)
METHOD(方法声明)
PARAMETER(参数声明)
TYPE(类、接口（包含注释类型）或枚举声明)
LOCAL_VARIABLE(局部变量声明)
注意：其中代表类的值是TYPE。因为class、enum、interface和@interface等都是属于Type的。不可用CLASS表示。
3、通过反射查看其它类中的注释：
过程：
第一、注解类：@interfaceA{}
第二、应用了“注释类”的类：@Aclass B{}
第三、对“应用注释类的类”进行反射操作的类：class{...}，操作如下：
B.class.isAnnotionPresent(A.class);//判断是否存在此注解类
A a = B.class.getAnnotation(a.class);//存在的话则得到这个注释类的对象
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface ItcastAnnotation {}
@ItcastAnnotation()
public class AnnotionTest {
@SuppressWarnings("deprecation") //表示压制警告的注解
@ItcastAnnotation()
public static void main(String[] args) {
System.runFinalizersOnExit(true);
//反射方式查看注解
if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){ //检查类上是否有注解
ItcastAnnotation annotation =
AnnotionTest.class.getAnnotation(ItcastAnnotation.class); //通过反射获取到注解
System.out.println(annotation);
}
} 06为注解增加基本属性
1、属性：
一个注解相当于一个胸牌，但仅通过胸牌还不足以区别带胸牌的两个人，这时就需要给胸牌增加一个属性来区分，如颜色等。
2、定义格式：同接口中的方法一样：String color();
定义缺省格式：Stringvalue() default ”ignal”;
3、应用：直接在注解的括号中添加自身的属性，如：
@ItcastAnnotation(color=”red”)
这个和上面的@SuppressWarnings("deprecation")是一样的，其中的"deprecation"就是属性值
1）当只有一个属性时，可直接传入属性值。如”red”
2）当含有其他属性值的时候，如果那个属性值是缺省的（default），也可以直接传入这个属性值。
为注解增加高级属性
1、可以为注解增加的高级属性的返回值类型有：
1）八种基本数据类型 2）String类型 3）Class类型
4）枚举类型 5）注解类型 6）前五种类型的数组
2、数组类型的属性：
定义：int[]arrayArr() default {7,8,9}; -->可不定义默认值
应用：@MyAnnotation(arrayArr={3,4,5}) --> 可重新赋值
注：若数组属性中只有一个元素（或重新赋值为一个元素），这时属性值部分可省略大括号。
3、枚举类型的属性：
假设定义了一个枚举类TraffLamp，它是EnumTest的内部类，其值是交通灯的三色。
定义：EnumTest.TrafficLamplamp();
应用：@MyAnnotation(lamp=EnumTestTrafficLamp.GREEN)
4、注解类型的属性：
假定有个注解类：MetaAnnotation，其中定义了一个属性：String value()
定义：MetaAnnotationannotation() default @MetaAnnotation(”xxx”);
应用：@MyAnnotation(annotation=@MetaAnnotation(”yyy”)) --> 可重新赋值
可认为上面的@MetaAnnotation是MyAnnotation类的一个实例对象，同样可以认为上面的@MetaAnnotation是MetaAnnotation类的一个实例对象，调用：
MetaAnnotation ma =MyAnnotation.annotation();
System.out.println(ma.value());
5、Class类型的属性：
定义：Class cls();
应用：@MyAnnotation(cls=ItcastAnnotion.class)
注：这里的.class必须是已定义的类，或是已有的字节码对象
6、基本数据类型的属性（以int为例）：
定义：int val()default 3; -->可不定义默认值
应用：@MyAnnotation(val=7) --> 可重新赋值
7、注解的详细语法可通过查看java语言规范了解即javaLanguage Specification
//自定义注解类
package cn.itcast.text2;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import cn.itcast.text1.EnumText;
@Retention(RetentionPolicy.RUNTIME) //将定义的注解的生命周期设置在运行时期
@Target({ElementType.TYPE,ElementType.METHOD}) //定义注解的放置位置
public @interface ItcastAnnotation { //自定义注解
String str(); //定义属性
int val() default 1;
int[] arr() default {2,3,4};
Class cls() default AnnotionTest.class;
EnumText.TrafficLamp lamp() default EnumText.TrafficLamp.YELLOW;
MetaAnnotation annotation() default @MetaAnnotation("sss");
}
package cn.itcast.text2;
import cn.itcast.text1.EnumText;
@ItcastAnnotation(annotation=@MetaAnnotation("anntation"), //测试注解类，用反射查看其属性
Lamp=EnumText.TrafficLamp.RED,
arr=7,val=5,str="String",
cls=ItcastAnnotation.class)
public class AnnotionTest {
@SuppressWarnings("deprecation") //表示压制警告的注解
@ItcastAnnotation(str = "yyy") //有缺省值可不用写缺省部分
public static void main(String[] args) {
if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){ //反射方式查看注解
//检查类上是否有注解
ItcastAnnotation annotation =
AnnotionTest.class.getAnnotation(ItcastAnnotation.class); //通过反射获取到注解
System.out.println(annotation); //打印查看属性值
System.out.println(annotation.str());
System.out.println(annotation.val());
System.out.println(annotation.arr().length);
System.out.println(annotation.cls().getName());
System.out.println(annotation.lamp().nextLamp());
System.out.println(annotation.annotation().value());
}
}
}
//定义枚举类，交通灯
package cn.itcast.text1;
public class EnumText {
public static void main(String[] args) {}
public enum TrafficLamp{ //定义交通灯
RED(30){ //定义3个元素，即此类的子类，覆写抽象方法
@Override
public TrafficLamp nextLamp() {return GREEN;}},
GREEN(45){
@Override
public TrafficLamp nextLamp() {return YELLOW;}},
YELLOW(5) {
@Override
public TrafficLamp nextLamp() {return RED;}};
private int time;
private TrafficLamp(int time){this.time = time;} //构造方法
public abstract TrafficLamp nextLamp(); //抽象方法，转为下个灯
}
} 07泛型的应用
泛型概述--->JDK1.5新特性
一、泛型的出现：
1、泛型是在JDK1.5以后出现的新特性。泛型是用于解决安全问题的，是一个安全机制。
2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的数据，无法加入指定类型以外的数据。
3、泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。
4、由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，如用反射得到集合，再调用add方法即可。
二、好处：
1、使用泛型集合，可将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象；这样就将运行时期出现的问题ClassCastException转移到了编译时期，方便与程序员解决问题，让运行时期问题减少，提高安全性。
2、当从集合中获取一个对象时，编译器也可知道这个对象的类型，不需要对对象进行强制转化，避免了强制转换的麻烦，这样更方便。
三、泛型格式：
通过<>来定义要操作的引用数据类型
如：TreeSet<String> -----> 来定义要存入集合中的元素指定为String类型
四、泛型定义中的术语：
如：ArrayList<E>类和ArrayList<Integer>
1、ArrayList<E>整个称为泛型类型
2、ArrayList<E>中的E称为类型变量或类型参数
3、整个ArrayList<Integer>称为参数化类型
4、ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
5、ArrayList<Integer>中的<>称为typeof
6、ArrayList称为原始类型
参数化：parametered，已经将参数变为实际类型的状态。
五、在使用java提供的对象时，何时写泛型？
通常在集合框架中很常见，只要见到<>就要定义泛型，其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
六、关于参数化类型的几点说明：
1、参数化类型与原始类型的兼容性
第一、参数化类型可引用一个原始类型的对象，编译只是报警告，能不能通过编译，是编译器说了算。
如：Collection<String> coll = new Date();
第二、原始类型可引用一个参数化类型的对象，编译报告警告
如：Collection coll = new Vector<String>();
原来的方法接受一个集合参数，新类型也要能传进去。
2、参数的类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Objec>();//错误的
不写Object没错，写了就是明知故犯
Vector<Objec> v = new Vector<String>();//错误的
3、在创建数组实例时，数组的元素不能使用参数化的类型
如：Vector<Integer> v[] = newVector<Integer>[10];//错误的
import java.lang.reflect.Constructor;
import java.util.*;
public class Generic {
public static void main(String[] args) throws Exception {
ArrayList<String> al = new ArrayList<String>();
al.add("25");
al.add("b");
System.out.println(al.get(1));
ArrayList<Integer> at = new ArrayList<Integer>();
at.add(23);
at.add(3);
System.out.println(at.get(1));
System.out.println((al.getClass() == at.getClass()+ //编译器生成的字节码会去掉泛型的类型信息
"-->" + at.getClass().getName()); //at.add("ab")-->报错，存储的应为Integer类型
at.getClass().getMethod("add",Object.class).invoke(at,"abcd"); //反射方式，由于编译器生成的字节码会去掉泛型的类型信息
at.getClass().getMethod("add",Object.class).invoke(at,5); //所以用反射可跳过编译器，存入任何类型
System.out.println("反射方式：" + at.get(3));
System.out.println("反射方式：" + at.get(4));
Constructor<String> cons = //反射方式获得new String(new StringBuffer("abc"));
String.class.getConstructor(StringBuffer.class);
String st = cons.newInstance(new StringBuffer("abc"));
System.out.println(st); 08 泛型的通配符
泛型中的通配符?
当传入的类型不确定时，可以使用通配符?
1、使用?通配符可引用其他各种类型化的类型，通配符的变量主要用作引用，也可调用与参数化无关的方法，但不能调用与参数化有关的方法。
2、可对通配符变量赋任意值：
如：Collection<?> coll ---> coll = newHashSet<Date>();
如：
public static void printObj(Collection<?> coll){
for(Object obj : coll){ //coll.add(1);是错误的，如果传入的是String类型，就不符合了
System.out.println(obj);
}
}
import java.util.*;
class GenerticDemo
{
public static void main(String[] args)
{
ArrayList<String> p = new ArrayList<String>();
p.add("per20");
p.add("per11");
p.add("per52");
print(p);
ArrayList<Integer> s = new ArrayList<Integer>();
s.add(new Integer(4));
s.add(new Integer(7));
s.add(new Integer(1));
print(s);
}
public static void print(ArrayList<?> al) {
Iterator<?> it = al.listIterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
通配符的扩展-->泛型的限定：
对于一个范围内的一类事物，可以通过泛型限定的方式定义，有两种方式：
1、? extends E：可接收E类型或E类型的子类型；称之为上限。
如：Vector<? extends Number> x = newvector<Integer>();
2、? super E：可接收E类型或E类型的父类型；称之为下限。
如：Vector<? super Integer>x = newvector<Number>();
09自定义泛型方法及其应用
java中泛型方法的定义：
private static <T> T add(T a, T b){
......
return null;
}
add(3,5); //自动装箱和拆箱
Number x1 = add(3.5,5); //取两个数的交集类型Number
Object x2 = add(3,"abc"); //去最大交集为Object
1、何时定义泛型方法：为了让不同方法可以操作不同的类型，而且类型不确定，那么就可以定义泛型方法
2、特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
泛型方法的特点：
1、位置：用于放置泛型的类型参数的<>应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前，按照惯例，类型参数通常用单个大写字母表示。
2、只有引用类型才能作为泛型方法的实际参数
3、除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符。
4、普通方法、构造函数和静态方法中都可以使用泛型。
5、可以用类型变量表示异常，称之为参数化的异常，可用于方法的throws列表中，但是不能用于catch子句中。
6、在泛型中可同时有多个类型参数，在定义它们的<>中用逗号分开。
public static <K,V> V getValue(K key){
Map<K, V> map = new HashMap<K, V>();
return map.get(key);
}
private static <T extends Exception> void sayHello() throws T{
try{}
catch(Exception e){
throw (T)e;
}
} 这个T和?有什么区别呢？
1、T限定了类型，传入什么类型即为什么类型，可以定义变量，接收赋值的内容。
2、?为通配符，也可以接收任意类型但是不可以定义变量。
但是这样定义，虽然提高了扩展性，可还是有一个局限性，就是不能使用其他类对象的特有方法。
3、总结：
通配符方案要比泛型方法更有效，当一个类型变量用来表达两个参数之间或参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用，而不是仅在签名的时候使用，才需要使用泛型方法。
泛型类概述：
1、若类实例对象中多出要使用到同一泛型参数，即这些地方引用类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型。
2、何时定义泛型类：当类中要操作的引用数据类型不确定时，在早期定义Object来完成扩展，而现在定义泛型。
3、泛型类定义的泛型，在整个类中都有效，如果被方法调用，那么泛型类的对象要明确需要操作的具体类型后，所有要操作的类就已经固定了。
4、类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的。
语法格式：
1、定义
public class GenerDao1<T>{
private T field;
public void save(T obj){}
public T getByteId(int Id){}
} 2、举例：
扩展：Dao：Data Access Object，数据访问对象。
对其操作：crud即增上删改查
c：creat，创建、增加； r：read，读取、查询；
u：update，更新、修改 d：delete，删除。
对javaEE的理解：13种技术。简单说就是对数据库的增删改查。
写Dao类有五个基本方法：增删改查，其中查包含查单个和对同类型集合的查询，如同性别或同地区的集合获取。
注意：
1、在对泛型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
2、当一个变量被声明为参数时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法调用，因为静态成员是被所有参数化的类共享的，所以静态成员不应该有类级别的类型参数。
总结：
对泛型的定义：
定义泛型：当有不确定的类型需要传入到集合中，需要定义泛型
定义泛型类：如果类型确定后，所操作的方法都是属于此类型，则定义泛型类
定义泛型方法：如果定义的方法确定了，里面所操作的类型不确定，则定义泛型方法
class GenerticTest { //测试类
public static void main(String[] args) {
GenClass<Worker> g = new GenClass<Worker> (); //创建泛型类对象
g.setTT(new Worker());
Worker w = g.getTT();
g.showC(w);
System.out.println("----------------------");
GenMethod<String> g1 = new GenMethod<String>(); //创建泛型方法测试
GenMethod.showS("SSS");
g1.show("sesf");
g1.print("heheh");
g1.printY(new Integer(5));
System.out.println("------------------------");
GenInter g2 = new GenInter(); //创建泛型接口测试
g2.show("haha");
System.out.println("Hello World!");
GenImpl<Integer> g3 = new GenImpl<Integer>();
g3.show(new Integer(95));
}
}
class GenClass<TT> { //泛型类
private TT t; //定义私有属性
public void setTT(TT t) { //定义公共设置方法，设置属性
this.t = t;
}
public TT getTT() { //定义公共访问方法，访问属性
return t;
}
public void showC(TT t) { //定义方法
System.out.println("GenClass show:" + t);
}
}
class Worker {} //创建Worker类，作为类型传入泛型类中
class GenMethod<T> { //泛型方法
public static <S> void showS(S s) { //静态的泛型方法
System.out.println("static show:" + s);
}
public void show(T t) { //非静态泛型方法
System.out.println("未指定T show:" + t);
}
public void print(T t) {
System.out.println("指定T print:" + t);
}
public <Y> void printY(Y y) { //指定接受其他类型的泛型方法
System.out.println("和类指定的不同，为Y print：" + y);
}
}
interface Inter<T> { //泛型接口
void show(T t);
}
class GenInter implements Inter<String> { //一般类实现泛型接口
public void show(String s) {
System.out.println("接口 show:" + s);
}
}
class GenImpl<T> implements Inter<T> { //泛型类实现泛型接口
public void show(T t) {
System.out.println("类接收类型不确定的实现接口 show：" + t);
} 10参数的类型推断
概述：
1、定义：编译器判断泛型方法的实际参数的过程，称之为类型推断。
2、类型推断是相对于直觉推断的，其实现方法是一种非常复杂的过程。
类型推断的具体规则：
根据调用泛型方法时，实际传递的参数类型或返回值的类型来推断。
1、当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时，该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时，传递的参数类型或返回值来决定泛型参数的类型，如：
swap(newString[3],1，2)
---> static <E> void swap(E[] a, inti, int j);
2、当某个类型变量在某个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时，这多处的实际应用类型都对应同一种类型来表示，这很容易凭感觉推断出来：
add(3,5)
---> static<T> T add(T a,T b);
3、若对应了不同类型，且没有使用返回值，这是取多个参数中的最大交集类型，如下面的对应类型Number，编译没问题，但是运行会出错：
fill(new Integer[3],3.5f)
---> static<T> void fill(T[] a,T v);
4、若对应了不同类型，且使用了返回值，这时候优先考虑返回值类型，如下面语句实际对应的类型就是Integer了，编译将报错，将变量x类型改为float，对此eclipse报错提示，接着再将变量x类型改为Number，则就没了错误：
int x = add(3,3.5f)
---> static<T> T add(T a,T b);
5、参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没问题，而第二种情况则会根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：
copy(newInteger[5],new String[5]);
---> static<T> T copy(T[] a,T[] b);
11通过反射获得泛型的实际类型参数
package cn.itcast.text2;
import java.lang.reflect.*; //导入程序所需的各个包
import java.sql.Date;
import java.util.*;
import cn.itcast.text1.ReflectPoint;
public class GenerticTest {
public static void main(String[] args) throws Exception {
Object obj = "abc";
String str = autoContor(obj);
GenerticDao<ReflectPoint> gd = new GenerticDao<ReflectPoint>();
gd.add(new ReflectPoint(3,5));
Method applyMethod =
GenerticTest.class.getMethod("applyVector", Vector.class); //通过获得方法本身的方法
Type[] types =
applyMethod.getGenericParameterTypes(); //通过方法的获取泛型参数的方法得到原始参数类型的集合
ParameterizedType pType = (ParameterizedType)types[0]; //将参数类型转换为参数化类型
System.out.println(pType.getRawType()); //得到原始类型
System.out.println(pType.getActualTypeArguments()[0]); //得到实际参数类型
} 12类加载器及其委托机制的深入分析
概述：
1、定义：简单说，类加载器就是加载类的工具。
当出现一个类，用到此类的时候，Java虚拟机首先将类字节码加载进内存，通常字节码的原始信息放在硬盘上的classpath指定的目录下。
2、类加载器作用：将.class文件中的内容加载进内存进行处理，处理完后的结果就是字节码。
3、默认类加载器：
1）Java虚拟机中可安装多个类加载器，系统默认的有三个主要的，每个类负责加载特定位置的类：BootStrap、ExtClassLoader、AppClassLoader
2）BootStrap--顶级类加载器：
类加载器本身也是Java类，因为它是Java类，本身也需要加载器加载，显然必须有第一个类加载器而不是java类的，这正是BootStrap。它是嵌套在Java虚拟机内核中的，已启动即出现在虚拟机中，是用c++写的一段二进制代码。所以不能通过java程序获取其名字，获得的只能是null。
4、Java虚拟机中的所有类加载器采用子父关系的树形结构进行组织，在实例化每个类加载器对象或默认采用系统类加载器作为其父级类加载器。
package cn.itcast.text2;
import java.util.Date;
public class ClassLoadTest{
public static void main(String[] args) throws Exception{
System.out.println(
ClassLoadTest.class.getClassLoader().
getClass().getName()); //打印结果为AppClassLoader
System.out.println(
System.class.getClassLoader()); // 为null
}
} 5、配置文件的路径问题：
第一、用绝对路径，通过getRealPath()方法运算出来具体的目录，而不是内部编码出来的。
一般先得到用户自定义的总目录，在加上自己内部的路径。可以通过getRealPath()方法获取文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，配置文件要放到程序的内部。
第二、name的路径问题：
①如果配置文件和classPath目录没关系，就必须写上绝对路径，
②如果配置文件和classPath目录有关系，即在classPath目录中或在其子目录中（一般是资源文件夹resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于当前包而言的。
示例：
配置文件内容：
className=java.util.ArrayList
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest2 {
public static void main(String [] args)throws Exception{
//读取系统文件到读取流中
//方式一：
//InputStream ips = new FileInputStream("config.propert");
/*getRealPath()--得到完整的路径
一定要用完整的路径，但完整的路径不是硬编码出来的，而是运算出来的。*/
//方式二：
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/text1/config.propert");
//方式三：
//第一种：配置文件（资源文件）在当前包中
InputStream ips = ReflectTest2.class.getResourceAsStream("resourse/config.propert");
//第二种：配置文件（资源文件）不在当前包中，和此包没太大关系
//InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/test2/resourse/config.properties");
Properties props = new Properties(); //加载文件中的键值对
props.load(ips);
ips.close(); //关闭资源，即ips调用的那个系统资源
//注意：关闭的是ips操作的流，加载进内存后，就不再需要流资源了，需要关闭
String className = props.getProperty("className"); //定义变量，将文件中的类名赋值给变量
Collection cons = //通过变量，创建给定类的对象
(Collection)Class.forName(className).newInstance();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
cons.add(pt1); //将元素添加到集合中
cons.add(pt2);
cons.add(pt3);
cons.add(pt1);
cons.remove(pt1); //移除元素
System.out.println(cons.size());
}
} 类加载器的委托机制：
1、加载类的方式
当Java虚拟机要加载一个类时，到底要用哪个类加载器加载呢？
1）首先，当前线程的类加载器去加载线程中的第一个类。
2）若A引用类B（继承或者使用了B），Java虚拟机将使用加载类的类加载器来加载类B。
3）还可直接调用ClassLoader的LoaderClass()方法，来制定某个类加载器去加载某个类。
2、加载器的委托机制：每个类加载器加载类时，又先委托给上级类加载器。
每个ClassLoader本身只能分别加载特定位置和目录中的类，但他们可以委托其他类的加载器去加载，这就是类加载器的委托模式，类加载器一级级委托到BootStrap类加载器，当BootStrap在指定目录中没有找到要加载的类时，无法加载当前所要加载的类，就会一级级返回子孙类加载器，进行真正的加载，每级都会先到自己相应指定的目录中去找，有没有当前的类；直到退回到最初的类装载器的发起者时，如果它自身还未找到，未完成类的加载，那就报告ClassNoFoundException的异常。
简单说，就是先由发起者将类一级级委托为BootStrap，从父级开始找，找到了直接返回，没找到再返回给其子级找，直到发起者，再没找到就报异常。
3、委托机制的优点：可以集中管理，不会产生多字节码重复的现象。
补充：面试题
可不可以自己写个类为：java.lang.System呢？
回答：第一、通常是不可以的，由于类加载器的委托机制，会先将System这个类一级级委托给最顶级的BootStrap，由于BootStrap在其指定的目录中加载的是rt.jar中的类，且其中有System这个类，那么就会直接加载自己目录中的，也就是Java已经定义好的System这个类，而不会加载自定义的这个System。
第二、但是还是有办法加载这个自定义的System类的，此时就不能交给上级加载了，需要用自定义的类加载器加载，这就需要有特殊的写法才能去加载这个自定义的System类的。
13自定义类加载器
1、自定义的类加载器必须继承抽象类ClassLoader，要覆写其中的findClass(String name)方法，而不用覆写loadClass()方法。
2、覆写findClass(String name)方法的原因：
1）是要保留loadClass()方法中的流程，因为loadClass()中调用了findClass(String name)这个方法，此方法返回的就是去寻找父级的类加载器。
2）在loadClass()内部是会先委托给父级，当父级找到后就会调用findClass(String name)方法，而找不到时就会用子级的类加载器，再找不到就报异常了，所以只需要覆写findClass方法，那么就具有了实现用自定义的类加载器加载类的目的。
流程：
父级-->loadClass-->findClass-->得到Class文件后转化成字节码-->defind()。
3、编程步骤：
1）编写一个对文件内容进行简单加密的程序
2）编写好了一个自己的类加载器，可实现对加密过来的类进行装载和解密。
3）编写一个程序，调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类，程序中除了可使用ClassLoader的load方法外，还能使用放置线程的上线文类加载器加载或系统类加载器，然后在使用forName得到字节码文件。
import java.util.Date;
public class ClassLoaderAttachment extends Date { //对此类进行加密
public String toString(){
return "hello world";
}
public static void main(String [] args){
}
}
package cn.itcast.text2; //自定义类加载器
import java.io.*;
public class MyClassLoader extends ClassLoader { //继承抽象类ClassLoader
public static void main(String[] args) throws Exception {
String scrPath = args[0]; //传入两个参数，源和目标
String destDir = args[1];
FileInputStream fis = new FileInputStream(scrPath);
String destFileName = //将数据读取到输入流中，并写入到输出流中
scrPath.substring(scrPath.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 = 0;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
private String classDir; //定义全局变量
@Override //覆写findClass方法，自定义类加载器
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);
fis.close();
byte[] bytes = bos.toByteArray();
return defineClass(bytes, 0, bytes.length);
} catch (Exception e) {
e.printStackTrace();
}
return super.findClass(name); //如果没找到类，则用父级类加载器加载
}
public MyClassLoader(){} //自定义加载器构造函数
public MyClassLoader(String classDir){
this.classDir = classDir;
}
}
14代理类的作用与AOP概念
概念：
生活中的代理：就是常说的代理商，从厂商将商品卖给消费者，消费者不用很麻烦的到厂商在购买了。
程序中的代理：要为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，如异常处理、日志、计算方法的运行时间、事物管理等等。
简单示例：编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码，如：
目标类： 代理类：
class X{ Xproxy{
void sayHello(){ void sayHello(){
syso:Hello; startTime
} X. sayHello();
} endTime;}}
一般用接口来引用其子类，如：Collectioncoll = new ArrayList();
代理类的优点：
如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类还是代理类。这样以后很容易切换，如果想要日志功能时，就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，更换系统也容易
import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
public static void main(String[] args) throws Exception{
Class clazzProxy1 = //获取代理类Proxy的Class对象，传入的是类加载器和相应的字节码对象
Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
System.out.println(clazzProxy1.getName());//$Proxy0
System.out.println("---begin constructor list------");
Constructor[] constructors = //获取代理类的构造方法，可能含有多个，得到数组
clazzProxy1.getConstructors();
for(Constructor constructor : constructors){ //遍历数组，获取每个构造方法
String name = constructor.getName(); //先得到构造方法的名字，并装入字符串容器中
StringBuilder sBul = new StringBuilder(name);
sBul.append('(');
Class[] clazzParams = //获取构造方法中的参数类型，并遍历
constructor.getParameterTypes();
for(Class clazzParam : clazzParams){
sBul.append(clazzParam.getName()).append(','); //将最后一个逗号去除
}
if(clazzParams != null && clazzParams.length!=0)
sBul.deleteCharAt(sBul.length()-1);
sBul.append(')');
System.out.println(sBul.toString());
}
System.out.println("---begin method list------");
Method[] methods = clazzProxy1.getMethods();
for(Method method : methods){
String name = method.getName();
StringBuilder sBul = new StringBuilder(name);
sBul.append('(');
Class[] clazzParams = method.getParameterTypes();
for(Class clazzParam : clazzParams){
sBul.append(clazzParam.getName()).append(',');
}
if(clazzParams!=null && clazzParams.length!=0)
sBul.deleteCharAt(sBul.length()-1);
sBul.append(')');
System.out.println(sBul.toString());
}
}
AOP
简述：AOP（Aspect Oriented Program）即面向方面的编程。
系统中存在着交叉业务，一个交叉业务就是要切入到系统中的一个方面
安全 事务 日志
StudentService ------|----------|------------|-------------
CourseService ------|----------|------------|-------------
MiscService ------|----------|------------|-------------
安全、事务、日志等功能要贯穿于好多个模块中，所以他们就是交叉业务。
交叉业务的编程问题即面向方面的编程(AOP)，AOP的目标就是使交叉业务模块化，可以采用将切面代理移动到原始方法的周围，这与直接在方法中编写切面代理的过程效果是一样的，如图：
------------------------------------------------------切面
func1 func2 func3
{ { {
.... .... ......
} } }
------------------------------------------------------切面
因此使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。
15动态代理
概述：
1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，这时就不能采用静态代理方式，需用动态代理技术。
2、动态代理类：JVM可在运行时，动态生成类的字节码，这种动态（不是代理，只是拿出来作为代理类）生成的类往往被用作代理类，即动态代理类。
注：JVM生成的动态类必须实现一或多个接口，所以JVM生成的动态代理类只能用作具有相同接口的目标类代理。
3、CGLIB库可以动态生成一个类的子类，一个类的子类也可以作为该类的代理，所以，如果要为一个没有实现接口的类生成动态代理，那么可以使用CGLIB库。
4、代理类各个方法通常除了调用目标相应方法和对外返回目标返回的结果外，还可以再代理方法中的如下位置上加上系统功能代码：
1）在调用目标方法之前
2）在调用目标方法之后
3）在调用目标方法前后
4）在处理目标方法异常的catch块中。
16分析JVM动态生成的类
1、创建动态类的实例对象：
1）用反射获得构造方法
2）编写一个最简单的InvocationHandler的类
3）调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去。
示例：
第一、打印创建的对象和调用对象的无返回值的方法和getClass方法，演示调用其他没有返回值的方法报告的异常
第二、将创建的动态类的实例对象的代理改写成为匿名内部类的形式编写。
package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class ProxyTest {
public static void main(String[] args) throws Exception{
//创建动态代理类的三种方式
Collection proxy1 = (Collection)
constructor.newInstance(new MyInvocationHandler()); //方式一：通过接口的子类创建对象
System.out.println(proxy1);//null
System.out.println(proxy1.toString());//null
proxy1.clear(); //无异常
//proxy1.size(); //异常
Collection proxy2 = (Collection)
constructor.newInstance(new InvocationHandler(){ //方式二：匿名内部类
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// TODO Auto-generated method stub
return null;
}
});
Collection proxy3 = //方式三: 通过代理类的 (Collection)Proxy.newProxyInstance( //newProxyInstance方法直接创建对象
Collection.class.getClassLoader(), //定义代理类的类加载器
new Class[]{Collection.class}, //代理类要实现的接口列表
new InvocationHandler() { //指派方法调用的调用处理程序
ArrayList target = new ArrayList(); //创建集合，制定一个目标
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long beginTime = System.currentTimeMillis(); //测试程序运行时间
Object retVal = method.invoke(target, args); //调用目标方法，将其从return抽出来 //加入代理所需的代码
long endTime = System.currentTimeMillis();
System.out.println(method.getName() + //开始测试
" run time of " +
(endTime - beginTime));
return retVal;
}
}
);
//通过代理类调用目标方法，每调用一个目标的方法就会执行代理类的方法
//当调用一次add方法时，就会找一次InvocationHandler这个参数的invoke方法
proxy3.add("sdfd");
proxy3.add("shrt");
proxy3.add("rtbv");
System.out.println(proxy3.size());
System.out.println(proxy3.getClass().getName());
}
}
2、让JVM创建动态类需要提供的信息：
1）生成类中的哪些方法，通过让其实现哪些接口的方式进行告知。
2）产生的类字节码必须有一个关联的类加载器对象
3）生成的类中的方法的代码是怎么样的，也得由我们自己提供，把我们的代码写在一个约定好的子接口对象的方法中，把对象传给它，它调用我们的方法，即相当于插入了我们自己的代码。提供执行代码的对象就是InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的，在上面的InvocationHandler对象的invoke方法中，加一点代码就可以看到这些代码被调用运行了。
17分析动态生成的类的内部代码运行原理
1、构造方法接受一个InvocationHandler对象，接受此对象的用处：
接受一个handler参数是为了记录它，以便在之后的程序中运用它。
2、实现Collection接口的动态类中的各个方法的代码的解析：
1）InvocationHandler接口中定义的invoke方法接受三个参数的含义：
第一、Client(客户端)程序调用objProxy.add(“avc”)方法时，涉及到了三个参数，分别为：objProxy对象，add方法，”avc”参数。代码如下：
class Proxy${
add(Object obj){
return handler.invoke(Object proxy, Method method, Object[] args);
}
}
第二、其中的Objectproxy 即为objProxy对象，Method method对应add方法，Object[] args就是”avc”参数。在使用newProxyInstance的方式创建代理对象实现时，当前正在调用代理对象（Object proxy），调用当前对象的哪个方法（Method method），调用此对象方法时传入的参数（Object[] args）。
3、调用代理涉及到三个因素：代理对象，代理对象的哪个方法，以及此方法接受的参数。要执行目标对象，只需要将代理对象作为目标对象即可。
4、对于上面代码中的Object retVal = method.invoke(target,args)的分析：
目标对象target执行完返回一个值为retVal，接着将值作为结果return回去，则代理方法就会收到一个返回值。其中还可以定义一个过滤器，对参数args（即当前对象的方法传入的参数）进行过滤（修改）。
5、对于上面代码中的proxy3.add(“sdfd”)的分析：
1）代理对象调用add方法，传递了sdfd参数。
2）add方法内部会找到InvocationHandler中的invoke方法，将代理对象proxy传进去，把add方法传入，将“sdfd”参数传入代理对象中的handler参数，返回了一个结果，就是给了add方法，add方法继续向外返回给调用的对象proxy3，即最终结果。
其中的handler的invoke方法返回又来自于目标target返回值，从而将此返回值返给Object invoke()方法，即作为handler参数位置上的值返回给add方法。add方法作为最后的结果返回。
问题：
1、在上面的方式一的代码中，调用无返回值的方法返回的是null，而调用有返回值方法的时候会报NullPointException异常的原因：
在proxy1.size()方法中，size()会调用Object invoke()方法，而对其覆写时的返回值是null，而size()本身会返回int类型，两者返回的类型不相等，所以就会报错。
而对于proxy3.size()不报错，是因为size()返回值与代理对象中handler参数返回值是一致的，当前目标返回什么，代理就返回什么，所以不会报错。
注意：目标返回值和代理返回值必须是同一类型。
2、为何动态类的实例对象的getClass()方法返回了正确结果，而没调用invoke方法：
因为代理类从Object上继承了许多方法，其中只对三个方法（hashCode、equals和toString）进行开发，委托给handler去自行处理，对于它身上其他方法不会交给代理类去实现，所以对于getClass()方法，还是由Object本身实现的。即proxy3.getClass()，该是什么结果还是什么结果，并不会交给invoke方法处理。
18总结分析动态代理类的统计原理和结构
1、怎样将目标传进去：
1）直接在InvocationHandler实现类中创建目标类的实例对象，可看运行效果和加入日志代码，但是毫无意义。
2）为InvocationHandler实现类注入目标的实例对象，不能采用匿名内部类的形式了。
3）让匿名内部类的InvocationHandler实现类访问外面的方法中的目标类实例对象的final类型的引用变量。
2、动态代理的工作原理：
1）Client(客户端)调用代理，代理的构造方法接受一个InvocationHandler，client调用代理的各个方法，代理的各个方法请求转发给刚才通过构造方法传入的handler对象，又把各请求分发给目标的相应的方法。就是将handler封装起来，其中this引用了当前的放(发来什么请求就接受哪个方法)。
示意图：
2）将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接受目标，同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
3、把系统功能代理模块化，即切面代码也改为通过参数形式提供，怎么把要执行的系统功能代码以参数的形式提供：
1）把要执行的代码装到一个对象的某个方法中，然后把此对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外接提供的代码。
2）为bind方法增加一个Advice参数。
示例：
//封装getProxy方法
package cn.itcast.test3;
import java.lang.reflect.*;
import java.util.*;
public class MyProxy {
public static void main(String[] args)throws Exception {
final ArrayList target = new ArrayList(); //创建目标对象，并进行操作测试
Collection proxy = (Collection)getProxy(target,new MyAdvice());
proxy.add("sdf");
proxy.add("wgcd");
proxy.add("hgwe");
System.out.println(proxy.size());
}
private static Object getProxy //作为一个通用的方法，就使用Object
(final Object target,final Advice advice){ //传入一个目标，并传入一个接口， //此接口作为通信的契约，才能调用额外的方法
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(), //这里的接口要和target实现相同的接口
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
advice.beforeMethod(method); //通过契约，使用其方法--before和after方法
Object value = method.invoke(target, args);
advice.afterMethod(method);
return value;
}
}
);
return proxy;
}
}
package cn.itcast.test3; //创建实现Advice接口的子类
import java.lang.reflect.Method;
public class MyAdvice implements Advice { //实现Advice接口中方法的具体内容
long beginTime = 0;
public void beforeMethod(Method method) {
System.out.println("从这里开始");
beginTime = System.currentTimeMillis();
}
public void afterMethod(Method method) {
long endTime = System.currentTimeMillis();
System.out.println("从这里结束");
System.out.println(method.getName() + " run time of " + (endTime-beginTime));
}
}
import java.lang.reflect.Method;
/*接口中需要实现四个方法
调用目标方法之前
调用目标方法之后
调用目标方法前后
在处理目标方法异常的catch块中
*/
//这里只列出两个作为示例
public interface Advice { //创建接口Advice
void beforeMethod(Method method);
void afterMethod(Method method);
}
19实现类似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进行测试。
示例：
//创建BeanFactory类
package cn.itcast.test3.aopframework;
import java.io.*;
import java.util.Properties;
import cn.itcast.test3.Advice;
public class BeanFactory {
Properties prop = new Properties();
public BeanFactory(InputStream ips) { //创建对象时需要传入一个配置文件中的数据，所以需要在构造方法中接受一个参数
try {
prop.load(ips); //将配置文件加载进来
} catch (IOException e) {
e.printStackTrace();
}
}
public Object getBean(String name){ //创建getBean方法，通过配置文件中的名字获取bean对象
String className = prop.getProperty(name); //从配置文件中读取类名
Object bean = null;
try {
Class clazz = Class.forName(className); //由类的字节码获取对象
bean = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){ //判断bean是特殊的bean即ProxyFactoryBean还是普通的bean
Object proxy = null;
try {
ProxyFactoryBean proxyFactoryBean = //是ProxyFactoryBean的话，强转，并获取目标和通告
(ProxyFactoryBean)bean;
Advice advice = //获取advice和target
(Advice)Class.forName(prop.getProperty(name + ".advice")).newInstance();
Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();
proxyFactoryBean.setAdvice(advice); //设置目标和通告
proxyFactoryBean.setTarget(target);
proxy = proxyFactoryBean.getProxy(); //通过类ProxyFactoryBean（开发中是作为接口存在 ）中获得proxy对象
} catch (Exception e) {
e.printStackTrace();
}
return proxy; //是ProxyFactoryBean的话，返回proxy对象
}
return bean; //否则返回普通bean对象
}
}
package cn.itcast.test3.aopframework;
import java.lang.reflect.*;
import cn.itcast.test3.Advice;
public class ProxyFactoryBean { //创建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() {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(), //这里的接口要和target实现相同的接口
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable{
advice.beforeMethod(method); //通过契约，使用其方法--before和after方法
Object value = method.invoke(target, args);
advice.afterMethod(method);
return value;
}
}
);
return proxy;
}
}
package cn.itcast.test3.aopframework;
import java.io.InputStream;
public class AopFramewrorkTest { //创建测试类AopFrameworkTest
public static void main(String[] args)throws Exception {
InputStream ips = //读取配置文件的数据
AopFramewrorkTest.class.getResourceAsStream("config.property");
Object bean = new BeanFactory(ips).getBean("xxx"); //获取bean对象
System.out.println(bean.getClass().getName());
}
}
此时，如果传入的是java.util.ArrayList的话，返回的结果就是这个对象的名字
否则，如果是特殊的bean对象，那么返回的就是$Proxy这个名字，是一个ProxyFactoryBean对象。
2715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
