1、Java反射获取某个类的全部属性
Java反射获取某个类的全部属性,步骤所用方法如下：
- forName()：返回给定串名相应的Class对象。
- getDeclaredFields()：返回当前Class对象表示的类或接口的所有的类成员。
- getFields()：返回当前Class对象表示的类或接口的所有可访问的公有类成员。
- getModifiers()：返回该类或接口的Java语言修改器代码，是 public、protect 还是 private。
- getName()：返回Class对象表示的类型(类、接口、数组或基类型)的完整路径名字符串。
package com.example.demo.Sub;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class TestReflect implements Serializable {
private static final long serialVersionUID = -2862585049955236662L;
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName(TestReflect.class.getName());
System.out.println("===============本类属性===============");
// 取得本类的全部属性
Field[] field = clazz.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 = clazz.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() + ";");
}
}
}
2、Java通过反射机制实例化一个类的对象
- newInstance()：创建类的新实例。
- getConstructors()：返回当前Class对象表示的类的所有公有构造函数数组。
package com.example.demo.Sub;
import java.lang.reflect.Constructor;
public class TestReflect {
public static void main(String[] args) throws Exception {
Class<?> class1 = null;
class1 = Class.forName(User.class.getName());
// 第一种方法，实例化默认构造方法，调用set赋值
User user = (User) class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
// 结果 User [age=20, name=Rollen]
// 第二种方法 取得全部的构造函数 使用构造函数赋值
Constructor<?> cons[] = class1.getConstructors();
// 查看每个构造方法需要的参数
for (int i = 0; i < cons.length; i++) {
Class<?> clazzs[] = cons[i].getParameterTypes();
System.out.print("cons[" + i + "] (");
for (int j = 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]
}
}
class User {
private int age;
private String name;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
public User(int age, String name) {
super();
this.age = age;
this.name = name;
}
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;
}
@Override
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
}
3、Java通过反射机制获取某个类的全部方法
- getMethods()：返回当前Class对象表示的类或接口的所有公有成员方法对象数组，包括已声明的和从父类继承的方法。
package com.example.demo.Sub;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class TestReflect implements Serializable {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName(TestReflect.class.getName());
Method method[] = clazz.getMethods();
for (int i = 0; i < method.length; ++i) {
Class<?> returnType = method[i].getReturnType();
Class<?> para[] = method[i].getParameterTypes();
int temp = method[i].getModifiers();
System.out.print(Modifier.toString(temp) + " ");
System.out.print(returnType.getName() + " ");
System.out.print(method[i].getName() + " ");
System.out.print("(");
for (int j = 0; j < para.length; ++j) {
System.out.print(para[j].getName() + " " + "arg" + j);
if (j < para.length - 1) {
System.out.print(",");
}
}
Class<?> exce[] = method[i].getExceptionTypes();
if (exce.length > 0) {
System.out.print(") throws ");
for (int k = 0; k < exce.length; ++k) {
System.out.print(exce[k].getName() + " ");
if (k < exce.length - 1) {
System.out.print(",");
}
}
} else {
System.out.print(")");
}
System.out.println();
}
}
}
4、Java通过反射机制调用某个类的方法
import java.lang.reflect.Method;
public class TestReflect {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName(TestReflect.class.getName());
Method method = clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
Method method1 = clazz.getMethod("reflect2", Integer.class, String.class);
method1.invoke(clazz.newInstance(), 18, "徐蜀");
}
public void reflect1() {
System.out.println("Java 反射机制 - 调用某个类的方法1.");
}
public void reflect2(Integer age, String name) {
System.out.println("Java 反射机制 - 调用某个类的方法2.");
System.out.println("age -> " + age + ". name -> " + name);
}
}
5、Java通过反射机制操作某个类的属性
import java.lang.reflect.Field;
public class TestReflect {
private String field = null;
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName(TestReflect.class.getName());
Object object = clazz.newInstance();
Field field = clazz.getDeclaredField("field");
field.set(object, "Java反射机制，射你一脸");
field.setAccessible(true);
System.out.println(field.get(object));
}
}
6、实战
假设这样一种场景，前端就想要几个字段，你一股脑把所有字段都返回了。
然后前端找你来理论：劳资就只要几个字段，都返回干嘛，就给我这几个字段就行。
你回复：这些都放在一个类里返回的，总不能我重新给你写个类吧。难道你要特定的字段，我就写个类给你？
然后你们打起来了！！！！
比如简单的方式是你用一个 map，然后 key 是 name，value 是属性的值，你一个个遍历，然后边写边骂：傻逼前端，搞的劳资代码写那么垃圾，艹！！！（突然想到 graphql 的好处了。。。）
高级的方式当然不会这么 der，直接反射即可：
FilterUtil.java
package com.example.demo.Sub.reflectPratice;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author xushu
* @create 1/20/21 9:32 PM
* @desc
*/
public class FilterUtil {
/**
* 单个类的情况
* @param object
* @param names
* @return
* @throws IllegalAccessException
*/
public static Map<String, Object> getFilterClass(Object object, List<String> names) throws IllegalAccessException {
Class<?> clazz = object.getClass();
Map<String, Object> map = new HashMap<>();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
if(names.contains(field.getName())){
map.put(field.getName(), field.get(object));
}
}
return map;
}
/**
* list 的情况
* @param objectList
* @param names
* @return
* @throws IllegalAccessException
*/
public static List<Map<String, Object>> getFilterListClass(List<Object> objectList, List<String> names) throws IllegalAccessException {
List<Map<String, Object>> list = new ArrayList<>();
for (Object o : objectList) {
list.add(getFilterClass(o, names));
}
return list;
}
}
PersonXushu.java
package com.example.demo.Sub.reflectPratice;
import java.util.ArrayList;
import java.util.List;
/**
* @author xushu
* @create 1/20/21 9:28 PM
* @desc
*/
public class PersonXushu {
private String name;
private String address;
private Integer age;
private String favorite;
public PersonXushu() {
}
public PersonXushu(String name, String address, Integer age, String favorite) {
this.name = name;
this.address = address;
this.age = age;
this.favorite = favorite;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getFavorite() {
return favorite;
}
public void setFavorite(String favorite) {
this.favorite = favorite;
}
public static List<PersonXushu> getList(){
List<PersonXushu> list = new ArrayList<>();
PersonXushu personXushu1 = new PersonXushu("xushu", "hangzhou", 18, "get money");
PersonXushu personXushu2 = new PersonXushu("xushu", "hangzhou", 18, "get money");
PersonXushu personXushu3 = new PersonXushu("xushu", "hangzhou", 18, "get money");
PersonXushu personXushu4 = new PersonXushu("xushu", "hangzhou", 18, "get money");
list.add(personXushu1);
list.add(personXushu2);
list.add(personXushu3);
list.add(personXushu4);
return list;
}
}
Reflect.java
package com.example.demo.Sub.reflectPratice;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* @author xushu
* @create 1/20/21 9:29 PM
* @desc
*/
public class Reflect {
public static void main(String[] args) throws IllegalAccessException {
// 单个类
PersonXushu personXushu1 = new PersonXushu("xushu", "hangzhou", 18, "get money");
Map<String, Object> map = FilterUtil.getFilterClass(personXushu1, Arrays.asList("name", "address", "favorite"));
for (String s : map.keySet()) {
System.out.println("名称为：" + s + "，值为" + map.get(s));
}
// list 情况
List list = PersonXushu.getList();
List<Map<String, Object>> listMap = FilterUtil.getFilterListClass(list, Arrays.asList("name", "address", "favorite"));
for (Map<String, Object> objectMap : listMap) {
for (String s : objectMap.keySet()) {
System.out.println("名称为：" + s + "，值为" + objectMap.get(s));
}
}
}
}
网友评论