自定义Response响应类和ObjectUtils 工具类
对于String、Collection、Map、Object等类型做非空判断
ObjectUtils类 是isEmpty() 判空的增强
对于String、Map、String[]、Collection。。。作非空判断
对于 Collection 集合类型，判断内容（值）是否为空（null、“”）
对于 Map 集合，判断 value 值是否为空（null、“”）
Map.isEmpty() 只判断了是否有内容，不判断内容是否为空字符串，这里对于空（null、“”）做了判断
其他类型转为String类型，Object转换成字符串
对于Object类型，采用多种判断
Map集合和Object对象直接的相互转换
对象和JSON数据的相互转换
对于入参的校验，必填参数非空的判断，以及必填参数为空的处理
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializeConfig;
import cn.molu.app.handle.BusinessException;
import cn.molu.app.vo.ResponseVo;
import lombok.extern.slf4j.Slf4j;
/**
* 对象工具类
*
* @Description
* @author 陌路
* @date 2022-07-22 下午6:50:47
*/
@Slf4j
public class ObjUtils {
/**
* 获取字符串数据
*
* @desc 对象转为字符串
* @param obj
* @return String
*/
public static String getStr(Object obj) {
if (null == obj)
return "";
if (obj instanceof String)
if ("".equals(obj) || obj.toString().trim().length() < 1 || StringUtils.isBlank((String) obj))
return "";
return obj.toString().trim();
}
/**
* 判断对象是否为空
*
* @desc 仅当对象为null或者没值时返回true
* @param obj
* @return boolean
*/
public static boolean isEmpty(Object obj) {
if (null == obj)
return true;
if (obj instanceof String)
return StringUtils.isBlank(getStr(obj));
if (obj instanceof Collection<?>)
return ((Collection<?>) obj).isEmpty();
if (obj instanceof Map<?, ?>)
return ((Map<?, ?>) obj).isEmpty();
if (obj instanceof Object[])
return Arrays.asList((Object[]) obj).isEmpty();
return ObjectUtils.isEmpty(obj);
}
/**
* 判断集合数据内容是否为空
*
* @desc 仅当所有值都为null||""时返回true
* @param c
* @return boolean
*/
public static boolean collIsBlank(Collection<?> c) {
if (null == c || c.isEmpty())
return true;
int i = 0;
for (Object v : c = new HashSet<>(c)) {
if (isEmpty(v))
i++;
}
return c.size() == i;
}
/**
* 判断Map集合内容是否为空
*
* @desc 仅当所有值都为null||""时返回true
* @param m
* @return boolean
*/
public static boolean mapIsBlank(Map<?, ?> m) {
if (null == m || m.isEmpty())
return true;
if (m.keySet().isEmpty())
return true;
return collIsBlank(m.values());
}
/**
* @desc 仅当有一个值都为null||""时返回true
* @param obj
* @return boolean
*/
public static boolean isEmpty(Object... obj) {
if (null == obj)
return true;
for (Object o : obj) {
if (StringUtils.isBlank(getStr(o)))
return true;
}
return false;
}
/**
* JSON数据转Map集合
*
* @param json
* @return Map<?,?>
*/
public static Map<?, ?> jsonToMap(String s) {
if (StringUtils.isBlank(s))
return new HashMap<String, String>();
return JSONObject.parseObject(s, Map.class);
}
/**
* Map集合转Object
*
* @return T
*/
public static <T> T mapToObj(Map<String, Object> map, Class<T> obj) {
if (null == obj || null == map || map.isEmpty())
return null;
return JSONObject.parseObject(toJSON(map), obj);
}
/**
* @title 对象数据转JSONString数据
* @Desc 实现了 SerializeConfig.globalInstance
*/
public static String toJSON(Object obj) {
if (isEmpty(obj))
return "";
return getStr(JSONObject.toJSON(obj, SerializeConfig.globalInstance));
}
/**
* JSON数据转对象
*
* @return T
*/
public static <T> T toObj(String jsonStr, Class<T> obj) {
if (StringUtils.isBlank(jsonStr) || null != obj)
return null;
return JSONObject.parseObject(jsonStr, obj);
}
/**
* 数据检验，有一个值为空则结束执行，并抛出errMsg异常
*
* @desc 为true时校验通过
* @return boolean
*/
public static boolean checkData(String errMsg, Object... params) {
if (StringUtils.isBlank(errMsg))
errMsg = ResponseVo.PARAM_ERR_STR;
if (null == params || isEmpty(params)) {
log.error("数据校验失败。。。");
throw new BusinessException(errMsg);
}
return true;
}
/**
* 比较两个对象是否相等
*
* @return boolean
*/
public static boolean equals(Object o1, Object o2) {
if (StringUtils.equals(getStr(o1), getStr(o2)) || o1.equals(o2))
return true;
return false;
}
/**
* 比较两个对象是否相等
*
* @return boolean
*/
public static boolean equalsIgnoreCase(Object o1, Object o2) {
if (StringUtils.equalsIgnoreCase(getStr(o1), getStr(o2)))
return true;
return false;
}
/**
* 把Map集合转为XML字符串
*
* @desc Map的Key和Value必须为String类型
* @param m
* @return String
*/
public static String mapToXML(Map<String, String> m) {
if (isEmpty(m))
return "";
StringBuffer sbf = new StringBuffer();
m.forEach((k, v) -> {
if (!isEmpty(k))
sbf.append(String.format("<%s>%s</%s>", k, getStr(v), k));
});
return sbf.toString();
}
/**
* 替换字符串中的？
*
* @param str
* @param val
* @return String
*/
public static String getVal(String str, String... val) {
String format = "";
for (String v : val) {
format = String.format(str, v);
}
return format;
}
/**
* 获取格式化日期 y-M-d H:m:s
*
* @return String
*/
public static String dateFormat() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
}
/**
* @Title 格式化日期
* @return String
*/
public static String dateFormat(Date date, String pattern) {
date = "".equals(getStr(date)) ? new Date() : date;
pattern = "".equals(getStr(pattern)) ? "yyyy-MM-dd HH:mm:ss" : pattern;
return new SimpleDateFormat(pattern).format(date);
}
/**
* 获取用户真实IP地址
*
* @param request
* @desc 不使用request.getRemoteAddr();的原因是有可能用户使用了代理软件方式避免真实IP地址,
* 如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值，哪个才是真实IP？
* 答案是取X-Forwarded-For中第一个非unknown的有效IP字符串。
* 如：X-Forwarded-For：192.168.1.110, 192.168.1.120, 192.168.1.130,
* 192.168.1.100 用户真实IP为： 192.168.1.110
*/
public static String getIp(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (isEmpty(ip) || "unknown".equalsIgnoreCase(ip))
ip = request.getHeader("Proxy-Client-IP");
if (isEmpty(ip) || "unknown".equalsIgnoreCase(ip))
ip = request.getHeader("WL-Proxy-Client-IP");
if (isEmpty(ip) || "unknown".equalsIgnoreCase(ip))
ip = request.getHeader("HTTP_CLIENT_IP");
if (isEmpty(ip) || "unknown".equalsIgnoreCase(ip))
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
if (isEmpty(ip) || "unknown".equalsIgnoreCase(ip))
ip = request.getRemoteAddr();
if (ip.replace(" ", "").replace("unknown,", "").indexOf(",") > 0)
ip = ip.substring(0, ip.indexOf(","));
return getStr(ip);
}
}
返回响应前端的工具类
/**
* 数据响应类
* @Description
* @author 陌路
* @date 2022-01-16
*/
public class R extends HashMap<String, Object> implements Serializable {
private static final long serialVersionUID = 1L;
/** 只返回code值 */
public static final R OK = R.set("code", 200);
/** 返回flag和code值 */
public static final R ok = R.set("code", 200).put("flag", true);
public R() {
}
/**
* 返回默认信息 flag msg code data
* @return R
*/
public static R ok() {
R r = new R();
r.put("flag", true);
r.put("msg", "成功！");
r.put("code", 200);
r.put("data", null);
return r;
}
/**
* 添加返回值对象data
* @return R
*/
public static R ok(Object data) {
R r = new R();
r.put("flag", true);
r.put("msg", "成功！");
r.put("code", 200);
r.put("data", data);
return r;
}
/**
* 自定返回值对象key value
* @return R
*/
public static R ok(String key, String value) {
R r = new R();
r.put("flag", true);
r.put("msg", "成功！");
r.put("code", 200);
r.put("data", null);
r.put(key, value);
return r;
}
/**
* 添加返回值对象和提示信息
* @return R
*/
public static R ok(Object data, String msg) {
R r = new R();
r.put("flag", true);
r.put("msg", msg);
r.put("code", 200);
r.put("data", data);
return r;
}
/**
* 返回默认错误信息 flag msg code
* @return R
*/
public static R err() {
R r = new R();
r.put("flag", false);
r.put("msg", "服务器返回失败！");
r.put("code", 500);
r.put("data", null);
return r;
}
/**
* 添加自定义错误信息 msg
* @return R
*/
public static R err(String msg) {
R r = new R();
r.put("flag", false);
r.put("msg", msg);
r.put("code", 500);
return r;
}
/**
* 自定义返回信息 msg error vo
* @param msg 提示信息
* @param error error信息
* @param vo enum
* @return R
*/
public static R err(String msg, Object error, ResponseVo vo) {
R r = new R();
r.put("flag", false);
r.put("code", 500);
if (StringUtils.isNotEmpty(msg)) {
r.put("msg", msg);
}
if (ObjectUtils.isNotEmpty(error)) {
r.put("error", error);
}
if (ObjectUtils.isNotEmpty(vo)) {
r.put("error", vo);
}
return r;
}
/**
* 自定义返回信息 msg error
* @param msg 提示信息
* @param error error信息
* @return R
*/
public static R err(String msg, Object error) {
return err(msg, error, null);
}
/**
* 错误信息
* @param error enum
* @return String
*/
public static String err(ResponseVo error) {
R r = new R();
r.put("flag", false);
r.put("error", error);
String jsonString = JSONObject.toJSONString(error);
return jsonString;
}
/**
* 返回错误信息
* @param error 异常信息
* @param msg 提示信息
* @return String
*/
public static String err(Object error, String msg) {
R r = new R();
r.put("flag", false);
r.put("code", 500);
if (StringUtils.isNotEmpty(msg)) {
r.put("msg", msg);
}
if (ObjectUtils.isNotEmpty(error)) {
r.put("error", error);
}
String jsonString = JSONObject.toJSONString(error);
return jsonString;
}
/**
* 只返回异常信息
* @param error
* @return String
*/
public static String err(Object error) {
return err(error, null);
}
@Override
public R put(String key, Object value) {
super.put(key, value);
return this;
}
/**
* 定义静态方法
* @param key
* @param value
* @return R
*/
public static R set(String key, Object value) {
R r = new R();
r.put(key, value);
return r;
}
}
返回响应类的使用
/**
* 接收前台数据,并校验必填非空数据
* @param params
* @param res
* @return R
*/
@ResponseBody
@PostMapping("check")
public R checkData(@RequestParam Map<String, Object> params, HttpServletResponse res) {
// 校验params,当为空集合,或者所有的值都为空时 返回提示信息,方法结束
ObjectUtils.checkNull(res, params, "参数不能为空!");// 将信息返回,下面的方法不在执行
String resMsg = "必要参数不可为空!";// 检测到必需参数有为空时,将该信息返回前端
String str = " ";
Object obj = null;
Integer inte = 0;
List<String> list = new ArrayList<String>();
Map<String, Object> map = new HashMap<String, Object>();
// 多参必填非空数据的校验
ObjectUtils.checkNull(res, resMsg, str, obj, inte, list, map);// 有一个为空,下面的方法将不会在执行
return R.ok("执行成功！").put("parm", params);
}
576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
