Java通过反射机制将对象封装成JSON和JsonArray格式
作者：喜上编程
这篇文章主要介绍了Java通过反射机制将对象封装成JSON和JsonArray格式,JAVA反射机制是在运行状态中,对于任意一个实体类,都能够知道这个类的所有属性和方法,需要的朋友可以参考下
反射机制
JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
1.获取构造方法，方法，属性
（1）getConstructors() 获取公共的构造方法
（2）getDeclaredConstructors() 获取所有的构造方法
（3）getMethods() 公共的方法(包含父类Object)
（4）getDeclaredMethods() 所有方法(不包含父类)
（5)getFields() 公共的属性 （6)getDeclaredFields() 所有的属性
2.Users对象
package com.it.bean;
public class Users {
private int age;
public String name;
char sex;
public Users() {
}
public Users(String name, char sex) {
this.name = name;
this.sex = sex;
}
public Users(int age, String name, char sex) {
this.age = age;
this.name = name;
this.sex = sex;
}
Users(int age, String name) {
this.age = age;
this.name = name;
}
private Users(String name,int age){
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public void fun1(){
System.out.println("fun1---");
}
public void fun2(String x,String y){
}
void fun3(int age){
}
private int fun4(){
return 0;
}
protected void fun5(){
}
}3.获取构造方法，方法，属性
package com.it.reflect;
import com.it.bean.Users;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class Demo2 {
@Test
//获取构造方法
public void fun1(){
Users users = new Users();
//获取该对象所属类
Class usersClass = users.getClass();
Constructor constructor[]=usersClass.getDeclaredConstructors();
//访问修饰符 方法名（参数类型 参数名）
for (int i = 0; i < constructor.length; i++) {
//获取访问修饰符
if(constructor[i].getModifiers()==1){
System.out.print("public ");
}else if(constructor[i].getModifiers()==4){
System.out.print("protected ");
}else if(constructor[i].getModifiers()==2){
System.out.print("private ");
}
//获取方法名
System.out.print(constructor[i].getName()+"(");
//获取参数类型 数组
Class parType[]=constructor[i].getParameterTypes();
for (int j = 0; j <parType.length ; j++) {
if(j!=parType.length-1){
System.out.print(parType[j].getTypeName()+",");
}else{
System.out.print(parType[j].getTypeName());
}
}
System.out.println(")");
}
}
//获取方法
@Test
public void fun2(){
Users users = new Users();
Class usersClass = users.getClass();
Method method[]=usersClass.getMethods();
for (int i = 0; i <method.length ; i++) {
//获取访问修饰符
if(method[i].getModifiers()==1){
System.out.print("public ");
}else if(method[i].getModifiers()==4){
System.out.print("protected ");
}else if(method[i].getModifiers()==2){
System.out.print("private ");
}
//获取返回值类型
Class returnType=method[i].getReturnType();
//拼接返回值类型和方法名
System.out.print(returnType.getName()+" "+method[i].getName()+"(");
//形参类型
Class parType[]=method[i].getParameterTypes();
for (int j = 0; j <parType.length ; j++) {
if(j!=parType.length-1){
System.out.print(parType[j].getTypeName()+",");
}else{
System.out.print(parType[j].getTypeName());
}
}
System.out.println(")");
}
}
//获取属性
@Test
public void fun3(){
Users users=new Users();
Class userClass=users.getClass();
Field field[]=userClass.getDeclaredFields();
for (int i = 0; i <field.length ; i++) {
//获取访问修饰符
if(field[i].getModifiers()==1){
System.out.print("public ");
}else if(field[i].getModifiers()==4){
System.out.print("protected ");
}else if(field[i].getModifiers()==2){
System.out.print("private ");
}
//获取数据类型 和属性名
System.out.println(field[i].getType().getTypeName()+" "+field[i].getName()+";");
}
}
}
Object invoke(Object obj, Object… args) 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
区别如下： 如果 method.invoke(Object obj, Object… args) 第一个参数传入的是类的实例，那么可以反射调用类的所有方法 包括静态方法，前提是 method 是正常获取 如果 method.invoke(Object obj, Object… args) 第一个参数传入的是类的Class对象，那么只能反射调用类的静态方法，否则会报错。
一句话概括： 传入类Class对象只能调用静态方法，传类的实例可以调用所有方法
4.通过反射机制将对象封装为json格式
//封装方法
//通过反射机制将对象封装成JSON格式
//{'id':'001','name':'hhh','age':'12'}
public static String objToJson(Object object) {
Class cls = object.getClass();
Method method[] = cls.getMethods();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("{");
//从方法中截取属性名
//控制,
int j = 0;
for (int i = 0; i < method.length; i++) {
//获取属性名
if (method[i].getName().startsWith("get") && method[i].getModifiers() == 1) {
if (j != 0) {
stringBuilder.append(",");
}
//获得名字截取 getName()转小写
String fieldName = method[i].getName().substring(3).toLowerCase();
// System.out.println("field->" + fieldName);
stringBuilder.append("'" + fieldName + "'" + ":");
//获取值
try {
stringBuilder.append("'" + method[i].invoke(object) + "'");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
j++;
}
}
stringBuilder.append("}");
// System.out.println(stringBuilder.toString());
return stringBuilder.toString();
}
5.通过反射机制将对象封装为jsonArray格式
//通过反射机制将对象封装成JSONArray格式
//[{},{},{},{}]
public static String objToJsonArray(List<Object> objectList) {
StringBuilder stringBuilder=new StringBuilder();
stringBuilder.append("[");
for (int i = 0; i <objectList.size() ; i++) {
if(i!=0){
stringBuilder.append(",");
}
//调用封装好的json格式
stringBuilder.append(objToJson(objectList.get(i)));
}
stringBuilder.append("]");
// System.out.println(stringBuilder);
return stringBuilder.toString();
}
测试代码
public static void main(String[] args) {
UserInfo userInfo1 = new UserInfo(001, "花花1", '女');
Prov prov = new Prov("sx001","西安市");
System.out.println("json");
System.out.println(objToJson(userInfo1));
System.out.println("jsonArry");
UserInfo userInfo2 = new UserInfo(002, "花花2", '女');
UserInfo userInfo3 = new UserInfo(003, "花花3", '女');
List list=new ArrayList();
list.add(userInfo1);
list.add(userInfo2);
list.add(userInfo3);
System.out.println(objToJsonArray(list));
}到此这篇关于Java通过反射机制将对象封装成JSON和JsonArray格式的文章就介绍到这了,更多相关Java反射封装对象内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！