java反射代理_Java代理的作用和實現

1. java反射的作用。

1. Java反射包reflection提供對Class，Method，field，constructor1 等信息的封裝類型。
2. 通過這些api可以輕易獲得一個類的各種信息並且可以進行實例化，方法調用等。
類中的private參數可以通過setaccessible方法強制獲取。
3. 反射的作用可謂是博大精深，JDK動態代理生成代理類的位元組碼後，首先把這個類通過defineclass定義成一個類，然後用class.for(name)會把該類載入到jvm，之後我們就可以通過，A.class.GetMethod()獲取其方法，然後通過invoke調用其方法，在調用這個方法時，實際上會通過被代理類的引用再去調用原方法。

2. JAVA中反射是什麼

JAVA中反射是動態獲取信息以及動態調用對象方法的一種反射機制。

Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性；並且能改變它的屬性。而這也是Java被視為動態語言的一個關鍵性質。

Java反射的功能是在運行時判斷任意一個對象所屬的類，在運行時構造任意一個類的對象，在運行時判斷任意一個類所具有的成員變數和方法，在運行時調用任意一個對象的方法，生成動態代理。

(2)java反射代理擴展閱讀：

JAVA中反射實例：

1、Class superClass=clazz.getSuperclass();//獲取父類。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//獲取實現介面。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//構造方法。

System.out.println("getConstructors:"+cons.length)。

參考資料來源：網路： JAVA反射機制

3. java中什麼是反射，反射怎麼用，什麼場景用有沒有替代方案

1、反射簡言之就是在編譯時無法拿到某一個類，但是可以在運行時動態獲取這個類，這樣去使用某一個類，就是反射的使用場景。
2、代替反射或者類似的操作，可以通過DI實現IOC .依賴注入，動態代理。

4. java中的反射可以做什麼

Java反射機制主要提供了以下功能：
在運行時判斷任意一個對象所屬的類；
在運行時構造任意一個類的對象；
在運行時判斷任意一個類所具有的成員變數和方法；
在運行時調用任意一個對象的方法；生成動態代理。
JAVA有著一個非常突出的動態相關機制：Reflection。
這個字的意思是「反射、映象、倒影」，用在Java身上指的是我們可以於運行時載入、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以載入一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods。這種「看透class」的能力（the ability of the program to examine itself）被稱為introspection（內省、內觀、反省）。Reflection和introspection是常被並提的兩個術語。

5. java課程分享Java的反射機制

Java反射機制是一個非常強大的功能，在很多大型項目比如Spring,Mybatis都可以看見反射的身影。通過反射機制我們可以在運行期間獲取對象的類型信息，利用這一特性我們可以實現工廠模式和代理模式等設計模式，同時也可以解決Java泛型擦除等令人苦惱的問題。下面java課程http://www.kmbdqn.com/就從實際應用的角度出發，來應用一下Java的反射機制。

反射基礎

p.s:本文需要讀者對反射機制的API有一定程度的了解，如果之前沒有接觸過的話，建議先看一下官方文檔的QuickStart。

在應用反射機制之前，首先我們先來看一下如何獲取一個對象對應的反射類Class，在Java中我們有三種方法可以獲取一個對象的反射類。

通過getClass方法

在Java中，每一個Object都有一個getClass方法，通過getClass方法我們可以獲取到這個對象對應的反射類：

Strings="ziwenxie";

Class<?>c=s.getClass();

通過forName方法

我們也可以調用Class類的靜態方法forName：

Class<?>c=Class.forName("java.lang.String");

使用.class

或者我們也可以直接使用.class：

Class<?>c=String.class;

獲取類型信息

在文章開頭我們就提到反射的一大好處就是可以允許我們在運行期間獲取對象的類型信息，下面我們通過一個例子來具體看一下。

首先我們在typeinfo.interfacea包下面新建一個介面A：

packagetypeinfo.interfacea;

publicinterfaceA{voidf();}

接著我們在typeinfo.packageaccess包下面新建一個介面C，介面C繼承自介面A，並且我們還另外創建了幾個用於測試的方法，注意下面幾個方法的許可權都是不同的。

6. Java代理的作用和實現

JDK 動態代理

動態代理的核心其實就是代理對象的生成，即 Proxy.newProxyInstance(classLoader, proxyInterface, handler)。

讓我們進入newProxyInstance方法觀摩下，核心代碼其實就三行。

這個方法需要三個參數：

ClassLoader，用於載入代理類的 Loader 類，通常這個 Loader 和被代理的類是同一個 Loader 類。
Interfaces，是要被代理的那些那些介面。
InvocationHandler，就是用於執行除了被代理介面中方法之外的用戶自定義的操作，也是用戶需要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。
//獲取代理類 Class cl = getProxyClass(loader, interfaces);

//獲取帶有InvocationHandler參數的構造方法 Constructor cons = cl.getConstructor(constructorParams);

//把handler傳入構造方法生成實例 return (Object) cons.newInstance(new Object[] { h });

一個典型的動態代理創建對象過程可分為以下四個步驟：

1、通過實現InvocationHandler介面創建調用處理器

IvocationHandler handler = new InvocationHandlerImpl(...);

2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類

Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型

Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入

Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。

Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),

new Class[]{Subject.class}, new InvocationHandlerImpl (real));

生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。

創建代理對象時序圖

獲取代理類

getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：

在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。

// 緩存的key使用介面名稱生成的List Object key = Arrays.asList(interfaceNames);

synchronized (cache) {

do {

Object value = cache.get(key);

// 緩存里保存了代理類的引用 if (value instanceof Reference) {

proxyClass = (Class) ((Reference) value).get();

}

if (proxyClass != null) {

// 代理類已經存在則返回

return proxyClass;

} else if (value == pendingGenerationMarker) {

// 如果代理類正在產生，則等待

try {

cache.wait();

} catch (InterruptedException e) {

}

continue;

} else {

//沒有代理類，則標記代理准備生成

cache.put(key, pendingGenerationMarker);

break;

}

} while (true);

}

生成並載入代理類

代理類的生成主要是以下這兩行代碼：

//生成代理類的位元組碼文件並保存到硬碟中(默認不保存到硬碟) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);

//使用類載入器將位元組碼載入到內存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

代理類的生成過程

ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
JD-GUI這樣的反編譯軟體打開jrelib t.jar來一探究竟，以下是其核心代碼的分析。

//添加介面中定義的方法，此時方法體為空 for (int i = 0; i < this.interfaces.length; i++) {

localObject1 = this.interfaces[i].getMethods();

for (int k = 0; k < localObject1.length; k++) {

addProxyMethod(localObject1[k], this.interfaces[i]);

}

}

//添加一個帶有InvocationHandler的構造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);

//循環生成方法體代碼（省略） //方法體里生成調用InvocationHandler的invoke方法代碼。（此處有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;")

//將生成的位元組碼，寫入硬碟，前面有個if判斷，默認情況下不保存到硬碟。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class");

localFileOutputStream.write(this.val$classFile);

生成的代理類源碼

那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。

public class ProxyBusiness extends Proxy implements IBusiness, IBusiness2 {

private LogInvocationHandler h;

@Override public void doSomeThing2() {

try {

Method m = (h.target).getClass().getMethod("doSomeThing2",null);

h.invoke(this, m, null);

} catch (Throwable e) {

// 異常處理（略）

}

}

@Override public boolean doSomeThing() {

try {

Method m = (h.target).getClass().getMethod("doSomeThing", null);

return (Boolean) h.invoke(this, m, null);

} catch (Throwable e) {

// 異常處理（略）

}

return false;

}

public ProxyBusiness(LogInvocationHandler h) {

this.h = h;

}

測試代理的代碼如下：

//測試public static void main(String[] args) {

//構建AOP的Advice

LogInvocationHandler handler = new LogInvocationHandler(new Business());

new ProxyBusiness(handler).doSomeThing();

new ProxyBusiness(handler).doSomeThing2();

}

下面看一個自定義代理的實現。

被代理類介面

public interface Subject {

public void doSomething();

}

被代理類

//目標對象public class RealSubject implements Subject{ public void doSomething() {

System.out.println( "call doSomething()" );

}

}

調用處理器(切面)

public class ProxyHandler implements InvocationHandler {

private Object proxied;

public ProxyHandler( Object proxied ) {

this.proxied = proxied;

}

public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable {

//在轉調具體目標對象之前，可以執行一些功能處理System.out.println( "doSomething before" ); //轉調具體目標對象的方法

return method.invoke( proxied, args);

//在轉調具體目標對象之後，可以執行一些功能處理System.out.println( "doSomething after" );

}

}

測試我們的代理實現

public class DynamicProxy {

public static void main( String args[] ) {

RealSubject real = new RealSubject();

Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),

new Class[]{Subject.class}, new ProxyHandler(real));

proxySubject.doSomething(); //write proxySubject class binary data to file

createProxyClassFile();

}

public static void createProxyClassFile() {

String name = "ProxySubject";

byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );

try{

FileOutputStream out = new FileOutputStream( name + ".class" );

out.write( data );

out.close();

}catch( Exception e ) {

e.printStackTrace();

}

}

}

運行結果：

doSomething beforecall doSomething()doSomething after

Proxy 介面

Proxy 的主要靜態變數

// 映射表：用於維護類裝載器對象到其對應的代理類緩存private static Map loaderToCache = new WeakHashMap();// 標記：用於標記一個動態代理類正在被創建中private static Object pendingGenerationMarker = new Object();// 同步表：記錄已經被創建的動態代理類類型，主要被方法 isProxyClass 進行相關的判斷private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());// 關聯的調用處理器引用protected InvocationHandler h;

Proxy的構造方法// 由於 Proxy 內部從不直接調用構造函數，所以 private 類型意味著禁止任何調用private Proxy() {}// 由於 Proxy 內部從不直接調用構造函數，所以 protected 意味著只有子類可以調用protected Proxy(InvocationHandler h) {this.h = h;}

ProxySubject 源碼

創建的代理類 ProxySubject.class

import java.lang.reflect.*;

public final class ProxySubject extends Proxy implements Subject{

private static Method m1;

private static Method m0;

private static Method m3;

private static Method m2;

public ProxySubject(InvocationHandler invocationhandler){

super(invocationhandler);

}

public final boolean equals(Object obj){

try {

return ((Boolean)super.h.invoke(this, m1, new Object[] {

})).booleanValue();

}catch(Error _ex) {

}catch(Throwable throwable){

throw new UndeclaredThrowableException(throwable);

}

}

public final int hashCode() {

try {

return ((Integer)super.h.invoke(this, m0, null)).intValue();

}catch(Error _ex) {

}catch(Throwable throwable){

throw new UndeclaredThrowableException(throwable);

}

}

/*關鍵部分*/

public final void doSomething() {

try {

// Proxy類中protected InvocationHandler h;關聯的調用處理器引用

super.h.invoke(this, m3, null);

return;

}catch(Error _ex) {

}catch(Throwable throwable) {

throw new UndeclaredThrowableException(throwable);

}

}

public final String toString() {

try {

return (String)super.h.invoke(this, m2, null);

} catch(Error _ex) {

} catch(Throwable throwable){

throw new UndeclaredThrowableException(throwable);

}

}

static{

try {

m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {

Class.forName("java.lang.Object")

});

m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);

m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

}catch(NoSuchMethodException nosuchmethodexception) {

throw new NoSuchMethodError(nosuchmethodexception.getMessage());

}catch(ClassNotFoundException classnotfoundexception){

throw new NoClassDefFoundError(classnotfoundexception.getMessage());

}

}

}

CGLib 動態代理

動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。

public static void main(String[] args) {

byteCodeGe();

}

public static void byteCodeGe() {

//創建一個織入器

Enhancer enhancer = new Enhancer();

//設置父類

enhancer.setSuperclass(Business.class);

//設置需要織入的邏輯

enhancer.setCallback(new LogIntercept());

//使用織入器創建子類

IBusiness2 newBusiness = (IBusiness2) enhancer.create();

newBusiness.doSomeThing2();

}

* 記錄日誌

*/ public static class LogIntercept implements MethodInterceptor {

@Override

public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {

//執行原有邏輯，注意這里是invokeSuper

Object rev = proxy.invokeSuper(target, args);

//執行織入的日誌

if (method.getName().equals("doSomeThing2")) {

System.out.println("記錄日誌");

}

return rev;

}

}

7. java中的反射機制是什麼有什麼作用呢求解，謝謝。

Java反射機制詳解

1. 反射機制是什麼

反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。

2. 反射機制能做什麼

反射機制主要提供了以下功能：

在運行時判斷任意一個對象所屬的類；
在運行時構造任意一個類的對象；
在運行時判斷任意一個類所具有的成員變數和方法；
在運行時調用任意一個對象的方法；
生成動態代理。

3. 反射機制的相關API

通過一個對象獲得完整的包名和類名

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
TestReflecttestReflect=newTestReflect();
System.out.println(testReflect.getClass().getName());
//結果net.xsoftlab.ke.TestReflect
}
}

實例化Class類對象

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
Class<?>class2=null;
Class<?>class3=null;
//一般採用這種形式
class1=Class.forName("net.xsoftlab.ke.TestReflect");
class2=newTestReflect().getClass();
class3=TestReflect.class;
System.out.println("類名稱"+class1.getName());
System.out.println("類名稱"+class2.getName());
System.out.println("類名稱"+class3.getName());
}
}

獲取一個對象的父類與實現的介面

packagenet.xsoftlab.ke;
importjava.io.Serializable;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//取得父類
Class<?>parentClass=clazz.getSuperclass();
System.out.println("clazz的父類為："+parentClass.getName());
//clazz的父類為：java.lang.Object
//獲取所有的介面
Class<?>intes[]=clazz.getInterfaces();
System.out.println("clazz實現的介面有：");
for(inti=0;i<intes.length;i++){
System.out.println((i+1)+"："+intes[i].getName());
}
//clazz實現的介面有：
//1：java.io.Serializable
}
}

獲取某個類中的全部構造函數 - 詳見下例

通過反射機制實例化一個類的對象

packagenet.xsoftlab.ke;
importjava.lang.reflect.Constructor;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
class1=Class.forName("net.xsoftlab.ke.User");
//第一種方法，實例化默認構造方法，調用set賦值
Useruser=(User)class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
//結果User[age=20,name=Rollen]
//第二種方法取得全部的構造函數使用構造函數賦值
Constructor<?>cons[]=class1.getConstructors();
//查看每個構造方法需要的參數
for(inti=0;i<cons.length;i++){
Class<?>clazzs[]=cons[i].getParameterTypes();
System.out.print("cons["+i+"](");
for(intj=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//結果
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user=(User)cons[0].newInstance("Rollen");
System.out.println(user);
//結果User[age=0,name=Rollen]
user=(User)cons[1].newInstance(20,"Rollen");
System.out.println(user);
//結果User[age=20,name=Rollen]
}
}
classUser{
privateintage;
privateStringname;
publicUser(){
super();
}
publicUser(Stringname){
super();
this.name=name;
}
publicUser(intage,Stringname){
super();
this.age=age;
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"User[age="+age+",name="+name+"]";
}
}

獲取某個類的全部屬性

packagenet.xsoftlab.ke;
importjava.io.Serializable;
importjava.lang.reflect.Field;
importjava.lang.reflect.Modifier;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
System.out.println("===============本類屬性===============");
//取得本類的全部屬性
Field[]field=clazz.getDeclaredFields();
for(inti=0;i<field.length;i++){
//許可權修飾符
intmo=field[i].getModifiers();
Stringpriv=Modifier.toString(mo);
//屬性類型
Class<?>type=field[i].getType();
System.out.println(priv+""+type.getName()+""+field[i].getName()+";");
}

System.out.println("==========實現的介面或者父類的屬性==========");
//取得實現的介面或者父類的屬性
Field[]filed1=clazz.getFields();
for(intj=0;j<filed1.length;j++){
//許可權修飾符
intmo=filed1[j].getModifiers();
Stringpriv=Modifier.toString(mo);
//屬性類型
Class<?>type=filed1[j].getType();
System.out.println(priv+""+type.getName()+""+filed1[j].getName()+";");
}
}
}

通過反射機制調用某個類的方法

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//調用TestReflect類中的reflect1方法
Methodmethod=clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
//Java反射機制-調用某個類的方法1.
//調用TestReflect的reflect2方法
method=clazz.getMethod("reflect2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"張三");
//Java反射機制-調用某個類的方法2.
//age->20.name->張三
}
publicvoidreflect1(){
System.out.println("Java反射機制-調用某個類的方法1.");
}
publicvoidreflect2(intage,Stringname){
System.out.println("Java反射機制-調用某個類的方法2.");
System.out.println("age->"+age+".name->"+name);
}
}

通過反射機制操作某個類的屬性

packagenet.xsoftlab.ke;
importjava.lang.reflect.Field;
publicclassTestReflect{
privateStringproprety=null;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
Objectobj=clazz.newInstance();
//可以直接對private的屬性賦值
Fieldfield=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"Java反射機制");
System.out.println(field.get(obj));
}
}

4. 反射機制的應用實例

在泛型為Integer的ArrayList中存放一個String類型的對象。

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
ArrayList<Integer>list=newArrayList<Integer>();
Methodmethod=list.getClass().getMethod("add",Object.class);
method.invoke(list,"Java反射機制實例。");
System.out.println(list.get(0));
}
}

通過反射取得並修改數組的信息

packagenet.xsoftlab.ke;
importjava.lang.reflect.Array;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
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));
}
}

將反射機制應用於工廠模式

packagenet.xsoftlab.ke;
interfacefruit{
publicabstractvoideat();
}
classAppleimplementsfruit{
publicvoideat(){
System.out.println("Apple");
}
}
classOrangeimplementsfruit{
publicvoideat(){
System.out.println("Orange");
}
}
classFactory{
publicstaticfruitgetInstance(StringClassName){
fruitf=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch(Exceptione){
e.printStackTrace();
}
returnf;
}
}
/**
*對於普通的工廠模式當我們在添加一個子類的時候，就需要對應的修改工廠類。當我們添加很多的子類的時候，會很麻煩。
*Java工廠模式可以參考
*http://ke.xsoftlab.net/view/java-factory-pattern
*
*現在我們利用反射機制實現工廠模式，可以在不修改工廠類的情況下添加任意多個子類。
*
*但是有一點仍然很麻煩，就是需要知道完整的包名和類名，這里可以使用properties配置文件來完成。
*
*java讀取properties配置文件的方法可以參考
*http://ke.xsoftlab.net/view/java-read-the-properties-configuration-file
*
*@authorxsoftlab.net
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
fruitf=Factory.getInstance("net.xsoftlab.ke.Apple");
if(f!=null){
f.eat();
}
}
}

我有一個微信公眾號，經常會分享一些Java技術相關的干貨，還有一些學習資源。
如果你喜歡我的分享，可以用微信搜索「Java團長」或者「javatuanzhang」關注。

導航:首頁 > 編程語言 > java反射代理

java反射代理

Java反射機制詳解

與java反射代理相關的資料