java測試動態方法_java反射学习
反射的核心Class類
Class類是一個特殊的類，不能手動創建，只能由jvm來創建。 jvm在類加載時會為每個類生成一個與之對應的Class對象在Java堆中(且每個類只會有一個對應的Class對象)，用來保存該類的結構信息。該類的對象都要通過這個Class對象來進行實例化。
可以通過Class的對象來獲得該類的結構信息(構造器、方法、屬性等)。
反射是什么
JAVA反射機制是在運行狀態中，對于任意一個實體類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意方法和屬性；這種動態獲取信息以及動態調用對象方法的功能稱為java語言的反射機制。
Class對象就像是一面鏡子，我們并不能直接得到加載的類里的內容，而是需要通過Class對象這面鏡子反射內部的信息來得到的。
通過Class對象來獲得類的結構信息并且把各個結構部分分別映射成各個對象這個過程就是反射了。
如何獲得Class對象
創建一個User類來進行測試
package com.rainc.test.bean;
/**
* @Author rainc
* @create 2019/10/12 19:51
*/
public class User {
private int id;
private int age;
private String name;
public User() {
}
public User(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static void main(String[] args) {
User user=new User();
//1.通過該類的對象直接過得Class對象
Class clz=user.getClass();
System.out.println(clz);
//2.通過類.class獲得
clz=User.class;
System.out.println(clz);
//3.調用Class的靜態方法forName通過類全名來獲得
try {
String path = "com.rainc.test.bean.User";
clz = Class.forName(path);
System.out.println(clz);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
Snipaste_2019-10-19_16-43-41.png
通過反射api來獲得類的結構信息
public static void main(String[] args) {
String path = "com.rainc.test.bean.User";
try {
Class clz = Class.forName(path);
//獲取類的名字
System.out.println(clz.getName());//獲得類全名
System.out.println(clz.getSimpleName());//獲得類名
//獲取屬性信息
Field[] fields = clz.getFields();//只能獲得public的field
for (Field temp : fields) {
System.out.println("屬性：" + temp);
}
fields = clz.getDeclaredFields();//獲得所有的field
for (Field temp : fields) {
System.out.println("屬性：" + temp);
}
//獲得指定的屬性信息
Field f = clz.getDeclaredField("name");
//獲取方法信息
Method[] methods = clz.getDeclaredMethods();
//通過名字獲取指定的方法信息
//獲得無參的指定方法
for (Method temp : methods) {
System.out.println("方法：" + temp);
}
Method m1 = clz.getDeclaredMethod("getName");
//獲得有參的指定方法
Method m2 = clz.getDeclaredMethod("setName", String.class);
//獲得構造器信息
Constructor[] constructors = clz.getDeclaredConstructors();
//獲得無參的構造器
Constructor c = clz.getDeclaredConstructor();
//獲得有參的構造器
c = clz.getDeclaredConstructor(int.class, int.class, String.class);
} catch (Exception e) {
e.printStackTrace();
}
}
Snipaste_2019-10-20_09-33-17.png
通過反射api動態的操作構造器、方法、屬性
public static void main(String[] args) {
String path = "com.rainc.test.bean.User";
try {
Class clz = (Class) Class.forName(path);
//獲得構造器信息
//通過反射api調用構造方法，構造對象
clz.getDeclaredConstructor().newInstance();
//通過反射api調用普通方法
User u = clz.getDeclaredConstructor().newInstance();
Method method = clz.getDeclaredMethod("setName", String.class);
method.invoke(u, "rainc");//相當于 u.setName("rainc")
System.out.println(u.getName());
//通過反射api操作屬性
User u2 = clz.getDeclaredConstructor().newInstance();
Field f = clz.getDeclaredField("name");
f.setAccessible(true);//解除安全檢查，可以通過這個方法使用私有方法和屬性等
f.set(u2, "rainc2");
System.out.println(u2.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
Snipaste_2019-10-20_09-36-19.png
反射的效率
使用反射的效率會比直接通過對象調用方法效率低。通過setAccessible(true)方法解除安全檢查可以提高反射的運行效率
創建TestBean類用來測試
/**
* @Author rainc
* @create 2019/10/20 9:19
*/
public class TestBean {
long sum=0;
public long getSum() {
return sum;
}
public void setSum(int sum) {
this.sum+=sum;
}
}
創建Test類進行測試
import java.lang.reflect.Method;
/**
* @Author rainc
* @create 2019/10/20 9:19
*/
public class TestAccessiable {
public static void main(String[] args) throws Exception {
test01();
test02();
test03();
}
/**
* 普通方法
*/
public static void test01() {
TestBean t=new TestBean();
long startTtime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
t.setSum(i);
}
System.out.println("和:"+t.getSum());
long endTime = System.currentTimeMillis();
System.out.println("普通方法調用10億次耗時：" + (endTime - startTtime) + "ms");
}
/**
* 反射調用
*/
public static void test02() throws Exception {
TestBean t=new TestBean();
Class clz=t.getClass();
Method m=clz.getDeclaredMethod("setSum", int.class);
long startTtime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
m.invoke(t,i);
}
System.out.println("和:"+t.getSum());
long endTime = System.currentTimeMillis();
System.out.println("反射調用10億次耗時：" + (endTime - startTtime) + "ms");
}
/**
* 解除安全檢查，反射調用
*/
public static void test03() throws Exception {
TestBean t=new TestBean();
Class clz=t.getClass();
Method m=clz.getDeclaredMethod("setSum", int.class);
m.setAccessible(true);
long startTtime = System.currentTimeMillis();
for (int i = 0; i < 1000000000L; i++) {
m.invoke(t,i);
}
System.out.println("和:"+t.getSum());
long endTime = System.currentTimeMillis();
System.out.println("解除安全檢查，反射調用10億次耗時：" + (endTime - startTtime) + "ms");
}
}
Snipaste_2019-10-20_09-43-18.png
可以看出，普通的方法調用效率最高，其次是解除安全檢查的，效率最低的是直接通過反射調用。
盡管反射的效率并不如普通的方法調用，但是由于其擁有動態性，在框架中有著大量的使用，而這些框架卻能大大的提高我們的工作效率。因此犧牲一定的性能效率來提高工作效率也是必要的。
反射操作泛型
ParameterizedType:表示一種參數化的類型，比如Collection< String >(常用)
GenericArrayType:表示一種元素類型是參數化類型或者類型變量的數組類型
TypeVariable:是各種類型變量的公共父接口
WildcardType:代表一種通配符類型表達式，比如？、？ extends Number、？ super Integer。(wildcard是一個單詞：就是”通配符“)
import com.rainc.test.bean.User;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
* @Author rainc
* @create 2019/10/20 10:10
*/
public class TestGenericity {
public void test01(Map map, List list){
}
public Map test02(){
return null;
}
public static void main(String[] args) throws Exception {
Class clz=TestGenericity.class;
//獲得指定方法的泛型
System.out.println("獲得指定方法的泛型");
Method m=clz.getMethod("test01", Map.class, List.class);
//取得方法的所有參數類型
Type[] t=m.getGenericParameterTypes();
for (Type paramType:t){
System.out.println("#"+paramType);
//判斷取得的參數是否為參數化類型
if (paramType instanceof ParameterizedType){
//是的話將其強制轉型并獲得泛型的真正類型
Type[] genericTypes=((ParameterizedType) paramType).getActualTypeArguments();
for (Type genericType:genericTypes){
System.out.println("泛型類型："+genericType);
}
}
}
//獲得指定方法返回值泛型
System.out.println("\n\n指定方法返回值泛型");
Method m2=clz.getMethod("test02");
//由于返回值只會有一個因此不需要數組
Type returnType =m2.getGenericReturnType();
if (returnType instanceof ParameterizedType){
Type[] genericTypes=((ParameterizedType) returnType).getActualTypeArguments();
for (Type genericType:genericTypes){
System.out.println("泛型類型："+genericType);
}
}
}
}
Snipaste_2019-10-20_10-47-16.png
總結
以上是生活随笔為你收集整理的java測試動態方法_java反射学习的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 加密工具类
- 下一篇： Rabbitmq-direct演示