java---反射

反射

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

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

8.1constructor类

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

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

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

l 得到某一个构造方法：

Ø例子： Constructor constructor =Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);  //获得方法时要用到类型

l 创建实例对象：

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

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

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

l Class.newInstance()方法：

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

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

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

//

2. 一个类有多个构造方法，用什么方式可以区分清楚想得到其中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。重点：参数类型用什么方式表示？用Class实例对象。例如：

int.class，(int []).class

int [] ints = new int[0];

ints.getClass();

Constructor对象代表一个构造方法，大家觉得Constructor对象上会有什么方法呢？得到名字，得到所属于的类，产生实例对象。

3. 讲解创建实例对象时，先应该举例说说通常情况下是怎样做的， String str= new String(new StringBuffer(“abc”));在源程序中用注释方式给出传统方式的代码，以便对比提醒程序阅读者。

然后再说用反射如何做

        String str =(String)constructor.newInstance(/*"abc"*/newStringBuffer("abc"));

        System.out.println(str);

讲反射方式创建实例对象时，先故意用string作为参数传进去，根据错误让大家感受到确实是那个构造方法，然后再改为传一个StringBuffer类型的参数进去，  String str =(String)constructor.newInstance(/*"abc"*/newStringBuffer("abc"));

好比，我叫来一个吃人不吃草的恐龙，等到它要吃东西时，我得给他送真人去了吧。

8.2Field类

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

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

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

l 示例代码：

   ReflectPoint point = new ReflectPoint(1,7);

    private int x;

    public int y;

    Field  y   = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");//getField()访问的是可见的（公有的）

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

    Field  x   =Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");//getDeclaredField()访问的是声明过的

   x.setAccessible(true);设置它为可见的（暴力反射）

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

l 作业：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

classXxx

{

    String name="abc";

    String email="abd";

}

func(Objectobj)

{//获取字段

Field [] fields =obj.getClass().getDeclaredFields();

for(Field field : fields)//迭代字段

{//因为同一个字节码，所以使用等号比较

        if(field.getType()==java.lang.String.class)

        {

           field.setAccesible(true);

           Stringoriginal = (String)field.get(obj);

           field.set(obj,original.replaceAll("b","a");

        }

}

}

一个问题，我把自己的变量定义成private，就是不想让人家访问，可是，现在人家用暴力反射还是能够访问我，这说不通啊，能不能让人家用暴力反射也访问不了我。首先,private主要是给javac编译器看的，希望在写程序的时候，在源代码中不要访问我，是帮助程序员实现高内聚、低耦合的一种策略。你这个程序员不领情，非要去访问，那我拦不住你，由你去吧。同样的道理，泛型集合在编译时可以帮助我们限定元素的内容，这是人家提供的好处，而你非不想要这个好处，怎么办？绕过编译器，就可以往集合中存入另外类型了。

8.3Method类

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

l 得到类中的某一个方法：

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

l 调用方法：

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

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

•  如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！

•  invoke()方法是Method方法对象的方法。

l 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})形式。

 

大家应通过思考和推理的方式来学习反射中的API，例如，Class.getMethod方法用于得到一个方法，该方法要接受什么参数呢？显然要一个方法名，而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法系列中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。

再强调一遍参数类型用什么来表示啊？用Class对象！

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

l 目标：

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

l 问题：

Ø启动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的语法解释，因此会出现参数类型不对的问题。

l 解决办法：

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

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

l  代码示例：

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

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

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

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

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

class TestArrayArguments {

    public static voidmain(String [] args)

    {

       for(String arg:args)

       {

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

       }

    }

}

8.5数组的反射

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

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

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

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

解释差异：String类型可以转换成object，但是int类型不可以转换成object类型

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

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

Object[]与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成newString[]{“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];    

Objectobj = a;

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

Object[]obj3 = a1

Objectobj4 = a3;

if(obj4instanceof String[][]){

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

}

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

4.private static voidprintObject(Object obj) {

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

int len = Array.getLength(obj);

for(inti=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[] 与String[]没有父子关系，Object与String有父子关系,所以new Object[]{“aaa”,”bb”}不能强制转换成newString[]{“aaa”,”bb”};,Object x = “abc”能强制转换成String x =“abc”。

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

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

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

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

l 框架要解决的核心问题

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

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

l 综合案例

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

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

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

什么是框架，例如，我们要写程序扫描.java文件中的注解，要解决哪些问题：读取每一样，在每一个中查找@，找到的@再去查询一个列表，如果@后的内容出现在了列表中，就说明这是一个我能处理和想处理的注解，否则，就说明它不是一个注解或者说至少不是一个我感兴趣和能处理的注解。接着就编写处理这个注解的相关代码。现在sun提供了一个APT框架，它会完成所有前期工作，只需要我们提供能够处理的注解列表，以及处理这些注解的代码。APT框架找到我们感兴趣的注解后通知或调用我们的处理代码去处理。

你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是别人提供的。

Class类也提供getResourceAsStream方法的比喻：如果你每次都找我给你商店买可乐，那我还不如直接向你买可乐，即直接提供一个买可乐的方法给你。

public static void main(String[] args) throwsException{

//应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。

Properties props = new Properties();

//先演示相对路径的问题

//InputStream ips = new FileInputStream("config.properties");

/*一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*/

//InputStream ips =ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config.properties");

//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件

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

//与类路径无关的配置文件

InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");

props.load(ips);

Ips.close();

String className =props.getProperty("className");

Class clazz = Class.forName(className);

Collection collection = (Collection)clazz.newInstance();//调用不带参数的构造方法

//Collection collection = new ArrayList();

ReflectPoint pt1 = new ReflectPoint(3,3);

ReflectPoint pt2 = new ReflectPoint(5,5);

ReflectPoint pt3 = new ReflectPoint(3,3);

collection.add(pt1);

collection.add(pt2);

collection.add(pt3);

collection.add(pt1);

System.out.println(collection.size());

}

8.7内省à了解JavaBean

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

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

ØsetId()的属性名àid

ØisLast()的属性名àlast

ØsetCPU的属性名是什么?àCPU

ØgetUPS的属性名是什么？àUPS

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

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

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

ØJDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。

内省对应的英文单词为IntroSpector，它主要用于对JavaBean进行操作，JavaBean是一种特殊的Java类，其中的某些方法符合某种命名规则，如果一个Java类中的一些方法符合某种命名规则，则可以把它当作JavaBean来使用。请问：一个JavaBean可以当做普通Java类来使用吗？一个普通Java类可以当做JavaBean来使用吗？

内省综合案例

l 用eclipse自动生成 ReflectPoint类的setter和getter方法。

l 直接new一个PropertyDescriptor(属性描述符)对象的方式来让大家了解JavaBean API的价值，先用一段代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。

l 用eclipse将读取属性和设置属性的流水帐式代码分别抽取成方法：

Ø只要调用这个方法，并给这个方法传递了一个对象、属性名和设置值，它就能完成属性修改的功能。

Ø得到BeanInfo最好采用“obj.getClass()”方式，而不要采用“类名.class”方式，这样程序更通用。

l 采用遍历BeanInfo的所有属性方式来查找和设置某个RefectPoint对象的x属性。在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法， 得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。

代码示例

publicstatic void main(String[] args) throws Exception{

       ReflectPoint pt1 = new ReflectPoint(3,5);

       Object retVal = getProperty(pt1);

       System.out.println(retVal);

       PropertyDescriptor pd2 = null;

       String propertyName = "y";

       Object value = 7;

       setProperty(pt1, propertyName, value);

       //先通过调用普通java类的方法的方式获得结果，然后在这之前插入BeanUtil的get和set操作，见下面的代码。

       //System.out.println(pt1.getY());

       System.out.println(BeanUtils.getProperty(pt1,"y"));

       BeanUtils.setProperty(pt1, "y","99");

       System.out.println(pt1.getY());

       PropertyUtils.setProperty(pt1,"y", 999);     System.out.println(PropertyUtils.getProperty(pt1,"y").getClass().getName());

    }

    private static ObjectgetProperty(ReflectPoint pt1) {

       Object retVal = null;

       PropertyDescriptor pd = null;

       try {

           pd = newPropertyDescriptor("y",pt1.getClass());

           retVal =pd.getReadMethod().invoke(pt1);

       } catch (Exception e) {

           e.printStackTrace();

       }

       return retVal;

    }

    private static void setProperty(Object pt1,String propertyName,

           Object value) {

       /*PropertyDescriptor pd2;

       try {

           pd2 = newPropertyDescriptor(propertyName,pt1.getClass());

           pd2.getWriteMethod().invoke(pt1,value);

       } catch (Exception e) {

           e.printStackTrace();

       }*/

      

       try {

           BeanInfo beanInfo =Introspector.getBeanInfo(pt1.getClass());

           PropertyDescriptor[] pds =beanInfo.getPropertyDescriptors();

           for(PropertyDescriptor pd :pds){

              if(pd.getName().equals(propertyName)){

                  pd.getWriteMethod().invoke(pt1,value);

                  break;

              }

           }

       } catch (IllegalArgumentException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } catch (IntrospectionException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } catch (IllegalAccessException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       } catch (InvocationTargetException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }

    }