java反射詳解 (二)

 【案例】經過反射操做屬性

class hello {
    public static void main(String[] args) throws Exception {
        Class<?> demo = null;
        Object obj = null;

        demo = Class.forName("Reflect.Person");
        obj = demo.newInstance();

        Field field = demo.getDeclaredField("sex");
        field.setAccessible(true);
        field.set(obj, "男");
        System.out.println(field.get(obj));
    }
}// end class

 

【案例】經過反射取得並修改數組的信息：

import java.lang.reflect.*;
class hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5};
        Class<?>demo=temp.getClass().getComponentType();
        System.out.println("數組類型： "+demo.getName());
        System.out.println("數組長度  "+Array.getLength(temp));
        System.out.println("數組的第一個元素: "+Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改以後數組第一個元素爲： "+Array.get(temp, 0));
    }
}

 

【運行結果】：

數組類型： int

數組長度  5

數組的第一個元素: 1

修改以後數組第一個元素爲： 100

【案例】經過反射修改數組大小

class hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5,6,7,8,9};
        int[] newTemp=(int[])arrayInc(temp,15);
        print(newTemp);
        System.out.println("=====================");
        String[] atr={"a","b","c"};
        String[] str1=(String[])arrayInc(atr,8);
        print(str1);
    }

    /**
     * 修改數組大小
     * */
    public static Object arrayInc(Object obj,int len){
        Class<?>arr=obj.getClass().getComponentType();
        Object newArr=Array.newInstance(arr, len);
        int co=Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, co);
        return newArr;
    }
    /**
     * 打印
     * */
    public static void print(Object obj){
        Class<?>c=obj.getClass();
        if(!c.isArray()){
            return;
        }
        System.out.println("數組長度爲： "+Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i)+" ");
        }
    }
}

 

 

 

【運行結果】：

數組長度爲： 15

1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================

數組長度爲： 8

a b c null null null null null

 

動態代理

【案例】首先來看看如何得到類加載器：

class test{

}
class hello{
    public static void main(String[] args) {
        test t=new test();
        System.out.println("類加載器  "+t.getClass().getClassLoader().getClass().getName());
    }
}

 

【程序輸出】：

類加載器  sun.misc.Launcher$AppClassLoader

其實在java中有三種類類加載器。

1）Bootstrap ClassLoader 此加載器採用c++編寫，通常開發中不多見。

2）Extension ClassLoader 用來進行擴展類的加載，通常對應的是jre\lib\ext目錄中的類

3）AppClassLoader 加載classpath指定的類，是最經常使用的加載器。同時也是java中默認的加載器。

若是想要完成動態代理，首先須要定義一個InvocationHandler接口的子類，已完成代理的具體操做。

package Reflect;
import java.lang.reflect.*;

//定義項目接口
interface Subject {
    public String say(String name, int age);
}

// 定義真實項目
class RealSubject implements Subject {
    @Override
    public String say(String name, int age) {
        return name + "  " + age;
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;

    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}

class hello {
    public static void main(String[] args) {
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say("Rollen", 20);
        System.out.println(info);
    }
}

 

 

【運行結果】：

Rollen  20

類的生命週期

在一個類編譯完成以後，下一步就須要開始使用類，若是要使用一個類，確定離不開JVM。在程序執行中JVM經過裝載，連接，初始化這3個步驟完成。

類的裝載是經過類加載器完成的，加載器將.class文件的二進制文件裝入JVM的方法區，而且在堆區建立描述這個類的java.lang.Class對象。用來封裝數據。 可是同一個類只會被類裝載器裝載之前

連接就是把二進制數據組裝爲能夠運行的狀態。

 

連接分爲校驗，準備，解析這3個階段

校驗通常用來確認此二進制文件是否適合當前的JVM（版本），

準備就是爲靜態成員分配內存空間，。並設置默認值

解析指的是轉換常量池中的代碼做爲直接引用的過程，直到全部的符號引用均可以被運行程序使用（創建完整的對應關係）

完成以後，類型也就完成了初始化，初始化以後類的對象就能夠正常使用了，直到一個對象再也不使用以後，將被垃圾回收。釋放空間。

當沒有任何引用指向Class對象時就會被卸載，結束類的生命週期

將反射用於工廠模式

先來看看，若是不用反射的時候，的工廠模式吧：

 

http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html

 

interface fruit{
    public abstract void eat();
}

class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}

class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}

// 構造工廠類
// 也就是說之後若是咱們在添加其餘的實例的時候只須要修改工廠類就好了
class Factory{
    public static fruit getInstance(String fruitName){
        fruit f=null;
        if("Apple".equals(fruitName)){
            f=new Apple();
        }
        if("Orange".equals(fruitName)){
            f=new Orange();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a){
        fruit f=Factory.getInstance("Orange");
        f.eat();
    }

}

 

這樣，當咱們在添加一個子類的時候，就須要修改工廠類了。若是咱們添加太多的子類的時候，改的就會不少。

如今咱們看看利用反射機制：

package Reflect;

interface fruit{
    public abstract void eat();
}

class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}

class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}

class Factory{
    public static fruit getInstance(String ClassName){
        fruit f=null;
        try{
            f=(fruit)Class.forName(ClassName).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a){
        fruit f=Factory.getInstance("Reflect.Apple");
        if(f!=null){
            f.eat();
        }
    }
}

 

 

如今就算咱們添加任意多個子類的時候，工廠類就不須要修改。

 

上面的愛嗎雖然能夠經過反射取得接口的實例，可是須要傳入完整的包和類名。並且用戶也沒法知道一個接口有多少個可使用的子類，因此咱們經過屬性文件的形式配置所須要的子類。

下面咱們來看看： 結合屬性文件的工廠模式

首先建立一個fruit.properties的資源文件，

內容爲：

apple=Reflect.Apple
orange=Reflect.Orange

 

而後編寫主類代碼：

package Reflect;

import java.io.*;
import java.util.*;

interface fruit{
    public abstract void eat();
}

class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}

class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}

//操做屬性文件類
class init{
    public static Properties getPro() throws FileNotFoundException, IOException{
        Properties pro=new Properties();
        File f=new File("fruit.properties");
        if(f.exists()){
            pro.load(new FileInputStream(f));
        }else{
            pro.setProperty("apple", "Reflect.Apple");
            pro.setProperty("orange", "Reflect.Orange");
            pro.store(new FileOutputStream(f), "FRUIT CLASS");
        }
        return pro;
    }
}

class Factory{
    public static fruit getInstance(String ClassName){
        fruit f=null;
        try{
            f=(fruit)Class.forName(ClassName).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a) throws FileNotFoundException, IOException{
        Properties pro=init.getPro();
        fruit f=Factory.getInstance(pro.getProperty("apple"));
        if(f!=null){
            f.eat();
        }
    }
}

下面這個是一個比較完整的反射工具類，用來得到一個類裏面屬性的具體信息

package util;
import java.lang.reflect.*;
/**
 * 獲取Class的信息
 *
 */
public class ClassInfo {
  //須要反射的JAVA類型
  private static Class reflectionClass;
  private static String[][] relation;
  private static String[] constructors;
  private static String[] methods;
  private static String[] fields;

  //加載須要反射的類
  public static void load(String reflectionClassName) {
    try {
      reflectionClass = null;
      reflectionClass = Class.forName(reflectionClassName);
    } catch (ClassNotFoundException e) {
      System.err.println(e.getMessage());
    }
  }
  //獲取類關係
  public static String[][] getRelation() {
    String superClassName = reflectionClass.getSuperclass().getSimpleName();
    Class[] interfaceClass = reflectionClass.getInterfaces();
    if(superClassName == null)
      superClassName = "Have not super class!";
    if (reflectionClass.getInterfaces().length == 0) {
      relation = new String[2][1];
      relation[1][0] = "Have not interface!";
    }else {
      relation = new String[2][reflectionClass.getInterfaces().length];
      for (int i = 0; i < interfaceClass.length; i++) {
        relation[1][i] = interfaceClass[i].getName();
        System.out.println( "interfaceClass:"+relation[1][i] );
      }
    }
    relation[0][0] = superClassName;
    System.out.println( "superClassName:"+superClassName );
    return relation;
  }

  //獲取構造方法
  public static String[] getConstructors() {
    Constructor[] constructor = reflectionClass.getDeclaredConstructors();
    constructors = new String[constructor.length];
    for (int i = 0; i < constructor.length; i++) {
      Class[] paramType = constructor[i].getParameterTypes();
      String param = "";
      for (int j = 0; j < paramType.length; j++) {
        param += paramType[j].getSimpleName().toString() + " ";
      }
      constructors[i] = constructor[i].getName().toString()
                + "(" + param + ")";
      System.out.println("constructor:"+ constructors[i] );
    }
    return constructors;
  }
  //獲取類方法
  public static String[] getMethods() {
    Method[] method = reflectionClass.getDeclaredMethods();
    methods = new String[method.length];
    for (int i = 0; i < method.length; i++) {
      Class[] paramType = method[i].getParameterTypes();
      String param = "";
      for (int j = 0; j < paramType.length; j++) {
        param += paramType[j].getSimpleName().toString() + " ";
      }
      methods[i] = method[i].getName().toString()
            + "(" + param + ")";
      System.out.println("method:"+ methods[i]);
    }
    return methods;
  }
  //獲取類屬性
  public static String[] getFields() {
    Field[] field = reflectionClass.getDeclaredFields();
    fields = new String[field.length];
    for (int i = 0; i < field.length; i++) {
    field[i].setAccessible( true ); //容許訪問私有屬性
      fields[i] = field[i].toGenericString();
      String type=field[i].getGenericType().toString();
      System.out.println("fields:"+fields[i]+"   type:"+type);
    }
    return fields;
  }

  //私有方法，被外部調用
  private void testInvoke() {
    System.out.println("invoke!");
  }
  private void testInvoke(String str) {
    System.out.println("invoke!:" + str);
  }
}