Java基础——Java反射机制及IoC原理
生活随笔
收集整理的這篇文章主要介紹了
Java基础——Java反射机制及IoC原理
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
一、概念
?? ? ? 主要是指程序可以訪問，檢測和修改它本身狀態或行為的一種能力，并能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。在java中，只要給定類的名字， 那么就可以通過反射機制來獲得類的所有信息。
? ? ? ?反射是Java中一種強大的工具，能夠使我們很方便的創建靈活的代碼，這些代碼可以再運行時裝配，無需在組件之間進行源代碼鏈接。但是反射使用不當會成本很高！
? ? ? ?類中有什么信息，利用反射機制就能可以獲得什么信息，不過前提是得知道類的名字。
二、作用
? ? 1）在運行時判斷任意一個對象所屬的類；
? ? 2）在運行時獲取類的對象；
? ? 3）在運行時訪問java對象的屬性，方法，構造方法等。
三、優點與缺點
? ? ? ?首先要搞清楚為什么要用反射機制？直接創建對象不就可以了嗎，這就涉及到了動態與靜態的概念。?
? ? ? ?靜態編譯：在編譯時確定類型，綁定對象，即通過。?
? ? ? ?動態編譯：運行時確定類型，綁定對象。動態編譯最大限度發揮了java的靈活性，體現了多態的應用，有以降低類之間的藕合性。
? ? ? ?反射機制的優點：可以實現動態創建對象和編譯，體現出很大的靈活性（特別是在J2EE的開發中它的靈活性就表現的十分明顯）。通過反射機制我們可以獲得類的各種內容，進行了反編譯。對于JAVA這種先編譯再運行的語言來說，反射機制可以使代碼更加靈活，更加容易實現面向對象。
? ? ? ?比如，一個大型的軟件，不可能一次就把把它設計的很完美，當這個程序編譯后，發布了，當發現需要更新某些功能時，我們不可能要用戶把以前的卸載，再重新安裝新的版本，假如這樣的話，這個軟件肯定是沒有多少人用的。采用靜態的話，需要把整個程序重新編譯一次才可以實現功能的更新，而采用反射機制的話，它就可以不用卸載，只需要在運行時才動態的創建和編譯，就可以實現該功能。?
? ? ? ?反射機制的缺點：對性能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什么并且它 滿足我們的要求。這類操作總是慢于只直接執行相同的操作。
四、示例
1、通過一個對象獲取完整的包名和類名
注：所有類的對象其實都是Class類的實例
package Reflect;class Demo{//other codes... }class hello{public static void main(String[] args) {Demo demo=new Demo();System.out.println(demo.getClass().getName());} } 運行結果： Reflect.Demo 2、實例化Class類對象package Reflect;class Demo{//other codes... }class hello{public static void main(String[] args) {Class<?> demo1=null;Class<?> demo2=null;Class<?> demo3=null;try{//一般盡量采用這種形式demo1=Class.forName("Reflect.Demo");}catch(Exception e){e.printStackTrace();}demo2=new Demo().getClass();demo3=Demo.class;System.out.println("類名稱 "+demo1.getName());System.out.println("類名稱 "+demo2.getName());System.out.println("類名稱 "+demo3.getName());} } 運行結果： 類名稱 Reflect.Demo 類名稱 Reflect.Demo 類名稱 Reflect.Demo 3、通過Class實例化其他類的對象 package Reflect;class Person{public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString(){return "["+this.name+" "+this.age+"]";}private String name;private int age; }class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Person per=null;try {per=(Person)demo.newInstance();} catch (InstantiationException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();}per.setName("Rollen");per.setAge(20);System.out.println(per);} } 運行結果： [Rollen 20]
? ? ? ?但是注意一下，當我們把Person中的默認的無參構造函數取消的時候，比如自己定義只定義一個有參數的構造函數之后，會出現錯誤：
比如定義了一個構造函數：
public Person(String name, int age) { this.age=age;this.name=name; }然后繼續運行上面的程序，會出現：java.lang.InstantiationException: Reflect.Person at java.lang.Class.newInstance0(Class.java:340) at java.lang.Class.newInstance(Class.java:308) at Reflect.hello.main(hello.java:39) Exception in thread "main" java.lang.NullPointerException at Reflect.hello.main(hello.java:47)? ? ? ?所以大家以后再編寫使用Class實例化其他類的對象的時候，一定要自己定義無參的構造函數。
4、通過Class調用其他類中的構造函數 （也可以通過這種方式通過Class創建其他類的對象）
package Reflect;import java.lang.reflect.Constructor;class Person{public Person() { }public Person(String name){this.name=name;}public Person(int age){this.age=age;}public Person(String name, int age) {this.age=age;this.name=name;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString(){return "["+this.name+" "+this.age+"]";}private String name;private int age; }class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Person per1=null;Person per2=null;Person per3=null;Person per4=null;//取得全部的構造函數Constructor<?> cons[]=demo.getConstructors();try{per1=(Person)cons[0].newInstance();per2=(Person)cons[1].newInstance("Rollen");per3=(Person)cons[2].newInstance(20);per4=(Person)cons[3].newInstance("Rollen",20);}catch(Exception e){e.printStackTrace();}System.out.println(per1);System.out.println(per2);System.out.println(per3);System.out.println(per4);} } 運行結果： [null 0] [Rollen 0] [null 20] [Rollen 20] 5、返回一個類實現的接口package Reflect;interface China{public static final String name="Rollen";public static int age=20;public void sayChina();public void sayHello(String name, int age); }class Person implements China{public Person() {}public Person(String sex){this.sex=sex;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic void sayChina(){System.out.println("hello ,china");}@Overridepublic void sayHello(String name, int age){System.out.println(name+" "+age);}private String sex; }class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}//保存所有的接口Class<?> intes[]=demo.getInterfaces();for (int i = 0; i < intes.length; i++) {System.out.println("實現的接口 "+intes[i].getName());}} } 運行結果： 實現的接口 Reflect.China（以下幾個例子，都會用到這個例子的Person類，所以為節省篇幅，此處不再粘貼Person的代碼部分，只粘貼主類hello的代碼）
6、取得其他類中的父類
class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}//取得父類Class<?> temp=demo.getSuperclass();System.out.println("繼承的父類為： "+temp.getName());} } 運行結果： 繼承的父類為： java.lang.Object 7、獲得其他類中的全部構造函數
//這個例子需要在程序開頭添加import java.lang.reflect.*; class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Constructor<?>cons[]=demo.getConstructors();for (int i = 0; i < cons.length; i++) {System.out.println("構造方法： "+cons[i]);}} } 運行結果： 構造方法： public Reflect.Person() 構造方法： public Reflect.Person(java.lang.String) class hello{public static void main(String[] args) {Class<?> demo=null;try{demo=Class.forName("Reflect.Person");}catch (Exception e) {e.printStackTrace();}Constructor<?>cons[]=demo.getConstructors();for (int i = 0; i < cons.length; i++) {Class<?> p[]=cons[i].getParameterTypes();System.out.print("構造方法： ");int mo=cons[i].getModifiers();System.out.print(Modifier.toString(mo)+" ");System.out.print(cons[i].getName());System.out.print("(");for(int j=0;j<p.length;++j){System.out.print(p[j].getName()+" arg"+i);if(j<p.length-1){System.out.print(",");}}System.out.println("){}");}} } 運行結果：
構造方法： public Reflect.Person(){} 構造方法： public Reflect.Person(java.lang.String arg1){}
8、取得其他類的全部屬性，將這些整理在一起，也就是通過class取得一個類的全部框架
class hello {public static void main(String[] args) {Class<?> demo = null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}System.out.println("===============本類屬性========================");// 取得本類的全部屬性Field[] field = demo.getDeclaredFields();for (int i = 0; i < field.length; i++) {// 權限修飾符int mo = field[i].getModifiers();String priv = Modifier.toString(mo);// 屬性類型Class<?> type = field[i].getType();System.out.println(priv + " " + type.getName() + " "+ field[i].getName() + ";");}System.out.println("===============實現的接口或者父類的屬性========================");// 取得實現的接口或者父類的屬性Field[] filed1 = demo.getFields();for (int j = 0; j < filed1.length; j++) {// 權限修飾符int mo = filed1[j].getModifiers();String priv = Modifier.toString(mo);// 屬性類型Class<?> type = filed1[j].getType();System.out.println(priv + " " + type.getName() + " "+ filed1[j].getName() + ";");}} } 運行結果： ===============本類屬性======================== private java.lang.String sex; ===============實現的接口或者父類的屬性======================== public static final java.lang.String name; public static final int age; 9、通過反射調用其他類中的方法class hello {public static void main(String[] args) {Class<?> demo = null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}try{//調用Person類中的sayChina方法Method method=demo.getMethod("sayChina");method.invoke(demo.newInstance());//調用Person的sayHello方法method=demo.getMethod("sayHello", String.class,int.class);method.invoke(demo.newInstance(),"Rollen",20);}catch (Exception e) {e.printStackTrace();}} } 運行結果： hello ,china Rollen 20
10、調用其他類的set和get方法
class hello {public static void main(String[] args) {Class<?> demo = null;Object obj=null;try {demo = Class.forName("Reflect.Person");} catch (Exception e) {e.printStackTrace();}try{obj=demo.newInstance();}catch (Exception e) {e.printStackTrace();}setter(obj,"Sex","男",String.class);getter(obj,"Sex");}/*** @param obj 操作的對象* @param att 操作的屬性* */public static void getter(Object obj, String att) {try {Method method = obj.getClass().getMethod("get" + att);System.out.println(method.invoke(obj));} catch (Exception e) {e.printStackTrace();}}/*** @param obj 操作的對象 * @param att 操作的屬性* @param value 設置的值* @param type 參數的屬性* */public static void setter(Object obj, String att, Object value,Class<?> type) {try {Method method = obj.getClass().getMethod("set" + att, type);method.invoke(obj, value);} catch (Exception e) {e.printStackTrace();}} }// end class 運行結果： 男 11、通過反射操作屬性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 12、通過反射取得并修改數組的信息
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 13、通過反射修改數組大小
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 14、動態代理
首先來看看如何獲得類加載器：
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 {@Overridepublic 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);}@Overridepublic 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對象時就會被卸載，結束類的生命周期。
Spring中的IoC的實現原理就是工廠模式加反射機制。
1、我們首先看一下不用反射機制時的工廠模式
2、利用反射機制的工廠模式
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();}} }
? ? ? ?現在就算我們添加任意多個子類的時候，工廠類就不需要修改。
? ? ? ?使用反射機制的工廠模式可以通過反射取得接口的實例，但是需要傳入完整的包和類名。而且用戶也無法知道一個接口有多少個可以使用的子類，所以我們通過屬性文件的形式配置所需要的子類。
3、使用反射機制并結合屬性文件的工廠模式（即IoC）首先創建一個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();}} } 運行結果： Apple
總結
以上是生活随笔為你收集整理的Java基础——Java反射机制及IoC原理的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 信用卡没到账单日可以提前还款吗，可以
- 下一篇： Java基础——Java多线程中slee