反射可以幫助我們查看指定類型中的信息、創建類型的實例，調用類型的方法。我們平時使用框架，例如Spring、EJB、Hibernate等都大量的使用了反射技術。
反射簡單示例
下面來演示反射相關的基本操作
首先是基礎代碼，我們定義一個接口及其實現，作為我們反射操作的目標：
代碼如下：
interface HelloWorldService
{
void sayHello(String name);
}
class MyHelloWorld implements HelloWorldService
{
public String name;
public void sayHello(String name)
{
System.out.println("Hello " + name + ".");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
獲取方法及字段信息
下面的代碼會輸出給定類型中的方法和字段的聲明信息：
代碼如下：
private static void printClassTypeInfo(String type) throws ClassNotFoundException
{
Class classType = Class.forName(type);
Method[] methods = classType.getDeclaredMethods();
System.out.println("Methods info as below:");
for(Method method : methods)
{
System.out.println(method.toGenericString());
}
Field[] fields = classType.getFields();
System.out.println("Fields info as below:");
for (Field field : fields)
{
System.out.println(field.toGenericString());
}
}
在使用反射時，我們一般會使用java.lang.reflect包中的內容。
然後我們調用下面的代碼：
代碼如下：
printClassTypeInfo("sample.reflection.MyHelloWorld");
輸出結果如下：
代碼如下：
Methods info as below:
public void sample.reflection.MyHelloWorld.sayHello(java.lang.String)
public java.lang.String sample.reflection.MyHelloWorld.getName()
public void sample.reflection.MyHelloWorld.setName(java.lang.String)
Fields info as below:
public java.lang.String sample.reflection.MyHelloWorld.name
實例化對象
我們可以使用class.netInstance的方式來創建一個對象，代碼如下：
代碼如下：
private static void createInstanceTest() throws ClassNotFoundException, InstantiationException, IllegalAccessException
{
Class classType = Class.forName("sample.reflection.MyHelloWorld");
MyHelloWorld hello = (MyHelloWorld)classType.newInstance();
hello.sayHello("Zhang San");
}
輸出結果：
代碼如下：
Hello Zhang San.
調用對象的方法
我們可以通過方法的名稱以及參數類型構建一個Method實例，然後調用Method的invoke方法，來觸發方法。
示例代碼如下：
代碼如下：
private static void invokeMethodTest() throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException
{
Class classType = Class.forName("sample.reflection.MyHelloWorld");
MyHelloWorld hello = (MyHelloWorld)classType.newInstance();
Method method = classType.getMethod("sayHello", new Class[]{String.class});
method.invoke(hello, new Object[]{"Zhang San"});
}
輸出結果同上。
修改字段的值
和C#不同，Java中一般使用setxxx和getxxx顯示為屬性賦值，因此Java中並沒有Property類型，而是有Field類型。
我們可以對Field的值進行修改，代碼如下：
代碼如下：
private static void setFieldTest() throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException
{
Class classType = Class.forName("sample.reflection.MyHelloWorld");
MyHelloWorld hello = (MyHelloWorld)classType.newInstance();
System.out.println("name is " + hello.name);
Field field = classType.getField("name");
field.set(hello, "Zhang San");
System.out.println("name is " + hello.name);
}
執行結果如下：
代碼如下：
name is null
name is Zhang San
可以看出，我們成功的修改了name的值。
Annotation探索
一開始我們提到，反射是很多技術的基礎，Annotation就是這樣的，我們可以把Annotation看做是C#中的Attribute，它可以對類型、方法、屬性、字段、方法參數等信息進行修飾。我們可以使用“@+Annotation名”的方式來使用Annotation。
Annotation基本操作
來看下面的代碼，我們定義了基於Type、Method、Parameter和Field上面的Annotation示例：
代碼如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface ClassAnnotation
{
public String value();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface MethodAnnotation
{
public String methodName();
public String returnType();
}
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface ParameterAnnotation
{
public String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface FieldAnnotation
{
public String value();
}
接著，我們定義了一個MyClass類型，使用了上述的Annotation：
代碼如下：
@ClassAnnotation("這是作用在類型上的Annotation")
class MyClass
{
@MethodAnnotation(methodName="printInfo", returnType="void")
public void printInfo(String info)
{
System.out.println(info);
}
@MethodAnnotation(methodName="printError", returnType="void")
public void printError(@ParameterAnnotation("這是作用在參數上的Annotation")String error)
{
System.err.println(error);
}
@FieldAnnotation("這是作用在字段上的Annotation")
public int count;
}
對於使用了Annotation，我們可以獲取其中的信息，下面兩種方式都可以獲取Annotation，第一種方式是通過反射遍歷類型及其方法、字段，一一讀取Annotation信息；第二種方式是讀取指定類型的Annotation：
代碼如下：
讀取Annotation方式一
private static void annotationTest1()
{
MyClass temp = new MyClass();
Annotation[] annotations = temp.getClass().getAnnotations();
for(Annotation a : annotations)
{
System.out.println(a.toString());
}
Method[] methods = temp.getClass().getDeclaredMethods();
for(Method method : methods)
{
annotations = method.getAnnotations();
for(Annotation a : annotations)
{
System.out.println(a.toString());
}
Annotation[][] paraAnnotations = method.getParameterAnnotations();
for(int i = 0; i < paraAnnotations.length; i++)
{
for (Annotation a : paraAnnotations[i])
{
System.out.println(a.toString());
}
}
}
Field[] fields = temp.getClass().getFields();
for (Field field : fields)
{
annotations = field.getAnnotations();
for(Annotation a : annotations)
{
System.out.println(a.toString());
}
}
}
代碼如下：
讀取Annotation方式二
private static void annotationTest2() throws ClassNotFoundException
{
Class classType = Class.forName("sample.reflection.annotation.MyClass");
boolean flag = classType.isAnnotationPresent(ClassAnnotation.class);
if (flag)
{
ClassAnnotation annotation = (ClassAnnotation) classType.getAnnotation(ClassAnnotation.class);
System.out.println(annotation.toString());
}
Method[] methods = classType.getMethods();
for(Method method : methods)
{
if (method.isAnnotationPresent(MethodAnnotation.class))
{
System.out.println(((MethodAnnotation)method.getAnnotation(MethodAnnotation.class)).toString());
}
Annotation[][] paraAnnotations = method.getParameterAnnotations();
for(int i = 0; i < paraAnnotations.length; i++)
{
for (Annotation a : paraAnnotations[i])
{
System.out.println(a.toString());
}
}
}
Field[] fields = classType.getFields();
for (Field field:fields)
{
if (field.isAnnotationPresent(FieldAnnotation.class))
{
System.out.println(((FieldAnnotation)field.getAnnotation(FieldAnnotation.class)).toString());
}
}
}
上述兩個方法的輸出都是一樣的，如下：
代碼如下：
@sample.reflection.annotation.ClassAnnotation(value=這是作用在類型上的Annotation)
@sample.reflection.annotation.MethodAnnotation(methodName=printInfo, returnType=void)
@sample.reflection.annotation.MethodAnnotation(methodName=printError, returnType=void)
@sample.reflection.annotation.ParameterAnnotation(value=這是作用在參數上的Annotation)
@sample.reflection.annotation.FieldAnnotation(value=這是作用在字段上的Annotation)
在WebService中使用Annotation
上述代碼看上去可能有些枯燥，不能顯示出Annotation的威力，那麼我們接下來看WebService，在WebService中，我們可以使用WebMethod、WebParam等Annotation來聲明方法或者參數。
接下來，我們來實現一個非常簡單的Web服務：
代碼如下：
@WebService(targetNamespace="http://test", serviceName="HelloService")
public class HelloServiceProvider
{
@WebResult(name="HelloString")
@WebMethod
public String sayHello(@WebParam(name="userName") String name)
{
return "Hello " + name;
}
@Oneway
@WebMethod(action="userLogin", operationName="userLogin")
public void login()
{
System.out.println("User has logged on.");
}
public static void main(String[] args)
{
Thread thread = new Thread(new HelloServicePublisher());
thread.start();
}
}
然後定義一個Publisher：
代碼如下：
class HelloServicePublisher implements Runnable
{
public void run()
{
Endpoint.publish("http://localhost:8888/test/HelloService", new HelloServiceProvider());
}
}
在命令行中，我們定位到源代碼路徑，執行下面的命令：
代碼如下：
wsgen -cp . HelloServiceProvider
wsgen位於JDK的bin目錄中。
然後我們啟動HelloServiceProvider，在浏覽器中輸入如下地址：http://localhost:8888/test/HelloService，可以看到如下信息：
點擊WSDL鏈接，可以看到：
代碼如下：
WSDL信息
<!-- Published by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. --><!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.2.4-b01. --><definitions targetNamespace="http://test" name="HelloService"><types><xsd:schema><xsd:import namespace="http://test" schemaLocation="http://localhost:8888/test/HelloService?xsd=1"/></xsd:schema></types><message name="sayHello"><part name="parameters" element="tns:sayHello"/></message><message name="sayHelloResponse"><part name="parameters" element="tns:sayHelloResponse"/></message><message name="userLogin"><part name="parameters" element="tns:userLogin"/></message><portType name="HelloServiceProvider"><operation name="sayHello"><input wsam:Action="http://test/HelloServiceProvider/sayHelloRequest" message="tns:sayHello"/><output wsam:Action="http://test/HelloServiceProvider/sayHelloResponse" message="tns:sayHelloResponse"/></operation><operation name="userLogin"><input wsam:Action="userLogin" message="tns:userLogin"/></operation></portType><binding name="HelloServiceProviderPortBinding" type="tns:HelloServiceProvider"><soap:binding transport="http://schemas.xmlsoap.org/soap/http" /><operation name="sayHello"><soap:operation soapAction=""/><input><soap:body use="literal"/></input><output><soap:body use="literal"/></output></operation><operation name="userLogin"><soap:operation soapAction="userLogin"/><input><soap:body use="literal"/></input></operation></binding><service name="HelloService"><port name="HelloServiceProviderPort" binding="tns:HelloServiceProviderPortBinding"><soap:address location="http://localhost:8888/test/HelloService"/></port></service></definitions>
JDK中自帶了Web服務器，我們不需要把上述代碼部署到其他服務器中。
動態代理機制
Spring中一大特色是AOP，面向方面編程也是框架設計一個趨勢。對於業務中的共通操作，諸如記錄日志、維護事務等，如果和業務邏輯糾纏在一起，會造成代碼職責不清，後續維護困難等問題。利用AOP，我們可以很好的分離共通操作和業務操作。
下面我們來實現一個簡單的AOP框架，要實現這樣一個框架，需要3部分：1）InvocationHandler，來觸發方法；2）Interceptor，來定義攔截器；3）DynamicProxy，來動態創建代理對象。
首先我們看Interptor的定義：
代碼如下：
interface AOPInterceptor
{
public void before(Method method, Object[] args);
public void after(Method method, Object[] args);
public void afterThrowing(Method method, Object[] args);
public void afterFinally(Method method, Object[] args);
}
接下來是InvocationHandler：
代碼如下：
class DynamicProxyInvocationHandler implements InvocationHandler
{
private Object target;
private AOPInterceptor interceptor;
public DynamicProxyInvocationHandler(Object target, AOPInterceptor interceptor)
{
this.target = target;
this.interceptor = interceptor;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
try
{
interceptor.before(method, args);
Object returnValue = method.invoke(target, args);
interceptor.after(method, args);
return returnValue;
}
catch(Throwable t)
{
interceptor.afterThrowing(method, args);
throw t;
}
finally
{
interceptor.afterFinally(method, args);
}
}
}
最後是DynamicProxy：
代碼如下：
class DynamicProxyFactoryImpl implements DynamicProxyFactory
{
public <T> T createProxy(Class<T> clazz, T target, AOPInterceptor interceptor)
{
InvocationHandler handler = new DynamicProxyInvocationHandler(target, interceptor);
return (T)Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[] {clazz}, handler);
}
}
至此，我們構建了一個”簡易“的AOP攔截器。下面我們來創建一些測試代碼。
首先是實現AOPInterceptor接口：
代碼如下：
class MyInterceptor implements AOPInterceptor
{
public void after(Method method, Object[] args) {
System.out.println("方法執行結束。");
}
public void afterFinally(Method method, Object[] args) {
System.out.println("方法體Finally執行結束。");
}
public void afterThrowing(Method method, Object[] args) {
System.out.println("方法拋出異常。");
}
public void before(Method method, Object[] args) {
System.out.println("方法開始執行");
}
}
然後利用本文一開始定義的HelloWorldService，來完成測試，需要在MyHello的sayHello方法最後，追加一行代碼：
代碼如下：
throw new RuntimeException();
接著是測試代碼：
代碼如下：
private static void test()
{
MyInterceptor interceptor = new MyInterceptor();
HelloWorldService hello = new MyHelloWorld();
DynamicProxyFactory factory = new DynamicProxyFactoryImpl();
HelloWorldService proxy = factory.createProxy(HelloWorldService.class, hello, interceptor);
proxy.sayHello("Zhang San");
}
最終，執行結果如下：
代碼如下：
方法開始執行
Hello Zhang San.
方法拋出異常。
方法體Finally執行結束。
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException
at sample.reflection.dynamicproxy.$Proxy0.sayHello(Unknown Source)
at sample.reflection.dynamicproxy.Sample.test(Sample.java:18)
at sample.reflection.dynamicproxy.Sample.main(Sample.java:9)
Caused by: java.lang.reflect.InvocationTargetException
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at sample.reflection.dynamicproxy.DynamicProxyInvocationHandler.invoke(Sample.java:60)
... 3 more
可以看出，我們已經在業務執行的前、後、異常拋出後以及finally執行後進行了攔截，達到了我們期望的效果。
