fastJson心得

已于 2022-08-22 10:05:58 修改
阅读量376 收藏
点赞数 1
文章标签： json
于 2021-09-24 17:28:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52925162/article/details/120459641
版权

开启fastJson的autoType全局配置

fastjson autoType is not support，有@字符串报错，开启后消除

    @Bean
    fun fastJson(){
        ParserConfig.getGlobalInstance().isAutoTypeSupport = true
    }

转换成json

    fun parsePhone(phoneStr: String?): MutableList<Phone> {
        val jsonBody = JSONObject.toJSONString(phoneStr )
        val jsonObject = JSONObject.parseObject("{\"phone\": " + jsonBody + "}")
        val phoneList = mutableListOf<Phone>()
        val phones = jsonObject.getJSONArray("phone")
        val iteratorPhone = phones?.iterator()
        if (iteratorPhone != null) {
            while (iteratorPhone.hasNext()) {
                val next = iteratorPhone.next() as JSONObject
                val phone = Phone()
                phone.mobileNoAreaCode = next["phonearea"]?.toString()
                phone.mobileNo = next["phoneval"]?.toString()

                phoneList.add(phone)
            }
        }
        return phoneList
    }

便捷转换

快速获取shopCode 

                val shopResponse = RestTemplateUtils.getRestTemplate().exchange(
                    UriComponentsBuilder.fromHttpUrl(applicationProperties.globalCmsApiEndpoint + "/v1/api/shop_list")
                        .queryParam("get_type", "")
                        .queryParam("shopid", shop.shopId)
                        .queryParam("channel_id", "4")
                        .toUriString(),
                    HttpMethod.GET,
                    entity,
                    Object::class.java,
                )
                shop.shopCode = ((shopResponse.body as Map<*, *>)["result"] as List<Map<String, Object>>)
                    .find { it["shopid"].toString() == shop.shopId }?.get("shopcode").toString()
                shopList.add(shop)

不知道json数据的key和value，遍历并使用key获取value数据

        val shops = personnel.getJSONObject("shop")
        val jsonObj = JSON.parseObject(shops.toString())
        for ((key,value) in jsonObj){
            val shops = shops.getJSONArray(key)
            val iteratorShop = shops.iterator()
            while (iteratorShop.hasNext()) {
                val shopNext = iteratorShop.next() as JSONObject
                val shop = ShopDto()
                shop.shopId = shopNext["store_id"]?.toString()
                shop.locations.add(I18nString(LocaleUtils.SIMPLIFIED_CHINESE, shopNext["atitle"]?.toString() ?: ""))
                shop.locations.add(I18nString(LocaleUtils.TRADITIONAL_CHINESE, shopNext["tc_atitle"]?.toString() ?: ""))
                shop.locations.add(I18nString(LocaleUtils.ENGLISH, shopNext["en_atitle"]?.toString() ?: ""))
                shop.clinics.add(I18nString(LocaleUtils.SIMPLIFIED_CHINESE, shopNext["cn_name"].toString()))
                shop.clinics.add(I18nString(LocaleUtils.TRADITIONAL_CHINESE, shopNext["tc_name"].toString()))
                shop.clinics.add(I18nString(LocaleUtils.ENGLISH, shopNext["en_name"].toString()))
                shop.address.add(I18nString(LocaleUtils.SIMPLIFIED_CHINESE, parseAddress(shopNext["cn_address"]?.toString() ?: "")))
                shop.address.add(I18nString(LocaleUtils.TRADITIONAL_CHINESE, parseAddress(shopNext["tc_address"]?.toString() ?: "")))
                shop.address.add(I18nString(LocaleUtils.ENGLISH, parseAddress(shopNext["en_address"]?.toString() ?: "")))
                shop.mail = shopNext["mail"]?.toString()
                shop.phone = parsePhone(shopNext["phone"]?.toString())
                //TODO shopCode
                shopList.add(shop)
        }

----------------------------------------------------------------------
val regionJsonObject = next["region_list"]
            //补充，此处有数据时为object，没有数据时为空数组，需先判断
            if (regionJsonObject is JSONObject) {
                val jsonObj = JSON.parseObject(regionJsonObject.toString())
                for ((key, value) in jsonObj) {
                    val regionList = (regionJsonObject as JSONObject).getJSONArray(key)
                    val regionListIterator = regionList.iterator()
                    while (regionListIterator.hasNext()) {
                        val regionListNext = regionListIterator.next() as JSONObject
                        val shop = MongoDBShopsDto()
                        shop.shopId = regionListNext["shopid"]?.toString()
                        shop.shopCode = regionListNext["shopcode"]?.toString()
                        shop.regionId = regionListNext["x_id"]?.toString()
                        shop.locations.add(
                            I18nString(
                                LocaleUtils.SIMPLIFIED_CHINESE, regionListNext["atitle"]?.toString() ?: ""
                            )
                        )
                        shop.locations.add(
                            I18nString(
                                LocaleUtils.TRADITIONAL_CHINESE,
                                regionListNext["tc_atitle"]?.toString() ?: ""
                            )
                        )
                        shop.locations.add(
                            I18nString(
                                LocaleUtils.ENGLISH,
                                regionListNext["en_atitle"]?.toString() ?: ""
                            )
                        )
                        shop.clinics.add(
                            I18nString(
                                LocaleUtils.SIMPLIFIED_CHINESE,
                                regionListNext["cn_name"].toString()
                            )
                        )
                        shop.clinics.add(
                            I18nString(
                                LocaleUtils.TRADITIONAL_CHINESE,
                                regionListNext["tc_name"].toString()
                            )
                        )
                        shop.clinics.add(I18nString(LocaleUtils.ENGLISH, regionListNext["en_name"].toString()))
                        shop.address.add(
                            I18nString(
                                LocaleUtils.SIMPLIFIED_CHINESE,
                                parseAddress(regionListNext["cn_address"]?.toString() ?: "")
                            )
                        )
                        shop.address.add(
                            I18nString(
                                LocaleUtils.TRADITIONAL_CHINESE,
                                parseAddress(regionListNext["tc_address"]?.toString() ?: "")
                            )
                        )
                        shop.address.add(
                            I18nString(
                                LocaleUtils.ENGLISH,
                                parseAddress(regionListNext["en_address"]?.toString() ?: "")
                            )
                        )
                        shop.mail = regionListNext["mail"]?.toString()
                        shop.phone = parsePhone(regionListNext["phone"]?.toString())
                        shop.businessDays = parseBusinessDays(regionListNext["business_hours"]?.toString())
                        doctor.shops.add(shop)
                    }
                }
            }

处理json的星期数据

package com.umh.medicalbookingplatform.background.service

import com.umh.medicalbookingplatform.core.error.ErrorCode
import com.umh.medicalbookingplatform.core.exception.ApplicationException
import com.umh.medicalbookingplatform.core.properties.ApplicationProperties
import com.umh.medicalbookingplatform.core.utils.RestTemplateUtils
import com.alibaba.fastjson.JSONObject
import com.umh.medicalbookingplatform.core.model.i18n.I18nString
import com.umh.medicalbookingplatform.core.utils.LocaleUtils
import org.apache.commons.lang3.StringUtils
import org.keycloak.admin.client.Keycloak
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.data.domain.Pageable
import org.springframework.http.HttpEntity
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.http.ResponseEntity
import org.springframework.stereotype.Service
import org.springframework.web.util.UriComponentsBuilder
import java.lang.StringBuilder
import java.util.*
import com.alibaba.fastjson.JSON
import com.umh.medicalbookingplatform.core.model.doctor.*
import com.umh.medicalbookingplatform.core.utils.ApplicationJsonObjectMapper
import org.bson.Document
import org.springframework.data.mongodb.core.MongoTemplate
import org.springframework.data.mongodb.core.query.Criteria
import org.springframework.data.mongodb.core.query.Query


/**
 * @Description :
 * @Author xiaomh
 * @create 2021/9/8 14:27
 */

@Service
class ApiCmsInvokeService {

    private val dayArray = arrayOf("mon", "tue", "wed", "thu", "fri", "sat", "sun", "gong")


    private fun parseBusinessDays(businessHoursStr: String?): MutableList<BusinessHourDto> {
        val jsonObject = JSONObject.parseObject(businessHoursStr)
        return parseBusinessHours(jsonObject)

    }

    private fun parseBusinessHours(jsonObject: JSONObject?): MutableList<BusinessHourDto> {
        val businessHours = mutableListOf<BusinessHourDto>()
        for (i in dayArray.indices) {
            val hoursJson = jsonObject?.getJSONArray(dayArray[i])
            val iterator = hoursJson?.iterator() ?: mutableListOf<BusinessHourDto>().iterator()
            val hourDto = BusinessHourDto()
            while (iterator.hasNext()) {
                val next = iterator.next() as JSONObject
                hourDto.periods!!.add(
                    BusinessHourPeriodDto().apply {
                        this.startTime = next["starttime"]?.toString() ?: ""
                        this.endTime = next["endtime"]?.toString() ?: ""
                    }
                )
            }
            if (dayArray[i] == "gong") {
                hourDto.day = "holiday"
            } else {
                hourDto.day = dayArray[i]
            }
            businessHours.add(hourDto)
        }
        return businessHours
    }


}
        val obj = mapOf(
            "test" to "test",
            "inner_test" to mapOf(
                "value" to "123456"
            )
        )



        val requestBody = mapOf(
            "id" to umhId,
            "hkid" to value,
            "country" to when (idType) {
                PersonalIdType.HKID -> "1"
                PersonalIdType.CHINA_ID -> "2"
                PersonalIdType.MACAU_ID -> "5"
                PersonalIdType.OTHERS -> "6"
            }
        )
        val firstName = jsonObject.getJSONArray("firstName").toArray()
        val lastName = jsonObject.getJSONArray("lastName").toArray()        
        val objectMapper = ApplicationJsonObjectMapper()        
        dto.firstName = objectMapper.convertValue(firstName, Array<I18nString>::class.java).toMutableList()
        dto.lastName = objectMapper.convertValue(lastName, Array<I18nString>::class.java).toMutableList()

枚举应用

enum class PersonalIdType {
    HKID, CHINA_ID, MACAU_ID, OTHERS
}



    fun updateUmhMemberIdentificationDocumentNo(
        umhMemberId: String,
        umhId: String,
        idType: PersonalIdType,
        value: String
    ): Boolean {

        val requestBody = mapOf(
            "id" to umhId,
            "hkid" to value,
            "country" to when (idType) {
                PersonalIdType.HKID -> "1"
                PersonalIdType.CHINA_ID -> "2"
                PersonalIdType.MACAU_ID -> "5"
                PersonalIdType.OTHERS -> "6"
            }
        )

RestTemplate 和 WebClient

package com.umh.medicalbookingplatform.core.utils

import org.apache.http.impl.client.HttpClients
import org.springframework.http.HttpRequest
import org.springframework.http.MediaType
import org.springframework.http.client.ClientHttpRequestExecution
import org.springframework.http.client.ClientHttpRequestInterceptor
import org.springframework.http.client.ClientHttpResponse
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
import org.springframework.retry.RetryContext
import org.springframework.retry.policy.SimpleRetryPolicy
import org.springframework.retry.support.RetryTemplate
import org.springframework.web.client.RestTemplate
import java.io.IOException


class RestTemplateUtils {

    companion object {
        fun getRestTemplate(timeOutTime :Int? = null, maxAttempt: Int? = null): RestTemplate {

            val httpClient = HttpClients.custom()
//                .setSSLSocketFactory(csf)
                //        .setProxy(proxy)
                .build()
            val requestFactory = HttpComponentsClientHttpRequestFactory()
            requestFactory.httpClient = httpClient
            if(timeOutTime != null) {
                requestFactory.setConnectTimeout(timeOutTime)
                requestFactory.setReadTimeout(timeOutTime)
            } else {
                requestFactory.setConnectTimeout(5 * 60 * 1000)
                requestFactory.setReadTimeout(5 * 60 * 1000)
            }

            val restTemplate = RestTemplate(requestFactory)

            if (maxAttempt != null) {
                restTemplate.interceptors.add(ClientHttpRequestInterceptor { request: HttpRequest?, body: ByteArray?, execution: ClientHttpRequestExecution ->
                    val retryTemplate = RetryTemplate()
                    retryTemplate.setRetryPolicy(SimpleRetryPolicy(maxAttempt))
                    try {
                        retryTemplate.execute<ClientHttpResponse, IOException> { context: RetryContext? ->
//                            println("start retrying .... ${context?.retryCount}")
                            execution.execute(request, body)
                        }
                    } catch (throwable: Throwable) {
                        throw RuntimeException(throwable)
                    }
                })
            }

            val supportedMediaTypes = ArrayList<MediaType>()
            supportedMediaTypes.add(MediaType.APPLICATION_JSON)
//        supportedMediaTypes.add(ActuatorMediaTypes)
            supportedMediaTypes.add(MediaType.TEXT_PLAIN)
            val converter = MappingJackson2HttpMessageConverter()
            val objectMapper = ApplicationJsonObjectMapper()

            converter.objectMapper = objectMapper
            converter.setPrettyPrint(true)
            converter.supportedMediaTypes = supportedMediaTypes

            restTemplate.messageConverters.add(0, converter)
            return restTemplate
        }
    }
}
package com.umh.medicalbookingplatform.core.utils

import io.netty.channel.ChannelOption
import io.netty.handler.timeout.ReadTimeoutHandler
import io.netty.handler.timeout.WriteTimeoutHandler
import org.springframework.http.MediaType
import org.springframework.http.client.reactive.ReactorClientHttpConnector
import org.springframework.http.codec.ClientCodecConfigurer
import org.springframework.http.codec.json.Jackson2JsonDecoder
import org.springframework.http.codec.json.Jackson2JsonEncoder
import org.springframework.web.reactive.function.client.ExchangeStrategies
import org.springframework.web.reactive.function.client.WebClient
import reactor.netty.http.client.HttpClient
import java.time.Duration


class WebClientUtils {

    companion object {
        fun getWebClient(timeOutTime: Int? = null): WebClient {


            val httpClient = HttpClient.create()
//                .responseTimeout(Duration.ofSeconds(timeOutTime?.toLong() ?: (5 * 60)))
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)
                .doOnConnected { connection ->
                    connection
                        .addHandlerLast(ReadTimeoutHandler(timeOutTime ?: (5 * 60)))
                        .addHandlerLast(WriteTimeoutHandler(timeOutTime ?: (5 * 60)))
                }

            val strategies = ExchangeStrategies
                .builder()
                .codecs { clientDefaultCodecsConfigurer: ClientCodecConfigurer ->
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonEncoder(
                            Jackson2JsonEncoder(
                                ApplicationJsonObjectMapper(),
                                MediaType.APPLICATION_JSON
                            )
                        )
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .jackson2JsonDecoder(
                            Jackson2JsonDecoder(
                                ApplicationJsonObjectMapper(),
                                MediaType.APPLICATION_JSON
                            )
                        )
                    clientDefaultCodecsConfigurer.defaultCodecs()
                        .maxInMemorySize(16 * 1024 * 1024)
                }.build()


            return WebClient.builder()
                .clientConnector(ReactorClientHttpConnector(httpClient))
                .exchangeStrategies(strategies)
                .build()
        }
    }
}
//        val headers = HttpHeaders()
//        headers.set("Accept", "application/json")
//        headers.set("version", "v1")
//        headers.set("x-umhappweb-authorization", keycloakGlobalCmsApi.tokenManager().accessToken.token)
//        val entity = HttpEntity(null, headers)
        val apiCmsInvokeUri =
            UriComponentsBuilder.fromHttpUrl(applicationProperties.globalCmsApiEndpoint + "/v1/api/specialty_list")
                .queryParam("get_type", "")
                .queryParam("channel_id", "4")
                .queryParam("state", "2")
                .toUriString()
        val response: Any?
        try {
            logger.info("[START] Call globalcms '$apiCmsInvokeUri'")
//            response = RestTemplateUtils.getRestTemplate().exchange(
//                    UriComponentsBuilder.fromHttpUrl(applicationProperties.globalCmsApiEndpoint + apiCmsInvokeUri)
//                            .queryParam("get_type", "")
//                            .queryParam("channel_id", "4")
//                            .queryParam("state", "2")
//                            .toUriString(),
//                    HttpMethod.GET,
//                    entity,
//                    Object::class.java,
//            )
            response = WebClientUtils.getWebClient()
                .method(HttpMethod.GET)
                .uri(apiCmsInvokeUri)
                .header("Accept", "application/json")
                .header("version", "v1")
                .header("x-umhappweb-authorization", keycloakGlobalCmsApi.tokenManager().accessToken.token)
                //                .body(Mono.just(param), UmhBookingParam::class.java)
                .retrieve()
                .bodyToMono(object : ParameterizedTypeReference<Any?>() {})
                .block()
            logger.info("[END] Call globalcms '$apiCmsInvokeUri'")
        } catch (e: WebClientResponseException) {
            logger.error(e.responseBodyAsString, e)
            throw ApplicationException(ErrorCode.ERR_GLOBAL_CMS_SPECIALTIES_API)
        }

淡漠世俗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
fastJson
weixin_43400432的博客
08-04 414
Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。导入依赖fastjsonx.x.x输出结果为：[{“AGE”:15,},{“AGE”:20,}]还可以自定义输出，并控制字段的排序，日期显示格式，序列化标记等。以上代码列出了基本参数类别，并使用了@JSONField注解，以便实现自定义转换。format 参数用于格式化date属性。...
FastJson
musk6的博客
03-23 357
------FastJson使用注意事项--- 字段不同没关系，都可以通过，甚至一个字段都不匹配都可以                  但是被转换的javabean必须存在无参构造方法 --- 举个例子   ----- 3个javabean   Man,java public class Man { public String tall; public Man(
FastJson.java
09-04
com.alibaba.fastjson.JSON读写json
初探fastJson的AutoType
溪c的博客
05-24 1万+
文章目录1. AutoType 何方神圣？1.1 type字段1.2 setAutoTypeSupport2.反序列化攻击3.AutoType 安全模式4.参考 1. AutoType 何方神圣？ 参考 https://juejin.cn/post/6846687594130964488 fastjson的主要功能就是将Java Bean序列化成JSON字符串，这样得到字符串之后就可以通过数据库等方式进行持久化了。 但是，fastjson在序列化以及反序列化的过程中并没有使用Java自带的序列化机制，而
Fastjson开启安全模式5种方法（VIP典藏版）
2301_76379269的博客
04-11 925
一、Fastjson漏洞事件始末。
Fastjson报autotype is not support
最新发布
pleaseprintf的博客
04-13 1292
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。打开AutoType功能在1.2.25之后的版本，以及所有的.sec01后缀版本中，autotype功能是受限的，和之前的版本不同，如果在升级的过程中遇到问题，可以通过以下方法配置。注意：如果配置了safeMode，配置白名单也是不起作用的。一、添加autotype白名单在代码中配置如果有多个包名前缀，分多次addAccept加上JVM启动参数。
json表示map_JSON字符串转换为Map
weixin_39568597的博客
12-19 340
Created by zkn on 2016/8/22.*/public class JsonToMapTest01 {public static void main(String[] args){String str = "{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}";//第一种方式Map maps =...
FastJson中AutoType反序列化漏洞
qq_53058639的博客
02-20 1163
在Fastjson
fastjson报autotype is not support
热门推荐
xiaolyuh的专栏
11-30 1万+
安全升级公告 最近发现fastjson在1.2.24以及之前版本存在远程代码执行高危安全漏洞，为了保证系统安全，请升级到1.2.28/1.2.29/1.2.30/1.2.31或者更新版本。 1.2.29//1.2.30/1.2.31是在1.2.28版本上修复了一些大家升级过程中遇到的问题的版本，非安全问题，如果升级到1.2.25~1.2.28以及各种sec01版本的，也是没有安全问题的。 1...
fastjson将json字符串转化成map的五种方法
我的笔记
10-12 2120
package com.zkn.newlearn.json; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import java.util.Map; /** * JSON字符串自动转换 * */ public class JsonToMapTest01 {...
利用fastjson将json字符串转换为map对象
yuhuofei的草屋
08-17 8033
利用 fastjson 包将 json 字符串转换为 map 对象。
FastJson 解析对象或者对象数组用法
Y
06-10 920
需要提前导入依赖，才能使用下面的接口。
FastJsonJar
01-05
FastJsonJar_你要的都在里面。。。。。。。。。。。。
fastjson.zip
03-04
fastjson依赖包，1.1.41,1.2.21，1.2.44,1.2.58,1.2.60，1.2.61
fastjson工具
06-19
FastJson对于json格式字符串的解析主要用到了下面三个类： 1.JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换 2.JSONObject：fastJson提供的json对象 3.JSONArray：fastJson提供json...
fastjson源码
02-22
fastjson源码，
多次触发FastJson漏洞的AutoType机制，你了解吗？
weixin_45701550的博客
12-24 1351
解决问题的方法也很简单，既然@type指定的类型不存在，那么可以在系统中把需要的类型定义出来，不过@type指定的类型，是三方接口系统中定义的，如果把该类型引入到调用方系统中，那么对于调用方的侵入性很大，而且定义这个类型，仅仅为了解决这个问题，有很大解释成本在里面。从内容上看，比较特殊的地方在于多了一个特殊的字段“@type”，经过测试，反序列化报错，的确是因为这个特殊的字段造成的(把@type字段去掉，反序列化可以正常进行)。） fastjson。导致的，那么在序列化时，把类型信息给添加上可以了。
fastjson开启safeMode，关闭autoType，去除安全漏洞
blood_Z的博客
05-26 5993
## fastjson开启safeMode，关闭autoType，去除安全漏洞 在1.2.68之后的版本，在1.2.68版本中，fastjson增加了safeMode的支持。safeMode打开后，完全禁用autoType。所有的安全修复版本sec10也支持SafeMode配置。 有三种方式配置SafeMode，如下: 在代码中配置 ParserConfig.getGlobalInstance().setSafeMode(true); 注意，如果使用new ParserConfig的方式，需要注意单例处
fastjson fastjson2
09-02
Fastjson和Fastjson2都是JSON库，用于处理JSON格式的数据。 Fastjson2是Fastjson项目的重要升级，旨在为未来十年提供高性能的JSON库。相比于原来的Fastjson，Fastjson2在性能上有了很大的提升，并且更加安全。它完全...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值