ruoyi的spring cloud项目详解（十一）-CSDN博客
接着上一篇学习
com/ruoyi/common/utils/MessageUtils.java
package com.ruoyi.common.utils;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;
import com.ruoyi.common.utils.spring.SpringUtils;
/**
* 获取i18n资源文件
*
* @author ruoyi
*/
public class MessageUtils
{
/**
* 根据消息键和参数 获取消息 委托给spring messageSource
*
* @param code 消息键
* @param args 参数
* @return 获取国际化翻译值
*/
public static String message(String code, Object... args)
{
MessageSource messageSource = SpringUtils.getBean(MessageSource.class);
return messageSource.getMessage(code, args, LocaleContextHolder.getLocale());
}
}
以下是对这段代码的分析，以代码块形式呈现
一、导入依赖部分
package com.ruoyi.common.utils;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;
import com.ruoyi.common.utils.spring.SpringUtils;
这里导入了必要的类，包括 Spring 的MessageSource用于处理国际化消息，LocaleContextHolder用于获取当前线程的本地化信息，以及自定义的SpringUtils可能用于获取 Spring 容器中的 bean。
二、类定义部分
public class MessageUtils {
定义了一个名为MessageUtils的类。
三、获取国际化消息的方法部分
public static String message(String code, Object... args) {
MessageSource messageSource = SpringUtils.getBean(MessageSource.class);
return messageSource.getMessage(code, args, LocaleContextHolder.getLocale());
}
}
这个静态方法message用于根据给定的消息键code和可变参数args获取国际化翻译后的消息。
- 首先通过
SpringUtils.getBean(MessageSource.class)从 Spring 容器中获取MessageSource实例。 - 然后调用
messageSource.getMessage(code, args, LocaleContextHolder.getLocale())来获取国际化消息。其中，code是消息键，args是可能的参数列表，LocaleContextHolder.getLocale()用于获取当前线程的本地化信息，以确定使用哪种语言的资源文件进行翻译，最后返回翻译后的消息字符串。
以下是对这段 Java 代码的整体解释：
一、功能概述
这段代码定义了一个名为MessageUtils的工具类，主要用于获取国际化（i18n）资源文件中的消息。
二、详细分析
-
导入依赖：
org.springframework.context.MessageSource：Spring 框架中用于处理国际化消息的接口。它能够根据不同的语言环境和消息键获取相应的翻译文本。org.springframework.context.i18n.LocaleContextHolder：用于获取当前线程的本地化上下文信息，即当前使用的语言环境。通过这个类可以确定要使用哪种语言的资源文件进行消息的查找和翻译。com.ruoyi.common.utils.spring.SpringUtils：可能是自定义的工具类，用于获取 Spring 容器中的 bean。在这个场景中，用于获取MessageSource的实例。
-
类定义：
MessageUtils类：这个类的目的是提供一个方便的方法来获取国际化消息。它通常被其他部分的代码调用，以获取特定消息键对应的翻译后的消息。
-
方法分析：
message(String code, Object... args)方法：- 参数：
code：消息键，用于在国际化资源文件中标识特定的消息。例如，可以是一个字符串，如 “welcome.message”。args：可变参数，用于在消息中包含动态的部分。例如，如果消息中有占位符，可以通过这些参数来替换占位符。
- 功能实现：
- 首先，通过
SpringUtils.getBean(MessageSource.class)从 Spring 容器中获取MessageSource的实例。MessageSource是 Spring 框架中用于处理国际化消息的核心接口，它负责根据给定的消息键和语言环境查找并返回相应的翻译后的消息。 - 然后，调用
messageSource.getMessage(code, args, LocaleContextHolder.getLocale())来获取国际化翻译后的消息。这个方法接受消息键、参数列表和当前线程的语言环境作为参数。它会根据消息键在相应的国际化资源文件中查找消息，并使用参数来替换消息中的占位符，如果有的话。最后返回翻译后的消息字符串。
- 首先，通过
- 参数：
三、使用场景和优势
-
使用场景：
- 在国际化的应用程序中，当需要在不同的语言环境下显示特定的消息时，可以使用
MessageUtils.message()方法。例如，在用户界面上显示提示信息、错误消息、欢迎消息等场景中，可以根据消息键获取相应的国际化翻译后的文本。 - 可以在后端代码中使用这个方法来生成动态的消息，然后将其返回给前端或者用于日志记录等目的。
- 在国际化的应用程序中，当需要在不同的语言环境下显示特定的消息时，可以使用
-
优势：
- 集中了获取国际化消息的逻辑，使得在整个应用程序中获取国际化消息的方式更加统一和方便。
- 充分利用了 Spring 的国际化支持，通过
MessageSource和LocaleContextHolder可以轻松地根据当前的语言环境获取正确的翻译。 - 可扩展性强，如果需要对获取国际化消息的逻辑进行进一步的定制或扩展，可以在这个工具类中进行修改，而不会影响到应用程序的其他部分。
com/ruoyi/common/utils/RandomUtil.java
package com.ruoyi.common.utils;
import org.apache.commons.lang3.RandomStringUtils;
public class RandomUtil
{
private static char[] chars = new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e',
'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
'V', 'W', 'X', 'Y', 'Z'};
private static char[] nubers = new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
/**
* 生成随机字符串，包含数字和字母
* @param length 长度
* @return
* @author zmr
*/
public static String randomStr(int length)
{
return RandomStringUtils.random(length, chars);
}
/**
* 生成随机字符串，只包含数字
* @param length 长度
* @return
* @author zmr
*/
public static String randomInt(int length)
{
return RandomStringUtils.random(length, nubers);
}
}
以下是对这段 Java 代码的逐块分析：
package com.ruoyi.common.utils;
import org.apache.commons.lang3.RandomStringUtils;
这部分代码声明了包名，并导入了org.apache.commons.lang3.RandomStringUtils类，这个类用于生成随机字符串。
public class RandomUtil {
这是一个名为RandomUtil的公共类的开始。
private static char[] chars = new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e',
'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
'V', 'W', 'X', 'Y', 'Z'};
定义了一个静态的字符数组chars，包含数字、小写字母和大写字母，用于生成包含数字和字母的随机字符串。
private static char[] nubers = new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
定义了一个静态的字符数组nubers，只包含数字，用于生成只包含数字的随机字符串。
/**
* 生成随机字符串，包含数字和字母
* @param length 长度
* @return
* @author zmr
*/
public static String randomStr(int length) {
return RandomStringUtils.random(length, chars);
}
这个静态方法randomStr接受一个整数参数length，表示要生成的随机字符串的长度。它使用RandomStringUtils.random(length, chars)方法生成随机字符串，其中length是指定的长度，chars是包含数字和字母的字符数组。最后返回生成的随机字符串。
/**
* 生成随机字符串，只包含数字
* @param length 长度
* @return
* @author zmr
*/
public static String randomInt(int length) {
return RandomStringUtils.random(length, nubers);
}
}
这个静态方法randomInt与randomStr方法类似，接受一个整数参数length表示随机字符串的长度。它使用RandomStringUtils.random(length, nubers)方法生成只包含数字的随机字符串，其中length是指定的长度，nubers是只包含数字的字符数组。最后返回生成的只包含数字的随机字符串。
以下是对这段 Java 代码的分析：
一、功能概述
这个类RandomUtil提供了生成随机字符串的方法。可以生成指定长度的包含数字和字母的随机字符串，也可以生成只包含数字的随机字符串。
二、代码详解
-
定义字符数组：
chars：包含数字、小写字母和大写字母的字符数组，用于生成包含数字和字母的随机字符串。nubers：只包含数字的字符数组，用于生成只包含数字的随机字符串。
-
生成随机字符串的方法：
-
randomStr(int length)：- 接受一个整数参数
length，表示要生成的随机字符串的长度。 - 使用
RandomStringUtils.random(length, chars)方法生成随机字符串，其中length是指定的长度，chars是包含数字和字母的字符数组。 - 返回生成的随机字符串。
- 接受一个整数参数
-
randomInt(int length)：- 与
randomStr方法类似，接受一个整数参数length表示随机字符串的长度。 - 使用
RandomStringUtils.random(length, nubers)方法生成只包含数字的随机字符串，其中length是指定的长度，nubers是只包含数字的字符数组。 - 返回生成的只包含数字的随机字符串。
- 与
-
三、使用场景和注意事项
-
使用场景：
- 在需要生成随机字符串的场景中，比如生成验证码、临时的标识符等，可以使用这个工具类来快速生成所需的随机字符串。
-
注意事项：
- 确保传入的长度参数是合理的正整数，否则可能会导致生成的随机字符串不符合预期。
- 如果需要更复杂的随机字符串生成逻辑，可以根据实际需求对这个工具类进行扩展或修改
com/ruoyi/common/utils/ServletUtils.java
package com.ruoyi.common.utils;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.ruoyi.common.core.text.Convert;
/**
* 客户端工具类
*
* @author ruoyi
*/
public class ServletUtils
{
/**
* 获取String参数
*/
public static String getParameter(String name)
{
return getRequest().getParameter(name);
}
/**
* 获取String参数
*/
public static String getParameter(String name, String defaultValue)
{
return Convert.toStr(getRequest().getParameter(name), defaultValue);
}
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name)
{
return Convert.toInt(getRequest().getParameter(name));
}
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name, Integer defaultValue)
{
return Convert.toInt(getRequest().getParameter(name), defaultValue);
}
/**
* 获取request
*/
public static HttpServletRequest getRequest()
{
return getRequestAttributes().getRequest();
}
/**
* 获取response
*/
public static HttpServletResponse getResponse()
{
return getRequestAttributes().getResponse();
}
/**
* 获取session
*/
public static HttpSession getSession()
{
return getRequest().getSession();
}
public static ServletRequestAttributes getRequestAttributes()
{
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes;
}
/**
* 将字符串渲染到客户端
*
* @param response 渲染对象
* @param string 待渲染的字符串
* @return null
*/
public static String renderString(HttpServletResponse response, String string)
{
try
{
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
response.getWriter().print(string);
}
catch (IOException e)
{
e.printStackTrace();
}
return null;
}
/**
* 是否是Ajax异步请求
*
* @param request
*/
public static boolean isAjaxRequest(HttpServletRequest request)
{
String accept = request.getHeader("accept");
if (accept != null && accept.indexOf("application/json") != -1)
{
return true;
}
String xRequestedWith = request.getHeader("X-Requested-With");
if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1)
{
return true;
}
String uri = request.getRequestURI();
if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
{
return true;
}
String ajax = request.getParameter("__ajax");
if (StringUtils.inStringIgnoreCase(ajax, "json", "xml"))
{
return true;
}
return false;
}
}
以下是对这段 Java 代码的逐块分析：
package com.ruoyi.common.utils;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.ruoyi.common.core.text.Convert;
这部分代码声明了包名，并导入了必要的类。其中包括用于处理 I/O 异常的IOException，用于处理 HTTP 请求和响应的HttpServletRequest、HttpServletResponse和HttpSession，用于获取请求上下文属性的RequestAttributes、RequestContextHolder和ServletRequestAttributes，以及可能是自定义的用于数据类型转换的Convert类。
/**
* 客户端工具类
*
* @author ruoyi
*/
public class ServletUtils {
这是一个名为ServletUtils的公共类的开始，带有一个 JavaDoc 注释，表明这个类是一个客户端工具类，作者是 “ruoyi”。
/**
* 获取String参数
*/
public static String getParameter(String name) {
return getRequest().getParameter(name);
}
这个静态方法getParameter接受一个参数name，表示请求参数的名称。通过调用getRequest().getParameter(name)获取指定名称的请求参数值，并返回该值。
/**
* 获取String参数
*/
public static String getParameter(String name, String defaultValue) {
return Convert.toStr(getRequest().getParameter(name), defaultValue);
}
这个静态方法getParameter与上一个方法类似，但是多了一个默认值参数defaultValue。使用Convert.toStr(getRequest().getParameter(name), defaultValue)将获取到的请求参数转换为字符串类型，并在参数值为null时返回默认值。
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name) {
return Convert.toInt(getRequest().getParameter(name));
}
这个静态方法getParameterToInt接受一个参数name，表示请求参数的名称。使用Convert.toInt(getRequest().getParameter(name))将获取到的请求参数转换为整数类型，如果转换失败则返回null。
/**
* 获取Integer参数
*/
public static Integer getParameterToInt(String name, Integer defaultValue) {
return Convert.toInt(getRequest().getParameter(name), defaultValue);
}
这个静态方法getParameterToInt与上一个方法类似，但是多了一个默认值参数defaultValue。使用Convert.toInt(getRequest().getParameter(name), defaultValue)将获取到的请求参数转换为整数类型，并在参数值为null或转换失败时返回默认值。
/**
* 获取request
*/
public static HttpServletRequest getRequest() {
return getRequestAttributes().getRequest();
}
这个静态方法getRequest通过调用getRequestAttributes().getRequest()获取当前的HttpServletRequest对象。
/**
* 获取response
*/
public static HttpServletResponse getResponse() {
return getRequestAttributes().getResponse();
}
这个静态方法getResponse通过调用getRequestAttributes().getResponse()获取当前的HttpServletResponse对象。
/**
* 获取session
*/
public static HttpSession getSession() {
return getRequest().getSession();
}
这个静态方法getSession通过调用getRequest().getSession()获取当前的HttpSession对象。
public static ServletRequestAttributes getRequestAttributes() {
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes;
}
这个静态方法getRequestAttributes使用RequestContextHolder.getRequestAttributes()获取当前请求的属性，然后将其强制转换为ServletRequestAttributes类型并返回。
/**
* 将字符串渲染到客户端
*
* @param response 渲染对象
* @param string 待渲染的字符串
* @return null
*/
public static String renderString(HttpServletResponse response, String string) {
try {
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
response.getWriter().print(string);
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
这个静态方法renderString接受一个HttpServletResponse对象和一个要渲染的字符串string。它设置响应的内容类型为application/json，字符编码为utf-8，然后使用response.getWriter().print(string)将字符串写入响应输出流中。如果出现 I/O 异常，则打印堆栈跟踪信息，并返回null。
/**
* 是否是Ajax异步请求
*
* @param request
*/
public static boolean isAjaxRequest(HttpServletRequest request) {
String accept = request.getHeader("accept");
if (accept!= null && accept.indexOf("application/json")!= -1) {
return true;
}
String xRequestedWith = request.getHeader("X-Requested-With");
if (xRequestedWith!= null && xRequestedWith.indexOf("XMLHttpRequest")!= -1) {
return true;
}
String uri = request.getRequestURI();
if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
return true;
}
String ajax = request.getParameter("__ajax");
if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
return true;
}
return false;
}
}
这个静态方法isAjaxRequest接受一个HttpServletRequest对象，用于判断当前请求是否为 Ajax 请求。它检查请求头中的accept字段是否包含application/json、请求头中的X-Requested-With字段是否包含XMLHttpRequest、请求的 URI 是否包含.json或.xml后缀，以及请求参数中是否有__ajax参数且值为json或xml。如果满足其中任何一个条件，则返回true，表示是 Ajax 请求；否则返回false。
以下是对这段 Java 代码的分析：
一、功能概述
这个类ServletUtils提供了一系列与 Servlet 相关的实用方法，包括获取请求参数、获取HttpServletRequest、HttpServletResponse和HttpSession对象、渲染字符串到客户端以及判断是否为 Ajax 请求等功能。
二、代码详解
-
导入依赖：
import java.io.IOException;：用于处理在渲染字符串到客户端时可能出现的 I/O 异常。import javax.servlet.http.HttpServletRequest;：用于获取 HTTP 请求对象。import javax.servlet.http.HttpServletResponse;：用于向客户端发送响应。import javax.servlet.http.HttpSession;：用于获取和管理用户会话。import org.springframework.web.context.request.RequestAttributes;：Spring 框架中用于获取请求上下文属性的接口。import org.springframework.web.context.request.RequestContextHolder;：Spring 框架中用于获取当前请求上下文的工具类。import org.springframework.web.context.request.ServletRequestAttributes;：Spring 框架中用于获取 Servlet 请求属性的类。import com.ruoyi.common.core.text.Convert;：可能是自定义的用于数据类型转换的工具类。
-
方法分析：
-
getParameter(String name)：- 这个方法接受一个参数
name，表示请求参数的名称。 - 通过
getRequest().getParameter(name)获取指定名称的请求参数值，并返回该值。
- 这个方法接受一个参数
-
getParameter(String name, String defaultValue)：- 与上一个方法类似，但是多了一个默认值参数
defaultValue。 - 使用
Convert.toStr(getRequest().getParameter(name), defaultValue)将获取到的请求参数转换为字符串类型，并在参数值为null时返回默认值。
- 与上一个方法类似，但是多了一个默认值参数
-
getParameterToInt(String name)：- 接受一个参数
name，表示请求参数的名称。 - 使用
Convert.toInt(getRequest().getParameter(name))将获取到的请求参数转换为整数类型，如果转换失败则返回null。
- 接受一个参数
-
getParameterToInt(String name, Integer defaultValue)：- 与上一个方法类似，但是多了一个默认值参数
defaultValue。 - 使用
Convert.toInt(getRequest().getParameter(name), defaultValue)将获取到的请求参数转换为整数类型，并在参数值为null或转换失败时返回默认值。
- 与上一个方法类似，但是多了一个默认值参数
-
getRequest()：- 通过
getRequestAttributes().getRequest()获取当前的HttpServletRequest对象。
- 通过
-
getResponse()：- 通过
getRequestAttributes().getResponse()获取当前的HttpServletResponse对象。
- 通过
-
getSession()：- 通过
getRequest().getSession()获取当前的HttpSession对象。
- 通过
-
getRequestAttributes()：- 使用
RequestContextHolder.getRequestAttributes()获取当前请求的属性，然后将其强制转换为ServletRequestAttributes类型并返回。
- 使用
-
renderString(HttpServletResponse response, String string)：- 这个方法接受一个
HttpServletResponse对象和一个要渲染的字符串string。 - 设置响应的内容类型为
application/json，字符编码为utf-8，然后使用response.getWriter().print(string)将字符串写入响应输出流中。如果出现 I/O 异常，则打印堆栈跟踪信息。
- 这个方法接受一个
-
isAjaxRequest(HttpServletRequest request)：- 这个方法接受一个
HttpServletRequest对象，用于判断当前请求是否为 Ajax 请求。 - 检查请求头中的
accept字段是否包含application/json、请求头中的X-Requested-With字段是否包含XMLHttpRequest、请求的 URI 是否包含.json或.xml后缀，以及请求参数中是否有__ajax参数且值为json或xml。如果满足其中任何一个条件，则返回true，表示是 Ajax 请求；否则返回false。
- 这个方法接受一个
-
三、使用场景和注意事项
-
使用场景：
- 在 Web 应用程序中，可以使用这些方法方便地获取请求参数、处理请求和响应、判断请求类型等。例如，在控制器方法中可以使用
getParameter方法获取请求参数，使用renderString方法将数据以 JSON 格式返回给客户端，使用isAjaxRequest方法判断请求是否为 Ajax 请求以便进行不同的处理。
- 在 Web 应用程序中，可以使用这些方法方便地获取请求参数、处理请求和响应、判断请求类型等。例如，在控制器方法中可以使用
-
注意事项：
- 在使用
renderString方法时，需要注意处理可能出现的 I/O 异常。 - 在判断 Ajax 请求时，需要考虑不同的判断条件可能存在的局限性，以及可能需要根据实际情况进行调整。
- 在获取请求参数时，需要注意参数值可能为
null的情况，并进行适当的处理
- 在使用
com/ruoyi/common/utils/StringUtils.java
package com.ruoyi.common.utils;
import java.util.Collection;
import java.util.Map;
import com.ruoyi.common.core.text.StrFormatter;
/**
* 字符串工具类
*
* @author ruoyi
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
/** 空字符串 */
private static final String NULLSTR = "";
/** 下划线 */
private static final char SEPARATOR = '_';
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue)
{
return value != null ? value : defaultValue;
}
/**
* * 判断一个Collection是否为空， 包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：为空 false：非空
*/
public static boolean isEmpty(Collection<?> coll)
{
return isNull(coll) || coll.isEmpty();
}
/**
* * 判断一个Collection是否非空，包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Collection<?> coll)
{
return !isEmpty(coll);
}
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
** @return true：为空 false：非空
*/
public static boolean isEmpty(Object[] objects)
{
return isNull(objects) || (objects.length == 0);
}
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object[] objects)
{
return !isEmpty(objects);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：为空 false：非空
*/
public static boolean isEmpty(Map<?, ?> map)
{
return isNull(map) || map.isEmpty();
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Map<?, ?> map)
{
return !isEmpty(map);
}
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true：为空 false：非空
*/
public static boolean isEmpty(String str)
{
return isNull(str) || NULLSTR.equals(str.trim());
}
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true：非空串 false：空串
*/
public static boolean isNotEmpty(String str)
{
return !isEmpty(str);
}
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true：为空 false：非空
*/
public static boolean isNull(Object object)
{
return object == null;
}
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true：非空 false：空
*/
public static boolean isNotNull(Object object)
{
return !isNull(object);
}
/**
* * 判断一个对象是否是数组类型（Java基本型别的数组）
*
* @param object 对象
* @return true：是数组 false：不是数组
*/
public static boolean isArray(Object object)
{
return isNotNull(object) && object.getClass().isArray();
}
/**
* 去空格
*/
public static String trim(String str)
{
return (str == null ? "" : str.trim());
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start)
{
if (str == null)
{
return NULLSTR;
}
if (start < 0)
{
start = str.length() + start;
}
if (start < 0)
{
start = 0;
}
if (start > str.length())
{
return NULLSTR;
}
return str.substring(start);
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end)
{
if (str == null)
{
return NULLSTR;
}
if (end < 0)
{
end = str.length() + end;
}
if (start < 0)
{
start = str.length() + start;
}
if (end > str.length())
{
end = str.length();
}
if (start > end)
{
return NULLSTR;
}
if (start < 0)
{
start = 0;
}
if (end < 0)
{
end = 0;
}
return str.substring(start, end);
}
/**
* 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值
* @return 格式化后的文本
*/
public static String format(String template, Object... params)
{
if (isEmpty(params) || isEmpty(template))
{
return template;
}
return StrFormatter.format(template, params);
}
/**
* 下划线转驼峰命名
*/
public static String toUnderScoreCase(String str)
{
if (str == null)
{
return null;
}
StringBuilder sb = new StringBuilder();
// 前置字符是否大写
boolean preCharIsUpperCase = true;
// 当前字符是否大写
boolean curreCharIsUpperCase = true;
// 下一字符是否大写
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
if (i > 0)
{
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
}
else
{
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1))
{
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{
sb.append(SEPARATOR);
}
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs)
{
if (str != null && strs != null)
{
for (String s : strs)
{
if (str.equalsIgnoreCase(trim(s)))
{
return true;
}
}
}
return false;
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name)
{
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty())
{
// 没必要转换
return "";
}
else if (!name.contains("_"))
{
// 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
// 用下划线将原始字符串分割
String[] camels = name.split("_");
for (String camel : camels)
{
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty())
{
continue;
}
// 首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
/**
* 驼峰式命名法 例如：user_name->userName
*/
public static String toCamelCase(String s)
{
if (s == null)
{
return null;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == SEPARATOR)
{
upperCase = true;
}
else if (upperCase)
{
sb.append(Character.toUpperCase(c));
upperCase = false;
}
else
{
sb.append(c);
}
}
return sb.toString();
}
}以下是对这段 Java 代码的逐块分析：
package com.ruoyi.common.utils;
import java.util.Collection;
import java.util.Map;
import com.ruoyi.common.core.text.StrFormatter;
这部分代码声明了包名，并导入了必要的类。其中Collection用于处理集合类型的判断，Map用于处理Map类型的判断，StrFormatter可能是自定义的用于格式化字符串的工具类。
/**
* 字符串工具类
*
* @author ruoyi
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils {
这是一个名为StringUtils的公共类的开始，带有一个 JavaDoc 注释，表明这个类是一个字符串工具类，作者是 “ruoyi”。这个类继承自org.apache.commons.lang3.StringUtils类，以获得更多的字符串处理功能。
/** 空字符串 */
private static final String NULLSTR = "";
/** 下划线 */
private static final char SEPARATOR = '_';
定义了两个私有静态常量，一个是空字符串NULLSTR，另一个是下划线字符SEPARATOR，可能用于字符串处理中的分隔符。
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue) {
return value!= null? value : defaultValue;
}
这个静态方法nvl接受两个参数，一个是要判断的对象value，另一个是默认值defaultValue。如果value不为null，则返回value，否则返回defaultValue。
/**
* * 判断一个Collection是否为空， 包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：为空 false：非空
*/
public static boolean isEmpty(Collection<?> coll) {
return isNull(coll) || coll.isEmpty();
}
这个静态方法isEmpty用于判断一个Collection是否为空。如果Collection为null或者没有元素，则返回true，否则返回false。
/**
* * 判断一个Collection是否非空，包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Collection<?> coll) {
return!isEmpty(coll);
}
这个静态方法isNotEmpty与isEmpty方法相反，用于判断一个Collection是否非空。
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
** @return true：为空 false：非空
*/
public static boolean isEmpty(Object[] objects) {
return isNull(objects) || (objects.length == 0);
}
这个静态方法isEmpty用于判断一个对象数组是否为空。如果数组为null或者长度为 0，则返回true，否则返回false。
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object[] objects) {
return!isEmpty(objects);
}
这个静态方法isNotEmpty用于判断一个对象数组是否非空。
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：为空 false：非空
*/
public static boolean isEmpty(Map<?,?> map) {
return isNull(map) || map.isEmpty();
}
这个静态方法isEmpty用于判断一个Map是否为空。如果Map为null或者没有键值对，则返回true，否则返回false。
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Map<?,?> map) {
return!isEmpty(map);
}
这个静态方法isNotEmpty用于判断一个Map是否非空。
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true：为空 false：非空
*/
public static boolean isEmpty(String str) {
return isNull(str) || NULLSTR.equals(str.trim());
}
这个静态方法isEmpty用于判断一个字符串是否为空串。如果字符串为null或者去除两端空格后为空字符串，则返回true，否则返回false。
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true：非空串 false：空串
*/
public static boolean isNotEmpty(String str) {
return!isEmpty(str);
}
这个静态方法isNotEmpty用于判断一个字符串是否为非空串。
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true：为空 false：非空
*/
public static boolean isNull(Object object) {
return object == null;
}
这个静态方法isNull用于判断一个对象是否为null
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true：非空 false：空
*/
public static boolean isNotNull(Object object) {
return!isNull(object);
}
这个静态方法isNotNull用于判断一个对象是否非空。
/**
* * 判断一个对象是否是数组类型（Java基本型别的数组）
*
* @param object 对象
* @return true：是数组 false：不是数组
*/
public static boolean isArray(Object object) {
return isNotNull(object) && object.getClass().isArray();
}
这个静态方法isArray用于判断一个对象是否是数组类型。
/**
* 去空格
*/
public static String trim(String str) {
return (str == null? "" : str.trim());
}
这个静态方法trim用于去除字符串两端的空格。如果字符串为null，则返回空字符串。
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start) {
if (str == null) {
return NULLSTR;
}
if (start < 0) {
start = str.length() + start;
}
if (start < 0) {
start = 0;
}
if (start > str.length()) {
return NULLSTR;
}
return str.substring(start);
}
这个静态方法substring用于截取字符串，从指定的起始位置开始。如果输入的字符串为null，则返回空字符串。如果起始位置为负数，则从字符串末尾开始计算起始位置。如果起始位置超出字符串长度，则返回空字符串。
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end) {
if (str == null) {
return NULLSTR;
}
if (end < 0) {
end = str.length() + end;
}
if (start < 0) {
start = str.length() + start;
}
if (end > str.length()) {
end = str.length();
}
if (start > end) {
return NULLSTR;
}
if (start < 0) {
start = 0;
}
if (end < 0) {
end = 0;
}
return str.substring(start, end);
}
这个静态方法substring用于截取字符串，从指定的起始位置开始，到指定的结束位置结束。如果输入的字符串为null，则返回空字符串。如果起始位置或结束位置为负数，则从字符串末尾开始计算起始位置或结束位置。如果起始位置超出字符串长度或起始位置大于结束位置，则返回空字符串。
/**
* 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值
* @return 格式化后的文本
*/
public static String format(String template, Object... params) {
if (isEmpty(params) || isEmpty(template)) {
return template;
}
return StrFormatter.format(template, params);
}
这个静态方法format用于格式化文本，将模板中的占位符{}按照顺序替换为参数值。如果模板或参数为空，则直接返回模板。调用了StrFormatter.format(template, params)进行实际的格式化操作。
/**
* 下划线转驼峰命名
*/
public static String toUnderScoreCase(String str) {
if (str == null) {
return null;
}
StringBuilder sb = new StringBuilder();
// 前置字符是否大写
boolean preCharIsUpperCase = true;
// 当前字符是否大写
boolean curreCharIsUpperCase = true;
// 下一字符是否大写
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (i > 0) {
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
} else {
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1)) {
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase &&!nexteCharIsUpperCase) {
sb.append(SEPARATOR);
} else if ((i!= 0 &&!preCharIsUpperCase) && curreCharIsUpperCase) {
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
这个静态方法toUnderScoreCase用于将输入的字符串从驼峰命名转换为下划线命名。遍历字符串中的每个字符，根据前后字符的大小写情况判断是否需要添加下划线，并将字符转换为小写。
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs) {
if (str!= null && strs!= null) {
for (String s : strs) {
if (str.equalsIgnoreCase(trim(s))) {
return true;
}
}
}
return false;
}
这个静态方法inStringIgnoreCase用于判断一个字符串是否在给定的字符串数组中（不区分大小写）。遍历字符串数组，如果找到与输入字符串相等（不区分大小写）的字符串，则返回true，否则返回false。
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name) {
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty()) {
// 没必要转换
return "";
} else if (!name.contains("_")) {
// 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
// 用下划线将原始字符串分割
String[] camels = name.split("_");
for (String camel : camels) {
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) {
continue;
}
// 首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
这个静态方法convertToCamelCase用于将下划线大写方式命名的字符串转换为驼峰式命名。如果输入字符串为null或为空，或者不包含下划线，则进行特殊处理。否则，将字符串用下划线分割，然后对每个部分进行处理，将首字母大写，并将结果拼接起来。
/**
* 驼峰式命名法 例如：user_name->userName
*/
public static String toCamelCase(String s) {
if (s == null) {
return null;
}
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == SEPARATOR) {
upperCase = true;
} else if (upperCase) {
sb.append(Character.toUpperCase(c));
upperCase = false;
} else {
sb.append(c);
}
}
return sb.toString();
}
}
这个静态方法toCamelCase用于将输入的字符串从下划线命名转换为驼峰命名。遍历字符串，遇到下划线时将下一个字符转换为大写，其他字符保持不变，并拼接成最终的驼峰命名字符串。
以下是对这段 Java 代码的分析：
一、功能概述
这个类StringUtils是一个字符串工具类，扩展了org.apache.commons.lang3.StringUtils类，提供了一系列用于处理字符串和判断对象是否为空等功能的方法。
二、代码详解
-
定义常量和导入依赖：
private static final String NULLSTR = "";：定义了一个空字符串常量。private static final char SEPARATOR = '_';：定义了一个下划线字符常量，可能用于字符串处理中的分隔符。import java.util.Collection;：用于处理集合类型的判断。import java.util.Map;：用于处理Map类型的判断。import com.ruoyi.common.core.text.StrFormatter;：可能是自定义的用于格式化字符串的工具类。
-
方法分析：
-
nvl(T value, T defaultValue)：- 这个方法接受两个参数，一个是要判断的对象
value，另一个是默认值defaultValue。如果value不为null，则返回value，否则返回defaultValue。
- 这个方法接受两个参数，一个是要判断的对象
-
判断集合、数组、
Map和字符串是否为空的方法：isEmpty(Collection<?>)、isNotEmpty(Collection<?>)：用于判断一个Collection是否为空或非空。isEmpty(Object[])、isNotEmpty(Object[])：用于判断一个对象数组是否为空或非空。isEmpty(Map<?,?>)、isNotEmpty(Map<?,?>)：用于判断一个Map是否为空或非空。isEmpty(String)、isNotEmpty(String)：用于判断一个字符串是否为空或非空。isNull(Object)、isNotNull(Object)：用于判断一个对象是否为null或非null。isArray(Object)：用于判断一个对象是否是数组类型。
-
trim(String str)：- 接受一个字符串参数，去除字符串两端的空格，如果字符串为
null，则返回空字符串。
- 接受一个字符串参数，去除字符串两端的空格，如果字符串为
-
substring(final String str, int start)和substring(final String str, int start, int end)：- 用于截取字符串。如果输入的字符串为
null，则返回空字符串。在处理起始和结束位置时，考虑了负数的情况，并进行了适当的调整。
- 用于截取字符串。如果输入的字符串为
-
format(String template, Object... params)：- 用于格式化文本，将模板中的占位符
{}按照顺序替换为参数值。如果模板或参数为空，则直接返回模板。调用了StrFormatter.format(template, params)进行实际的格式化操作。
- 用于格式化文本，将模板中的占位符
-
toUnderScoreCase(String str)：- 将输入的字符串从驼峰命名转换为下划线命名。遍历字符串中的每个字符，根据前后字符的大小写情况判断是否需要添加下划线，并将字符转换为小写。
-
inStringIgnoreCase(String str, String... strs)：- 判断一个字符串是否在给定的字符串数组中（不区分大小写）。遍历字符串数组，如果找到与输入字符串相等（不区分大小写）的字符串，则返回
true，否则返回false。
- 判断一个字符串是否在给定的字符串数组中（不区分大小写）。遍历字符串数组，如果找到与输入字符串相等（不区分大小写）的字符串，则返回
-
convertToCamelCase(String name)：- 将下划线大写方式命名的字符串转换为驼峰式命名。如果输入字符串为
null或为空，或者不包含下划线，则进行特殊处理。否则，将字符串用下划线分割，然后对每个部分进行处理，将首字母大写，并将结果拼接起来。
- 将下划线大写方式命名的字符串转换为驼峰式命名。如果输入字符串为
-
toCamelCase(String s)：- 将输入的字符串从下划线命名转换为驼峰命名。遍历字符串，遇到下划线时将下一个字符转换为大写，其他字符保持不变，并拼接成最终的驼峰命名字符串。
-
三、使用场景和注意事项
-
使用场景：
- 在 Java 应用程序中，这些方法可以用于处理字符串、判断对象是否为空、进行字符串的格式化和命名转换等操作。例如，在数据处理、字符串拼接、参数验证等场景中，可以使用这些方法来简化代码和提高开发效率。
-
注意事项：
- 在使用字符串截取方法时，要注意处理输入字符串为
null的情况，以及起始和结束位置的合法性。 - 在进行命名转换方法时，要注意输入字符串的格式是否符合预期，以及可能出现的边界情况。
- 在判断对象是否为空的方法中，要根据实际需求选择合适的方法，并注意处理可能出现的
null值情况。
- 在使用字符串截取方法时，要注意处理输入字符串为
扫一扫
6174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
