Java编程：按照指定的字段顺序，将 Bean 转换为 Json

最新推荐文章于 2024-08-05 04:24:10 发布
最新推荐文章于 2024-08-05 04:24:10 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： java 文章标签： 按字段顺序 json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43935907/article/details/105318678
版权

一、背景

最近在做项目的时候，我碰到了一个问题，使用json传递报文的时候怎么保存报文的顺序？比如下面一段报文：

{
	"ec": {
		"request": {
			"header": {
				"actiontype": "00",
				"currenttime": "1586003427105"
			},
			"body": {
				"uuid": "dsasdadada",
				"subject": "CN=AO",
				"pubkey": "dsadsadsad",
				"validaty": "",
				"duration": "",
				"certhash": ""
			}
		},
		"signature": {
			"alg": "sm3withSM2",
			"pubkey": "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw==",
			"sign": "MEUCIQD1NNi3enH4IuivzTMdGt3NYuuIbui/2/zBbk/rZ/BPIQIgbDqaiS34rkkaSc/QWLaH2kfjTIT3lzWJN4M1IzzJ+TA="
		},
		"eccert": {
			"type": "00",
			"value": "fsafasdsadasdas"
		}
	},
	"signature": {
		"alg": "sm3withSM2",
		"pubkey": "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw==",
		"sign": "MEYCIQDdwZByaHxSBYGZv2mD9VjKjatzkx8FkbWRjwd+aVJuyAIhALgERohg8KTaVqkun2kjcHHe+7HBgFEIZCbyZo8m0pA2"
	}
}

这一段报文怎么创建呢？怎么确保每次创建的报文格式都是一致的呢？

二、解决方法

  1. 我的第一种解决方案（傻瓜式）
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.15</version>
</dependency>

使用fastjson的JSONObject反复创建添加，代码如下：

    
    @Test
    public void test(){
        JSONObject jsonObject = new JSONObject(true);
        JSONObject ec = new JSONObject(true);
        JSONObject request = new JSONObject(true);
        JSONObject header = new JSONObject(true);
        header.put("actiontype","00");
        header.put("currenttime","1586003427105");

        JSONObject body = new JSONObject(true);
        body.put("uuid","dsasdadada");
        body.put("subject","CN=AO");
        body.put("pubkey","dsadsadsad");
        body.put("validaty","");
        body.put("duration","");
        body.put("certhash","");
        request.put("header",header);
        request.put("body",body);

        JSONObject signature = new JSONObject();
        signature.put("alg","sm3withSM2");
        signature.put("pubkey", "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw==");
        signature.put("sign","MEUCIQD1NNi3enH4IuivzTMdGt3NYuuIbui/2/zBbk/rZ/BPIQIgbDqaiS34rkkaSc/QWLaH2kfjTIT3lzWJN4M1IzzJ+TA=");

        JSONObject eccert = new JSONObject();
        eccert.put("type","00");
        eccert.put("value","fsafasdsadasdas");
        ec.put("request",request);
        ec.put("signature",signature);
        ec.put("eccert",eccert);

        JSONObject signNature = new JSONObject();
        signNature.put("alg","sm3withSM2");
        signNature.put("pubkey", "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw==");
        signNature.put("sign", "MEYCIQDdwZByaHxSBYGZv2mD9VjKjatzkx8FkbWRjwd+aVJuyAIhALgERohg8KTaVqkun2kjcHHe+7HBgFEIZCbyZo8m0pA2");

        jsonObject.put("ec",ec);
        jsonObject.put("signature",signNature);
        System.out.println(JSONObject.toJSONString(jsonObject,true));
    }

打印结果：

{
	"ec":{
		"request":{
			"header":{
				"actiontype":"00",
				"currenttime":"1586003427105"
			},
			"body":{
				"uuid":"dsasdadada",
				"subject":"CN=AO",
				"pubkey":"dsadsadsad",
				"validaty":"",
				"duration":"",
				"certhash":""
			}
		},
		"signature":{
			"sign":"MEUCIQD1NNi3enH4IuivzTMdGt3NYuuIbui/2/zBbk/rZ/BPIQIgbDqaiS34rkkaSc/QWLaH2kfjTIT3lzWJN4M1IzzJ+TA=",
			"alg":"sm3withSM2",
			"pubkey":"MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw=="
		},
		"eccert":{
			"type":"00",
			"value":"fsafasdsadasdas"
		}
	},
	"signature":{
		"sign":"MEYCIQDdwZByaHxSBYGZv2mD9VjKjatzkx8FkbWRjwd+aVJuyAIhALgERohg8KTaVqkun2kjcHHe+7HBgFEIZCbyZo8m0pA2",
		"alg":"sm3withSM2",
		"pubkey":"MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw=="
	}
}

这种方法特别的麻烦，每次向服务器发起请求时必须手动编写一次，这些代码存在高度的重复性，只是body不同，其它都是类似的，这样写代码复用性不高，存在代码臃肿，不利于阅读和项目拓展。

我的第二种解决方案（静态工厂模式和建造者模式）

  1. 将报文拆分成多个可重用组件(AtRequestBody、Ec、EcCert、Head、request和Signature)
  2. 使用静态工厂方法创建对应的对象
  3. 使用建造者模式创建AtRequestBody，实例化每个对象，组装对象

这种方法代码比较多，实例化起来也不是很简单，调用也不是很方便，而且组装的时候碰到一个问题，怎么保证AtRequestBody转化成json字符串按照，怎么保证转化是按照bean的字段顺序转化呢？也是本文的标题的关键字。

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.8.1</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.8.1</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.8.1</version>
</dependency>

使用jackson的注解@JsonPropertyOrder({“ec”,“signature”})，这个会确保Java bean转化成jsonStr时按照指定顺序序列化。

package com.infosec.ra.common.build.outer.request;

import cn.com.infosec.hsm.crypto.HSM;
import cn.com.infosec.hsm.crypto.IHSM;
import cn.com.infosec.util.encoders.Base64;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.infosec.ra.common.RAConstant;
import com.infosec.ra.common.RAEnum;
import com.infosec.ra.common.build.Builder;
import com.infosec.ra.common.build.outer.Signature;
import com.infosec.ra.util.IHSMUtil;
import lombok.*;

import java.security.PublicKey;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"ec","signature"})
public class AtRequestBody {
    private Ec ec;
    private Signature signature;

    public void setSignature(String alg){
        try {
            IHSM sjj1507 = HSM.getInst("SOFT");
            sjj1507.init();
            IHSMUtil.setSjj1507(sjj1507);
            byte[] sm3withSM2s = IHSMUtil.sign("1", 256, "12345678".toCharArray(), JSON.toJSONString(this.ec).getBytes(), "SM3withSM2", RAConstant.SM2ID);
            PublicKey p1= IHSMUtil.exportPublicKey("SM2", IHSM.SIGN, "1", 256,"12345678".toCharArray());
            byte[] encoded = p1.getEncoded();
            this.signature = Builder.of(Signature::new)
                    .with(Signature::setAlg,alg)
                    .with(Signature::setPubkey, Base64.toBase64String(encoded))
                    .with(Signature::setSign,Base64.toBase64String(sm3withSM2s))
                    .build();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public static String getMsg(String actionType, String certType,String cert,JSONObject jsonObject) throws JsonProcessingException {
        Ec ec = Builder.of(Ec::new)
                .with(Ec::setRequest, actionType, System.currentTimeMillis() + "", jsonObject)
                .with(Ec::setSignature, RAConstant.SIGN_ALG)
                .with(Ec::setEcCert, certType, cert)
                .build();
        AtRequestBody build = Builder.of(AtRequestBody::new)
                .with(AtRequestBody::setEc, ec)
                .with(AtRequestBody::setSignature, RAConstant.SIGN_ALG)
                .build();
        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(build);
        //JSONObject jsonObject1 = JSONObject.parseObject(JSONObject.toJSON(build).toString(), Feature.OrderedField);
        return s;
    }
}

代码比较多，就不一一贴了，不然篇幅太长。

我的第三种解决方案（java8 通用builder）

  1. 将报文拆分成多个可重用组件(AtRequestBody、Ec、EcCert、Head、request和Signature)
  2. 使用Supplier接口实例化对象
  3. 使用Consumer接口初始化对象
  4. 使用jackson确保java bean系列化时按照字段顺序

具体代码如下：

一、将报文拆分成可复用组件(java bean)

  1. Signature
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.*;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"alg","pubkey","sign"})
public class Signature {
    private String alg;
    private String pubkey;
    private String sign;
}

2.Request

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.infosec.ra.common.build.Builder;
import lombok.*;


/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"header","body"})
public class Request {
    private Head header;
    private JSONObject body;

    public void setHeader(String actiontype,String currenttime){
        this.header = Builder.of(Head::new)
                .with(Head::setActiontype,actiontype)
                .with(Head::setCurrenttime,currenttime)
                .build();
    }
}

3.head

import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.*;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"actiontype","currenttime"})
public class Head {
    private String actiontype;
    private String currenttime;
}

4.EcCert

import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import lombok.*;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"type","value"})
public class EcCert {
    private String type;
    private String value;
}

5.ec

import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.infosec.ra.common.build.Builder;
import lombok.*;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"request","signature","eccert"})
public class Ec extends RequestBody {
    private EcCert eccert;

    public void setEcCert(String type,String value){
        this.eccert = Builder.of(EcCert::new)
                .with(EcCert::setType, type)
                .with(EcCert::setValue, value)
                .build();
    }
}

6.AtRequestBody

import cn.com.infosec.hsm.crypto.HSM;
import cn.com.infosec.hsm.crypto.IHSM;
import cn.com.infosec.util.encoders.Base64;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.infosec.ra.common.RAConstant;
import com.infosec.ra.common.RAEnum;
import com.infosec.ra.common.build.Builder;
import com.infosec.ra.common.build.outer.Signature;
import com.infosec.ra.util.IHSMUtil;
import lombok.*;

import java.security.PublicKey;

/**
 * @author Javacfox
 */
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = false)
@JsonPropertyOrder({"ec","signature"})
public class AtRequestBody {
    private Ec ec;
    private Signature signature;

    public void setSignature(String alg){
        try {
            IHSM sjj1507 = HSM.getInst("SOFT");
            sjj1507.init();
            IHSMUtil.setSjj1507(sjj1507);
            byte[] sm3withSM2s = IHSMUtil.sign("1", 256, "12345678".toCharArray(), JSON.toJSONString(this.ec).getBytes(), "SM3withSM2", RAConstant.SM2ID);
            PublicKey p1= IHSMUtil.exportPublicKey("SM2", IHSM.SIGN, "1", 256,"12345678".toCharArray());
            byte[] encoded = p1.getEncoded();
            this.signature = Builder.of(Signature::new)
                    .with(Signature::setAlg,alg)
                    .with(Signature::setPubkey, Base64.toBase64String(encoded))
                    .with(Signature::setSign,Base64.toBase64String(sm3withSM2s))
                    .build();
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public static String getMsg(String actionType, String certType,String cert,JSONObject jsonObject) throws JsonProcessingException {
        Ec ec = Builder.of(Ec::new)
                .with(Ec::setRequest, actionType, System.currentTimeMillis() + "", jsonObject)
                .with(Ec::setSignature, RAConstant.SIGN_ALG)
                .with(Ec::setEcCert, certType, cert)
                .build();
        AtRequestBody build = Builder.of(AtRequestBody::new)
                .with(AtRequestBody::setEc, ec)
                .with(AtRequestBody::setSignature, RAConstant.SIGN_ALG)
                .build();
        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(build);
        //JSONObject jsonObject1 = JSONObject.parseObject(JSONObject.toJSON(build).toString(), Feature.OrderedField);
        return s;
    }
}

二、创建建造器（Builder）

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * @author Javacfox
 */
public class Builder<T> {

    private final Supplier<T> instantiator;

    private List<Consumer<T>> modifiers = new ArrayList<>();

    public Builder(Supplier<T> instant) {
        this.instantiator = instant;
    }

    public static <T> Builder<T> of(Supplier<T> instant) {
        return new Builder<>(instant);
    }

    public <P1> Builder<T> with(Consumer1<T, P1> consumer, P1 p1) {
        Consumer<T> c = instance -> consumer.accept(instance, p1);
        modifiers.add(c);
        return this;
    }

    public <P1, P2> Builder<T> with(Consumer2<T, P1, P2> consumer, P1 p1, P2 p2) {
        Consumer<T> c = instance -> consumer.accept(instance, p1, p2);
        modifiers.add(c);
        return this;
    }

    public <P1, P2, P3> Builder<T> with(Consumer3<T, P1, P2, P3> consumer, P1 p1, P2 p2, P3 p3) {
        Consumer<T> c = instance -> consumer.accept(instance, p1, p2, p3);
        modifiers.add(c);
        return this;
    }

    public <P1, P2, P3,P4> Builder<T> with(Consumer4<T, P1, P2, P3,P4> consumer, P1 p1, P2 p2, P3 p3,P4 p4) {
        Consumer<T> c = instance -> consumer.accept(instance, p1, p2, p3,p4);
        modifiers.add(c);
        return this;
    }

    public <P1, P2, P3,P4,P5> Builder<T> with(Consumer5<T, P1, P2, P3,P4,P5> consumer, P1 p1, P2 p2, P3 p3,P4 p4,P5 p5) {
        Consumer<T> c = instance -> consumer.accept(instance, p1, p2, p3,p4,p5);
        modifiers.add(c);
        return this;
    }

    public T build() {
        T value = instantiator.get();
        modifiers.forEach(modifier -> modifier.accept(value));
        modifiers.clear();
        return value;
    }
    

    /**
     * 1 参数 Consumer
     */
    @FunctionalInterface
    public interface Consumer1<T, P1> {
        /**
         * 接收参数方法
         * @param t 对象
         * @param p1 参数二
         */
        void accept(T t, P1 p1);
    }

    /**
     * 2 参数 Consumer
     */
    @FunctionalInterface
    public interface Consumer2<T, P1, P2> {
        /**
         * 接收参数方法
         * @param t 对象
         * @param p1 参数一
         * @param p2 参数二
         */
        void accept(T t, P1 p1, P2 p2);
    }

    /**
     * 3 参数 Consumer
     */
    @FunctionalInterface
    public interface Consumer3<T, P1, P2, P3> {
        /**
         * 接收参数方法
         * @param t 对象
         * @param p1 参数一
         * @param p2 参数二
         * @param p3 参数三
         */
        void accept(T t, P1 p1, P2 p2, P3 p3);
    }

    @FunctionalInterface
    public interface Consumer4<T, P1, P2, P3, P4>{
        /**
         * 接收参数方法
         * @param t 对象
         * @param p1 参数一
         * @param p2 参数二
         * @param p3 参数三
         * @param p4 参数四
         */
        void accept(T t,P1 p1,P2 p2,P3 p3,P4 p4);
    }

    @FunctionalInterface
    public interface Consumer5<T, P1, P2, P3, P4, P5>{
        /**
         * 接收参数方法
         * @param t 对象
         * @param p1 参数一
         * @param p2 参数二
         * @param p3 参数三
         * @param p4 参数四
         * @param p5 参数五
         */
        void accept(T t,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5);
    }
}
  1. 调用方法
JSONObject jsonObject = new JSONObject(true);
jsonObject.put("uuid","dsasdadada");
jsonObject.put("subject","CN=AO");
jsonObject.put("pubkey","dsadsadsad");
jsonObject.put("validaty","");
jsonObject.put("duration","");
jsonObject.put("certhash","");
System.out.println(AtRequestBody.getMsg("00",RAEnum.CertType.EC.getValue(),"fsafasdsadasdas",jsonObject));
  1. 运行结果
{
	"ec":{
		"request":{
			"header":{
				"actiontype":"00",
				"currenttime":"1586003427105"
			},
			"body":{
				"uuid":"dsasdadada",
				"subject":"CN=AO",
				"pubkey":"dsadsadsad",
				"validaty":"",
				"duration":"",
				"certhash":""
			}
		},
		"signature":{
			"sign":"MEUCIQD1NNi3enH4IuivzTMdGt3NYuuIbui/2/zBbk/rZ/BPIQIgbDqaiS34rkkaSc/QWLaH2kfjTIT3lzWJN4M1IzzJ+TA=",
			"alg":"sm3withSM2",
			"pubkey":"MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw=="
		},
		"eccert":{
			"type":"00",
			"value":"fsafasdsadasdas"
		}
	},
	"signature":{
		"sign":"MEYCIQDdwZByaHxSBYGZv2mD9VjKjatzkx8FkbWRjwd+aVJuyAIhALgERohg8KTaVqkun2kjcHHe+7HBgFEIZCbyZo8m0pA2",
		"alg":"sm3withSM2",
		"pubkey":"MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEuFn8z5HGpbTm790ZVfs0w5kHAN2qASpVINFPqDdqvd39olapX8Op+Re2+yXU5MwmxdDtVj5PmOEnyGqLuLpqZw=="
	}
}

很明显，和第一次结果是一致的，但是比起第一次少了特别多代码，很简洁干净。

总结：
代码不可能一次就能既简洁又好用，复用性和拓展性高，需要反复的重构和优化，不断的提高自己的代码能力。

笑不语
关注
专栏目录
自定义枚举对象序列化规则： 在Json中以枚举的code值表示枚举；枚举序列化时，新增枚举描述字段；String到IEnum的转换
iOS逆向与安全
07-09 260
GetterENABLE("1", "启用"),DEACTIVATE("0", "停用");@EnumValue// 自定义toString方法返回code@Override。
Java详解：java对象转json字符串不加引号
m0_56252652的博客
06-20 1892
一面 自我介绍 项目中的监控：那个监控指标常见的有哪些？ 微服务涉及到的技术以及需要注意的问题有哪些？ 注册中心你了解了哪些？ consul 的可靠性你了解吗？ consul 的机制你有没有具体深入过？有没有和其他的注册中心对比过？ 项目用 Spring 比较多，有没有了解 Spring 的原理？AOP 和 IOC 的原理 Spring Boot除了自动配置，相比传统的 Spring 有什么其他的区别？ Spring Cloud 有了解多少？ Spring Bean 的生命周期 HashMap 和 has
java bean 转为JSON
03-01
NULL 博文链接：https://elf8848.iteye.com/blog/259312
Bouncy Castle集成SM2与SM3
weixin_41850878的博客
07-28 629
SM2和SM3作为中国国家密码管理局制定的密码算法，在信息安全领域具有重要地位。在Bouncy Castle库中，可以方便地实现这两种算法以及它们的结合使用（如SM2+SM3签名算法），为Java应用程序提供高安全性的加密签名功能。
java bean jsonobject_javabean转jsonObject
weixin_39579548的博客
03-04 3740
工程场景：需要将一个javaBean转换成jsonObject对象。假设User user = new User();有三个属性，name、age、sex，我们对其设值user.setName("张三");user.setAget("32");user.setSex(null);现需要转换，我采用的方法是：JSONObject jsonObjectData = (JSONObject) JSONO...
javabean 转化成jsonObject
最新发布
weixin_36969169的博客
08-05 83
将 JavaBean 转换为 JSONObject 的方法 在Java开发中，经常需要将Java对象（通常称为JavaBean）转换为JSON格式，以便于数据传输和存储。在这篇文章中，我将带你了解如何实现JavaBean到JSONObject的转换，讲解每一步的实现流程，并提供必要的代码示例。 整体流程 我们将通过以下步骤...
将Javabean转化JSONObject为对象
Bii_yu的博客
05-08 6059
JSONObject.parseObject(JSONObject.toJSON(obj).toString())；
Java中实现参数名ASCII码从小到大排序（字典序）.doc
10-12
在Java编程中，有时我们需要对一组参数按照字典顺序（ASCII码值从小到大）进行排序，例如在创建签名或构建URL查询字符串时。这里提供了一个名为`createSign`的方法，它接受一个`Map, Object>`类型的参数，并返回一个...
Java JSON使用总结
Dong滴个Dong的博客
02-08 137
Json 相关 json 背景知识 SourceForge.net 是全球最大开源软件开发平台和仓库，网站建立的宗旨，就是为开源软件提供一个存储、协作和发布的平台。SourceForge 上拥有大量非常优秀的开源软件 net.sf.json和com.alibaba.fastjson对比 ： fastjson 更快 FastJson、Jackson、Gson、Json的效率简单对比 NULL值...
最强常用开发库总结 - JSON库详解
fk_99的博客
12-18 3502
内容目录 JSON简介 JSON是什么 结构与类型 JSON优秀资源 JSON在线解析工具 JSON类库 性能测试对比 FastJson Fastjson 简介 Fastjson 特性 下载和使用 序列化一个对象成JSON字符串 反序列化一个JSON字符串成Java对象 对于日期的处理 Bean和数组转换 设置字段名 设置是否不序列化某字段 设置字段顺序 自定义序列化和反序列化 FastJson漏洞问题 JackSon Ja
javaBean--jsonObject--jsonString相互转化
12-19
最近在研究Webservice的时候遇到一个问题，把java对象转化问json后传过去，接受的是String类型，怎么恢复到原来的java对象呢，后来再一个项目中看到了转换方法，转换顺序为javaBean--jsonObject--jsonString，还原顺序为jsonString--jsonObject--javaBean，所用jar包为json-lib-2.3-jdk15.jar，压缩包里是测试程序和jar包
Java bean转化为jsonObject异常
龙之竹的博客
08-17 2213
     首先解释下java bean转化为JSONObject的过程（我之前并不知道，才会有这次bug的产生）：      通过阅读源码，你会发现，json包会扫描java实体类中的所有get方法，并且把所有的getXXX()方法都执行一遍！然后在内部执行new JSONObject操作创建一个新的jsonObject对象，通过各种resolver解析器把从get中获取到的值都设置到这个jso...
java bean 转json 串_java中字符串和JSON对象、Bean之间的相互转换
weixin_35835018的博客
02-16 7330
JSON格式用于数据传输、bean用于封装数据信息、String用于展示封装信息、json格式的内容用json工具或者之间在json.cn展示比较清晰。一、将Sting转为Json在开发中，经常是前端发送一串数据过来之后，是通过一个参数带着一串值过来，这一串值是String 格式的，但是里面的内容其实是json格式类型的，所以拿到值之后就要将该值转化成json格式，然后获取里面指定的key就可以拿...
java bean jsonobject_JSON、JSONObject、JavaBean三者的相互转换
weixin_39984201的博客
02-16 1062
JSON、JSONObject、JavaBean三者的相互转换平常的开发中，json的转换是需要经常使用到的，特意整理了下。User user = new User(1L, "haha", 13, "erfa",new Date(),new Date(),1,3);@Testvoid testFastJson() {//将对象转换成json字符串String userToJsonString = ...
java bean jsonobject_JSON与Bean互转
weixin_30500365的博客
02-16 661
废话不多说，直接进入主题，json与javaBean之间的互相转换javaBean转换成json直接使用提供的方法可以得到jsonJSONObjectjson = JSONObject.fromObject(object);---------------------------------------------------------------------------------------p...
Json与JavaBean之间的转换
lihuking2011的博客
04-14 1071
项目中一些变化次数不大或者固定数据，为了提高用户访问速度，往往会转换成json字符串存入到redis中。当用户访问时，会从redis中获取，再转换成原数据传人到前端页面展示。说到json与javaBean之间的转换，这两者更加频繁，json本身就是作为数据交换格式而存在的。这里我只说最常见的一处位置：那就是将数据转换成json再存储到redis中。在这次项目中我使用的是阿里的fastJson,除此还有一个是谷歌的Gosn,这两个相对来说比较简单，上手快，另外，我还自己封装了一个工具类，也一起发表出来。
bean类数据顺序
Sinsinw的博客
08-12 196
后台的数据输出到前台，发现bean中的数据顺序有问题 可以在bean中直接对数据顺序做处理 @JsonProperty("ORG") privateStringORG; 紧接着 @JsonIgnore publicStringgetORG(){ returnORG; } @JsonIgno...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笑不语

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值