【Respnose响应实体类、Object非空工具类】_responseobj类和vo类的区别

自定义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);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276

返回响应前端的工具类

/**
 * 数据响应类
 * @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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

返回响应类的使用

/**
 * 接收前台数据,并校验必填非空数据
 * @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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21