Java通过反射机制将对象封装成JSON和JsonArray格式

更新时间：2023年10月18日 09:42:49 作者：喜上编程

这篇文章主要介绍了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反射封装对象内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java Swing JSlider滑块的实现示例
这篇文章主要介绍了Java Swing JSlider滑块的实现示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-12-12
Java趣味练习题之输出两个日期之间的相隔天数
本篇文章介绍了我看到的一个趣味小题目，怎么求得两个日期之间相隔的天数，以及解决该题目的过程及思路，通读本篇对大家的学习或工作具有一定的价值，需要的朋友可以参考下
2021-10-10
Java多线程之volatile关键字及内存屏障实例解析
volatile是JVM提供的一种最轻量级的同步机制，因为Java内存模型为volatile定义特殊的访问规则，使其可以实现Java内存模型中的两大特性：可见性和有序性。这篇文章主要介绍了Java多线程之volatile关键字及内存屏障,需要的朋友可以参考下
2019-05-05
浅谈一下JVM垃圾回收算法
这篇文章主要介绍了一下JVM垃圾回收算法,Java有着自己一套的内存管理机制，不需要开发者去手动释放内存，开发者只需要写好代码即可，运行过程中产生的垃圾都由JVM回收,需要的朋友可以参考下
2023-04-04
实战分布式医疗挂号系统之整合Swagger2到通用模块
这篇文章主要为大家介绍了实战分布式医疗挂号系统之整合Swagger2到通用模块，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-04-04
java高并发ScheduledThreadPoolExecutor类深度解析
这篇文章主要为大家介绍了java高并发ScheduledThreadPoolExecutor类源码深度解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-11-11
MyBatis框架关联映射实例详解
这篇文章主要介绍了MyBatis框架关联映射,关系映射主要处理复杂的SQl查询，如子查询，多表联查等复杂查询，应用此种需求时可以考虑使用，需要的朋友可以参考下
2022-11-11
SpringBoot2开启Actuator端点监控的方法
这篇文章主要介绍了SpringBoot2开启Actuator端点监控的相关资料,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-06-06
Java之策略模式比较器案例讲解
这篇文章主要介绍了Java之策略模式比较器案例讲解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
2021-08-08
JAVA算法起步之插入排序实例
这篇文章主要介绍了JAVA算法起步之插入排序实例,需要的朋友可以参考下
2014-02-02