json转化工具类

json转化工具类
将对象转化为string
将string转化为某种类型的对象

将对象转为字符串, 如果传来对象为空,则返回空, 如果传来对象属于String,强转为String, 否则调用writeValueAsString方法

package com.mmall.common;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;

import java.util.HashMap;
import java.util.Map;

@Getter
@Setter
public class JsonData {

private boolean ret;

private String msg;

private Object data;

public JsonData(boolean ret) {
    this.ret = ret;
}

public static JsonData success(Object object, String msg) {
    JsonData jsonData = new JsonData(true);
    jsonData.data = object;
    jsonData.msg = msg;
    return jsonData;
}

public static JsonData success(Object object) {
    JsonData jsonData = new JsonData(true);
    jsonData.data = object;
    return jsonData;
}

public static JsonData success() {
    return new JsonData(true);
}

public static JsonData fail(String msg) {
    JsonData jsonData = new JsonData(false);
    jsonData.msg = msg;
    return jsonData;
}

public Map<String, Object> toMap() {
    HashMap<String, Object> result = new HashMap<String, Object>();
    result.put("ret", ret);
    result.put("msg", msg);
    result.put("data", data);
    return result;
}

}

package com.mmall.util;

import lombok.extern.slf4j.Slf4j;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.ser.impl.SimpleFilterProvider;
import org.codehaus.jackson.type.TypeReference;

@Slf4j
public class JsonMapper {
private static ObjectMapper objectMapper=new ObjectMapper();

//下面作用:和json互转时,排除掉 "空"字段
static {
    // config
    objectMapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
    objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
    objectMapper.setFilters(new SimpleFilterProvider().setFailOnUnknownId(false));
    objectMapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_EMPTY);
}

//将对象转为字符串,  如果传来对象为空,则返回空,   如果传来对象属于String,强转为String, 否则调用writeValueAsString方法
public static  <T> String obj2String(T src){
    if(src == null){
        return null;
    }
    try {
        return src instanceof String? (String) src :objectMapper.writeValueAsString(src);
    } catch (Exception e) {
        log.warn("Obj2String is exception",e);
        return null;
    }
}

public static <T> T string2Object(String src, TypeReference<T> typeReference){
    if(src==null || typeReference==null){
        return null;
    }
    try {
        return (T) (typeReference.getType().equals(String.class)?src :objectMapper.readValue(src,typeReference));
    } catch (Exception e) {
        log.warn("parse String to Object exception, String:{}, TypeReference<T>:{}, error:{}", src, typeReference.getType(), e);
        return null;
    }
}

}

package com.mmall.controller;
import com.mmall.common.ApplicationContextHelper;
import com.mmall.common.JsonData;
import com.mmall.dao.SysAclModuleMapper;
import com.mmall.exception.ParamException;
import com.mmall.model.SysAclModule;
import com.mmall.param.TestVo;
import com.mmall.util.BeanValidator;
import com.mmall.util.JsonMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Map;

@Controller
@RequestMapping("/test")
@Slf4j
public class TestController {

@RequestMapping("/hello.json")
@ResponseBody
public JsonData hello(){
    log.info("hello");

// System.out.println(“11111”);
throw new RuntimeException(“wode exception”);
// return JsonData.success(“hello,permission”);
}

// entr().size作用 https://blog.csdn.net/q5706503/article/details/85122343
@RequestMapping("/valid.json")
@ResponseBody
public JsonData valid(TestVo vo){
try {
Map<String,String> map= BeanValidator.validateObject(vo);
if(map!=null && map.entrySet().size()>0){
for (Map.Entry<String, String> entry : map.entrySet()) {
log.info("{}->{}",entry.getKey(),entry.getValue());
}
}
} catch (Exception e) {
e.printStackTrace();
}
return JsonData.success(“test valid”);
}

@RequestMapping("/validate.json")
@ResponseBody
public JsonData validate(TestVo vo) throws ParamException {
    log.info("validate");
    SysAclModuleMapper moduleMapper = ApplicationContextHelper.popBean(SysAclModuleMapper.class);
    SysAclModule module = moduleMapper.selectByPrimaryKey(2);
    log.info(JsonMapper.obj2String(module));
    BeanValidator.check(vo);
    return JsonData.success("test validate");
}

}