JAVA Web项目中常用工具类集合

ゝ一纸荒年。 2024-04-22 19:30 81阅读 0赞

## WebUtil 网络服务工具类 ##

完整代码如下：

import org.apache.commons.codec.Charsets;
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.lang.Nullable;
    import org.springframework.util.Assert;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    import org.springframework.web.method.HandlerMethod;
    import org.springframework.web.util.WebUtils;
    
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.nio.charset.StandardCharsets;
    import java.util.Enumeration;
    import java.util.Objects;
    import java.util.function.Predicate;
    
    public class WebUtil extends WebUtils {
        private static final Logger log = LoggerFactory.getLogger(WebUtil.class);
        public static final String USER_AGENT_HEADER = "user-agent";
        private static final String[] IP_HEADER_NAMES = new String[]{"x-forwarded-for", "Proxy-Client-IP", "WL-Proxy-Client-IP", "HTTP_CLIENT_IP", "HTTP_X_FORWARDED_FOR"};
        private static final Predicate<String> IP_PREDICATE = (ip) -> {
            return StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip);
        };
    
        public WebUtil() {
        }
    
        public static boolean isBody(HandlerMethod handlerMethod) {
            ResponseBody responseBody = (ResponseBody) ClassUtil.getAnnotation(handlerMethod, ResponseBody.class);
            return responseBody != null;
        }
    
        @Nullable
        public static String getCookieVal(String name) {
            HttpServletRequest request = getRequest();
            Assert.notNull(request, "request from RequestContextHolder is null");
            return getCookieVal(request, name);
        }
    
        @Nullable
        public static String getCookieVal(HttpServletRequest request, String name) {
            Cookie cookie = getCookie(request, name);
            return cookie != null ? cookie.getValue() : null;
        }
    
        public static void removeCookie(HttpServletResponse response, String key) {
            setCookie(response, key, (String)null, 0);
        }
    
        public static void setCookie(HttpServletResponse response, String name, @Nullable String value, int maxAgeInSeconds) {
            Cookie cookie = new Cookie(name, value);
            cookie.setPath("/");
            cookie.setMaxAge(maxAgeInSeconds);
            cookie.setHttpOnly(true);
            response.addCookie(cookie);
        }
    
        public static HttpServletRequest getRequest() {
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            return requestAttributes == null ? null : ((ServletRequestAttributes)requestAttributes).getRequest();
        }
    
        public static void renderJson(HttpServletResponse response, Object result) {
            renderJson(response, result, "application/json;charset=UTF-8");
        }
    
        public static void renderJson(HttpServletResponse response, Object result, String contentType) {
            response.setCharacterEncoding("UTF-8");
            response.setContentType(contentType);
    
            try {
                PrintWriter out = response.getWriter();
                Throwable var4 = null;
    
                try {
                    out.append(JsonUtil.toJson(result));
                } catch (Throwable var14) {
                    var4 = var14;
                    throw var14;
                } finally {
                    if (out != null) {
                        if (var4 != null) {
                            try {
                                out.close();
                            } catch (Throwable var13) {
                                var4.addSuppressed(var13);
                            }
                        } else {
                            out.close();
                        }
                    }
    
                }
            } catch (IOException var16) {
                log.error(var16.getMessage(), var16);
            }
    
        }
    
        public static String getIP() {
            return getIP(getRequest());
        }
    
        @Nullable
        public static String getIP(@Nullable HttpServletRequest request) {
            if (request == null) {
                return "";
            } else {
                String ip = null;
                String[] var2 = IP_HEADER_NAMES;
                int var3 = var2.length;
    
                for(int var4 = 0; var4 < var3; ++var4) {
                    String ipHeader = var2[var4];
                    ip = request.getHeader(ipHeader);
                    if (!IP_PREDICATE.test(ip)) {
                        break;
                    }
                }
    
                if (IP_PREDICATE.test(ip)) {
                    ip = request.getRemoteAddr();
                }
    
                return StringUtils.isBlank(ip) ? null :splitTrim(ip, ",")[0];
            }
        }
        public static String[] splitTrim(String splitStr,String regex) {
            return splitStr.trim().split(regex);
        }
    
    
        public static String getHeader(String name) {
            HttpServletRequest request = getRequest();
            return ((HttpServletRequest)Objects.requireNonNull(request)).getHeader(name);
        }
    
        public static Enumeration<String> getHeaders(String name) {
            HttpServletRequest request = getRequest();
            return ((HttpServletRequest)Objects.requireNonNull(request)).getHeaders(name);
        }
    
        public static Enumeration<String> getHeaderNames() {
            HttpServletRequest request = getRequest();
            return ((HttpServletRequest)Objects.requireNonNull(request)).getHeaderNames();
        }
    
        public static String getParameter(String name) {
            HttpServletRequest request = getRequest();
            return ((HttpServletRequest)Objects.requireNonNull(request)).getParameter(name);
        }
    
        public static String getRequestBody(ServletInputStream servletInputStream) {
            StringBuilder sb = new StringBuilder();
            BufferedReader reader = null;
    
            try {
                reader = new BufferedReader(new InputStreamReader(servletInputStream, StandardCharsets.UTF_8));
    
                String line;
                while((line = reader.readLine()) != null) {
                    sb.append(line);
                }
            } catch (IOException var16) {
                var16.printStackTrace();
            } finally {
                if (servletInputStream != null) {
                    try {
                        servletInputStream.close();
                    } catch (IOException var15) {
                        var15.printStackTrace();
                    }
                }
    
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException var14) {
                        var14.printStackTrace();
                    }
                }
    
            }
    
            return sb.toString();
        }
    
        public static String getRequestContent(HttpServletRequest request) {
            try {
                String queryString = request.getQueryString();
                if (StringUtils.isNotBlank(queryString)) {
                    return (new String(queryString.getBytes(Charsets.ISO_8859_1), Charsets.UTF_8)).replaceAll("&", "&").replaceAll("%22", "\"");
                } else {
                    String charEncoding = request.getCharacterEncoding();
                    if (charEncoding == null) {
                        charEncoding = "UTF-8";
                    }
    
                    byte[] buffer = getRequestBody(request.getInputStream()).getBytes();
                    String str = (new String(buffer, charEncoding)).trim();
                    if (org.apache.commons.lang3.StringUtils.isBlank(str)) {
                        StringBuilder sb = new StringBuilder();
                        Enumeration parameterNames = request.getParameterNames();
    
                        while(parameterNames.hasMoreElements()) {
                            String key = (String)parameterNames.nextElement();
                            String value = request.getParameter(key);
                            StringUtil.appendBuilder(sb, new CharSequence[]{key, "=", value, "&"});
                        }
    
                        str = StringUtil.removeSuffix(sb.toString(), "&");
                    }
    
                    return str.replaceAll("&", "&");
                }
            } catch (Exception var9) {
                var9.printStackTrace();
                return "";
            }
        }
    
    
    }

## FileUtil 文件操作工具类 ##

完整代码如下：

import com.tarzan.cms.common.exception.ForbiddenException;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.lang.NonNull;
    import org.springframework.util.Assert;
     
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.nio.file.*;
    import java.nio.file.attribute.BasicFileAttributes;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    import java.util.zip.ZipEntry;
    import java.util.zip.ZipInputStream;
    import java.util.zip.ZipOutputStream;
     
    @Slf4j
    public class FileUtil {
     
        /**
         * Copies folder.
         *
         * @param source source path must not be null
         * @param target target path must not be null
         */
        public static void copyFolder(@NonNull Path source, @NonNull Path target) throws IOException {
            Assert.notNull(source, "Source path must not be null");
            Assert.notNull(target, "Target path must not be null");
     
            Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
     
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                        throws IOException {
                    Path current = target.resolve(source.relativize(dir).toString());
                    Files.createDirectories(current);
                    return FileVisitResult.CONTINUE;
                }
     
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                        throws IOException {
                    Files.copy(file, target.resolve(source.relativize(file).toString()),
                            StandardCopyOption.REPLACE_EXISTING);
                    return FileVisitResult.CONTINUE;
                }
            });
        }
     
        /**
         * Deletes folder recursively.
         *
         * @param deletingPath deleting path must not be null
         */
        public static void deleteFolder(@NonNull Path deletingPath) throws IOException {
            Assert.notNull(deletingPath, "Deleting path must not be null");
     
            if (Files.notExists(deletingPath)) {
                return;
            }
            log.info("Deleting [{}]", deletingPath);
            delete(deletingPath.toFile());
            log.info("Deleted [{}] successfully", deletingPath);
        }
     
        public static void delete(File file) {
            if(file.isDirectory()){
                Arrays.asList(file.listFiles()).forEach(e->{
                    delete(e);
                });
            }
            file.delete();
        }
     
        /**
         * Renames file or folder.
         *
         * @param pathToRename file path to rename must not be null
         * @param newName new name must not be null
         */
        public static void rename(@NonNull Path pathToRename, @NonNull String newName)
                throws IOException {
            Assert.notNull(pathToRename, "File path to rename must not be null");
            Assert.notNull(newName, "New name must not be null");
     
            Path newPath = pathToRename.resolveSibling(newName);
            log.info("Rename [{}] to [{}]", pathToRename, newPath);
     
            Files.move(pathToRename, newPath);
     
            log.info("Rename [{}] successfully", pathToRename);
        }
     
     
     
        /**
         * Unzips content to the target path.
         *
         * @param zis zip input stream must not be null
         * @param targetPath target path must not be null and not empty
         * @throws IOException throws when failed to access file to be unzipped
         */
        public static void unzip(@NonNull ZipInputStream zis, @NonNull Path targetPath)
                throws IOException {
            // 1. unzip file to folder
            // 2. return the folder path
            Assert.notNull(zis, "Zip input stream must not be null");
            Assert.notNull(targetPath, "Target path must not be null");
     
            // Create path if absent
            createIfAbsent(targetPath);
     
            // Folder must be empty
            ensureEmpty(targetPath);
     
            ZipEntry zipEntry = zis.getNextEntry();
     
            while (zipEntry != null) {
                // Resolve the entry path
                Path entryPath = targetPath.resolve(zipEntry.getName());
     
                // Check directory
                checkDirectoryTraversal(targetPath, entryPath);
     
                if (zipEntry.isDirectory()) {
                    // Create directories
                    Files.createDirectories(entryPath);
                } else {
                    // Copy file
                    Files.copy(zis, entryPath);
                }
     
                zipEntry = zis.getNextEntry();
            }
        }
     
        /**
         * Unzips content to the target path.
         *
         * @param bytes zip bytes array must not be null
         * @param targetPath target path must not be null and not empty
         * @throws IOException io exception
         */
        public static void unzip(@NonNull byte[] bytes, @NonNull Path targetPath) throws IOException {
            Assert.notNull(bytes, "Zip bytes must not be null");
     
            ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(bytes));
            unzip(zis, targetPath);
        }
     
        /**
         * Zips folder or file.
         *
         * @param pathToZip file path to zip must not be null
         * @param pathOfArchive zip file path to archive must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        public static void zip(@NonNull Path pathToZip, @NonNull Path pathOfArchive)
                throws IOException {
            try (OutputStream outputStream = Files.newOutputStream(pathOfArchive)) {
                try (ZipOutputStream zipOut = new ZipOutputStream(outputStream)) {
                    zip(pathToZip, zipOut);
                }
            }
        }
     
        /**
         * Zips folder or file.
         *
         * @param pathToZip file path to zip must not be null
         * @param zipOut zip output stream must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        public static void zip(@NonNull Path pathToZip, @NonNull ZipOutputStream zipOut)
                throws IOException {
            // Zip file
            zip(pathToZip, pathToZip.getFileName().toString(), zipOut);
        }
     
        /**
         * Zips folder or file.
         *
         * @param fileToZip file path to zip must not be null
         * @param fileName file name must not be blank
         * @param zipOut zip output stream must not be null
         * @throws IOException throws when failed to access file to be zipped
         */
        private static void zip(@NonNull Path fileToZip, @NonNull String fileName,
                                @NonNull ZipOutputStream zipOut) throws IOException {
            if (Files.isDirectory(fileToZip)) {
                log.debug("Try to zip folder: [{}]", fileToZip);
                // Append with '/' if missing
                String folderName =
                        StringUtils.appendIfMissing(fileName, File.separator, File.separator);
                // Create zip entry and put into zip output stream
                zipOut.putNextEntry(new ZipEntry(folderName));
                // Close entry for writing the next entry
                zipOut.closeEntry();
     
                // Iterate the sub files recursively
                try (Stream<Path> subPathStream = Files.list(fileToZip)) {
                    // There should not use foreach for stream as internal zip method will throw
                    // IOException
                    List<Path> subFiles = subPathStream.collect(Collectors.toList());
                    for (Path subFileToZip : subFiles) {
                        // Zip children
                        zip(subFileToZip, folderName + subFileToZip.getFileName(), zipOut);
                    }
                }
            } else {
                // Open file to be zipped
                // Create zip entry for target file
                ZipEntry zipEntry = new ZipEntry(fileName);
                // Put the entry into zip output stream
                zipOut.putNextEntry(zipEntry);
                // Copy file to zip output stream
                Files.copy(fileToZip, zipOut);
                // Close entry
                zipOut.closeEntry();
            }
        }
     
        /**
         * Creates directories if absent.
         *
         * @param path path must not be null
         * @throws IOException io exception
         */
        public static void createIfAbsent(@NonNull Path path) throws IOException {
            Assert.notNull(path, "Path must not be null");
     
            if (Files.notExists(path)) {
                // Create directories
                Files.createDirectories(path);
     
                log.debug("Created directory: [{}]", path);
            }
        }
     
        /**
         * The given path must be empty.
         *
         * @param path path must not be null
         * @throws IOException io exception
         */
        public static void ensureEmpty(@NonNull Path path) throws IOException {
            if (!isEmpty(path)) {
                throw new DirectoryNotEmptyException("Target directory: " + path + " was not empty");
            }
        }
     
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull String parentPath,
                                                   @NonNull String pathToCheck) {
            checkDirectoryTraversal(Paths.get(parentPath), Paths.get(pathToCheck));
        }
     
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull Path parentPath,
                                                   @NonNull String pathToCheck) {
            checkDirectoryTraversal(parentPath, Paths.get(pathToCheck));
        }
     
        /**
         * Checks directory traversal vulnerability.
         *
         * @param parentPath parent path must not be null.
         * @param pathToCheck path to check must not be null
         */
        public static void checkDirectoryTraversal(@NonNull Path parentPath,
                                                   @NonNull Path pathToCheck) {
            Assert.notNull(parentPath, "Parent path must not be null");
            Assert.notNull(pathToCheck, "Path to check must not be null");
     
            if (pathToCheck.normalize().startsWith(parentPath)) {
                return;
            }
     
            throw new ForbiddenException("你没有权限访问 " + pathToCheck);
        }
     
        /**
         * Checks if the given path is empty.
         *
         * @param path path must not be null
         * @return true if the given path is empty; false otherwise
         * @throws IOException io exception
         */
        public static boolean isEmpty(@NonNull Path path) throws IOException {
            Assert.notNull(path, "Path must not be null");
     
            if (!Files.isDirectory(path) || Files.notExists(path)) {
                return true;
            }
     
            try (Stream<Path> pathStream = Files.list(path)) {
                return pathStream.count() == 0;
            }
        }
     
    }

## FileCopyUtils 文件复制工具类 ##

文件复制拷贝FileCopyUtils工具类，完整代码如下：

import org.springframework.lang.Nullable;
    import org.springframework.util.Assert;
    import org.springframework.util.StreamUtils;
     
    import java.io.*;
    import java.nio.file.Files;
     
    public abstract class FileCopyUtils {
        public static final int BUFFER_SIZE = 4096;
     
        public FileCopyUtils() {
        }
     
        public static int copy(File in, File out) throws IOException {
            Assert.notNull(in, "No input File specified");
            Assert.notNull(out, "No output File specified");
            return copy(Files.newInputStream(in.toPath()), Files.newOutputStream(out.toPath()));
        }
     
        public static void copy(byte[] in, File out) throws IOException {
            Assert.notNull(in, "No input byte array specified");
            Assert.notNull(out, "No output File specified");
            copy((InputStream)(new ByteArrayInputStream(in)), (OutputStream)Files.newOutputStream(out.toPath()));
        }
     
        public static byte[] copyToByteArray(File in) throws IOException {
            Assert.notNull(in, "No input File specified");
            return copyToByteArray(Files.newInputStream(in.toPath()));
        }
     
        public static int copy(InputStream in, OutputStream out) throws IOException {
            Assert.notNull(in, "No InputStream specified");
            Assert.notNull(out, "No OutputStream specified");
     
            int var2;
            try {
                var2 = StreamUtils.copy(in, out);
            } finally {
                try {
                    in.close();
                } catch (IOException var12) {
                }
     
                try {
                    out.close();
                } catch (IOException var11) {
                }
     
            }
     
            return var2;
        }
     
        public static void copy(byte[] in, OutputStream out) throws IOException {
            Assert.notNull(in, "No input byte array specified");
            Assert.notNull(out, "No OutputStream specified");
     
            try {
                out.write(in);
            } finally {
                try {
                    out.close();
                } catch (IOException var8) {
                }
     
            }
     
        }
     
        public static byte[] copyToByteArray(@Nullable InputStream in) throws IOException {
            if (in == null) {
                return new byte[0];
            } else {
                ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
                copy((InputStream)in, (OutputStream)out);
                return out.toByteArray();
            }
        }
     
        public static int copy(Reader in, Writer out) throws IOException {
            Assert.notNull(in, "No Reader specified");
            Assert.notNull(out, "No Writer specified");
     
            try {
                int byteCount = 0;
                char[] buffer = new char[4096];
     
                int bytesRead;
                for(boolean var4 = true; (bytesRead = in.read(buffer)) != -1; byteCount += bytesRead) {
                    out.write(buffer, 0, bytesRead);
                }
     
                out.flush();
                int var5 = byteCount;
                return var5;
            } finally {
                try {
                    in.close();
                } catch (IOException var15) {
                }
     
                try {
                    out.close();
                } catch (IOException var14) {
                }
     
            }
        }
     
        public static void copy(String in, Writer out) throws IOException {
            Assert.notNull(in, "No input String specified");
            Assert.notNull(out, "No Writer specified");
     
            try {
                out.write(in);
            } finally {
                try {
                    out.close();
                } catch (IOException var8) {
                }
     
            }
     
        }
     
        public static String copyToString(@Nullable Reader in) throws IOException {
            if (in == null) {
                return "";
            } else {
                StringWriter out = new StringWriter();
                copy((Reader)in, (Writer)out);
                return out.toString();
            }
        }
    }

## IoUtil io流工具类 ##

完整代码如下：

import java.io.Closeable;
    import java.io.Flushable;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.charset.Charset;
    import org.springframework.lang.Nullable;
    import org.springframework.util.StreamUtils;
     
    public class IoUtil extends StreamUtils {
        public IoUtil() {
        }
     
        public static void closeQuietly(@Nullable Closeable closeable) {
            if (closeable != null) {
                if (closeable instanceof Flushable) {
                    try {
                        ((Flushable)closeable).flush();
                    } catch (IOException var3) {
                    }
                }
     
                try {
                    closeable.close();
                } catch (IOException var2) {
                }
     
            }
        }
     
        public static String readToString(InputStream input) {
            return readToString(input, Charsets.UTF_8);
        }
     
        public static String readToString(@Nullable InputStream input, Charset charset) {
            String var2;
            try {
                var2 = copyToString(input, charset);
            } catch (IOException var6) {
                throw Exceptions.unchecked(var6);
            } finally {
                closeQuietly(input);
            }
     
            return var2;
        }
     
        public static byte[] readToByteArray(@Nullable InputStream input) {
            byte[] var1;
            try {
                var1 = copyToByteArray(input);
            } catch (IOException var5) {
                throw Exceptions.unchecked(var5);
            } finally {
                closeQuietly(input);
            }
     
            return var1;
        }
     
        public static void write(@Nullable final String data, final OutputStream output, final Charset encoding) throws IOException {
            if (data != null) {
                output.write(data.getBytes(encoding));
            }
     
        }
    }

## DateUtil 日期时间工具类 ##

完整代码如下：

import lombok.experimental.UtilityClass;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
     
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.GregorianCalendar;
    import java.util.Locale;
     
    /**
     * 日期工具类
     *
     * @author tarzan liu
     * @version V1.0
     * @date 2021年5月11日
     */
    @Slf4j
    @UtilityClass
    public class DateUtil {
     
        public static final long ONE_DAY_SECONDS = 86400;
        public static final String SHORT_FORMAT = "yyyyMMdd";
        public static final String LONG_FORMAT = "yyyyMMddHHmmss";
        public static final String concurrentFormat = "yyyyMMddHHmmssSSS";
        public static final String shortConcurrentFormat = "yyMMddHHmmssSSS";
        public static final String webFormat = "yyyy-MM-dd";
        public static final String webMonthFormat = "yyyy-MM";
        public static final String timeFormat = "HH:mm:ss";
        public static final String monthFormat = "yyyyMM";
        public static final String chineseDtFormat = "yyyy年MM月dd日";
        public static final String chineseYMFormat = "yyyy年MM月";
        public static final String datetimeFormat = "yyyy-MM-dd HH:mm:ss";
        public static final String noSecondFormat = "yyyy-MM-dd HH:mm";
        public static final String MdFormat = "MM-dd";
        public static final long ONE_DAY_MILL_SECONDS = 86400000;
     
        public static Date now() {
            return new Date();
        }
     
        public static DateFormat getNewDateFormat(String pattern) {
            DateFormat df = new SimpleDateFormat(pattern);
            df.setLenient(false);
            return df;
        }
     
        public static String format(Date date, String format) {
            return new SimpleDateFormat(format).format(date);
        }
     
        public static String format(String dateStr, String oldFormat, String newFormat) throws ParseException {
            String result = null;
            DateFormat oldDateFormat = new SimpleDateFormat(oldFormat);
            DateFormat newDateFormat = new SimpleDateFormat(newFormat);
            Date date = oldDateFormat.parse(dateStr);
            result = newDateFormat.format(date);
            return result;
        }
     
        public static Date parseDateNoTime(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(SHORT_FORMAT);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateNoTime(String sDate, String format) throws ParseException {
            if (StringUtils.isBlank(format)) {
                throw new ParseException("Null format. ", 0);
            }
     
            DateFormat dateFormat = new SimpleDateFormat(format);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateNoTimeWithDelimit(String sDate, String delimit) throws ParseException {
            sDate = sDate.replaceAll(delimit, "");
            DateFormat dateFormat = new SimpleDateFormat(SHORT_FORMAT);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateLongFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(LONG_FORMAT);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateNewFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(datetimeFormat);
            dateFormat.setLenient(false);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateNoSecondFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(noSecondFormat);
            dateFormat.setLenient(false);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateWebFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(webFormat);
            dateFormat.setLenient(false);
            return dateFormat.parse(sDate);
        }
     
        public static Date parseDateWebMonthFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(webMonthFormat);
            dateFormat.setLenient(false);
            return dateFormat.parse(sDate);
        }
     
        /**
         * 计算当前时间几小时之后的时间
         *
         * @param date
         * @param hours
         * @return
         */
        public static Date addHours(Date date, long hours) {
            return addMinutes(date, hours * 60);
        }
     
        /**
         * 计算当前时间几分钟之后的时间
         *
         * @param date
         * @param minutes
         * @return
         */
        public static Date addMinutes(Date date, long minutes) {
            return addSeconds(date, minutes * 60);
        }
     
        /**
         * @param date1
         * @param secs
         * @return
         */
        public static Date addSeconds(Date date1, long secs) {
            return new Date(date1.getTime() + secs * 1000);
        }
     
        /**
         * 判断输入的字符串是否为合法的小时
         *
         * @param hourStr
         * @return true/false
         */
        public static boolean isValidHour(String hourStr) {
            if (!StringUtils.isEmpty(hourStr) && StringUtils.isNumeric(hourStr)) {
                int hour = Integer.parseInt(hourStr);
                return hour >= 0 && hour <= 23;
            }
            return false;
        }
     
        /**
         * 判断输入的字符串是否为合法的分或秒
         *
         * @param str
         * @return true/false
         */
        public static boolean isValidMinuteOrSecond(String str) {
            if (!StringUtils.isEmpty(str) && StringUtils.isNumeric(str)) {
                int hour = Integer.parseInt(str);
                return hour >= 0 && hour <= 59;
            }
            return false;
        }
     
        /**
         * 取得新的日期
         *
         * @param date1 日期
         * @param days  天数
         * @return 新的日期
         */
        public static Date addDays(Date date1, long days) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date1);
            cal.add(Calendar.DATE, (int) days);
            return cal.getTime();
        }
     
        public static String getTomorrowDateString(String sDate) throws ParseException {
            Date aDate = parseDateNoTime(sDate);
     
            aDate = addSeconds(aDate, ONE_DAY_SECONDS);
     
            return getDateString(aDate);
        }
     
        public static String getTomorrowDateNewFMTString(String sDate) throws ParseException {
            Date aDate = parseDateWebFormat(sDate);
            aDate = addDays(aDate, 1);
            return getWebDateString(aDate);
        }
     
        public static String getTomorrowDateNewFormatString(String sDate) throws ParseException {
            Date aDate = parseDateNewFormat(sDate);
            aDate = addDays(aDate, 1);
            return getWebDateString(aDate);
        }
     
        public static String getLongDateString(Date date) {
            DateFormat dateFormat = new SimpleDateFormat(LONG_FORMAT);
     
            return getDateString(date, dateFormat);
        }
     
        public static String getNewFormatDateString(Date date) {
            DateFormat dateFormat = new SimpleDateFormat(datetimeFormat);
            return getDateString(date, dateFormat);
        }
     
        public static String getWebFormatDateString(Date date) {
            DateFormat dateFormat = new SimpleDateFormat(webFormat);
            return getDateString(date, dateFormat);
        }
     
        public static String getConcurrentFormatDateString(Date date) {
            DateFormat dateFormat = new SimpleDateFormat(concurrentFormat);
            return getDateString(date, dateFormat);
        }
     
        public static String getDateString(Date date, DateFormat dateFormat) {
            if (date == null || dateFormat == null) {
                return null;
            }
     
            return dateFormat.format(date);
        }
     
        public static String getYesterDayDateString(String sDate) throws ParseException {
            Date aDate = parseDateNoTime(sDate);
     
            aDate = addSeconds(aDate, -ONE_DAY_SECONDS);
     
            return getDateString(aDate);
        }
     
        /**
         * @return 当天的时间格式化为"yyyyMMdd"
         */
        public static String getDateString(Date date) {
            DateFormat df = getNewDateFormat(SHORT_FORMAT);
     
            return df.format(date);
        }
     
        public static String getWebDateString(Date date) {
            DateFormat dateFormat = getNewDateFormat(webFormat);
     
            return getDateString(date, dateFormat);
        }
     
        /**
         * 取得“X年X月X日”的日期格式
         *
         * @param date
         * @return
         */
        public static String getChineseDateString(Date date) {
            DateFormat dateFormat = getNewDateFormat(chineseDtFormat);
     
            return getDateString(date, dateFormat);
        }
     
        public static String getTodayString() {
            DateFormat dateFormat = getNewDateFormat(SHORT_FORMAT);
     
            return getDateString(new Date(), dateFormat);
        }
     
        public static String getTomorrowString() {
            DateFormat dateFormat = getNewDateFormat(SHORT_FORMAT);
     
            return getDateString(DateUtil.addDays(new Date(), 1), dateFormat);
        }
     
        public static String getTimeString(Date date) {
            DateFormat dateFormat = getNewDateFormat(timeFormat);
     
            return getDateString(date, dateFormat);
        }
     
        public static String getBeforeDayString(int days) {
            Date date = new Date(System.currentTimeMillis() - ONE_DAY_MILL_SECONDS * days);
            DateFormat dateFormat = getNewDateFormat(SHORT_FORMAT);
     
            return getDateString(date, dateFormat);
        }
     
        /**
         * 取得两个日期间隔毫秒数（日期1-日期2）
         *
         * @param one 日期1
         * @param two 日期2
         * @return 间隔秒数
         */
        public static long getDiffMillis(Date one, Date two) {
            Calendar sysDate = new GregorianCalendar();
     
            sysDate.setTime(one);
     
            Calendar failDate = new GregorianCalendar();
     
            failDate.setTime(two);
            return sysDate.getTimeInMillis() - failDate.getTimeInMillis();
        }
     
        /**
         * 取得两个日期间隔秒数（日期1-日期2）
         *
         * @param one 日期1
         * @param two 日期2
         * @return 间隔秒数
         */
        public static long getDiffSeconds(Date one, Date two) {
            Calendar sysDate = new GregorianCalendar();
     
            sysDate.setTime(one);
     
            Calendar failDate = new GregorianCalendar();
     
            failDate.setTime(two);
            return (sysDate.getTimeInMillis() - failDate.getTimeInMillis()) / 1000;
        }
     
        /**
         * 取得两个日期间隔分钟数（日期1-日期2）
         *
         * @param one 日期1
         * @param two 日期2
         * @return 间隔秒数
         */
        public static long getDiffMinutes(Date one, Date two) {
            Calendar sysDate = new GregorianCalendar();
     
            sysDate.setTime(one);
     
            Calendar failDate = new GregorianCalendar();
     
            failDate.setTime(two);
            return (sysDate.getTimeInMillis() - failDate.getTimeInMillis()) / (60 * 1000);
        }
     
        /**
         * 取得两个日期的间隔天数
         *
         * @param one
         * @param two
         * @return 间隔天数
         */
        public static long getDiffDays(Date one, Date two) {
            Calendar sysDate = new GregorianCalendar();
     
            sysDate.setTime(one);
     
            Calendar failDate = new GregorianCalendar();
     
            failDate.setTime(two);
            return (sysDate.getTimeInMillis() - failDate.getTimeInMillis()) / (24 * 60 * 60 * 1000);
        }
     
        /**
         * 取得两个日期相差的自然日
         *
         * @param date1
         * @param date2
         * @return
         */
        public static long getDiffNaturalDays(Date date1, Date date2) throws ParseException {
            return Math.abs(getDiffNaturalDayNotAbs(date1, date2));
        }
     
        /**
         * 取得两个日期相差的自然日
         *
         * @param date1
         * @param date2
         * @return
         */
        public static long getDiffNaturalDayNotAbs(Date date1, Date date2) throws ParseException {
     
            long diffDays;
            DateFormat dateFormat = new SimpleDateFormat(webFormat);
     
            //去掉时分秒
            String dateStr1 = dateFormat.format(date1);
            String dateStr2 = dateFormat.format(date2);
            diffDays = (dateFormat.parse(dateStr1).getTime() - dateFormat.parse(dateStr2).getTime()) / (24 * 60 * 60 * 1000);
     
            return diffDays;
        }
     
        public static String getBeforeDayString(String dateString, int days) throws ParseException {
            DateFormat df = getNewDateFormat(SHORT_FORMAT);
            Date date = df.parse(dateString);
            date = new Date(date.getTime() - ONE_DAY_MILL_SECONDS * days);
     
            return df.format(date);
        }
     
        public static boolean isValidShortDateFormat(String strDate) {
            if (strDate == null || strDate.length() != SHORT_FORMAT.length()) {
                return false;
            }
     
            try {
                // ---- 避免日期中输入非数字 ----
                Integer.parseInt(strDate);
            } catch (NumberFormatException e) {
                return false;
            }
     
            DateFormat df = getNewDateFormat(SHORT_FORMAT);
     
            try {
                df.parse(strDate);
            } catch (ParseException e) {
                return false;
            }
     
            return true;
        }
     
        public static boolean isValidShortDateFormat(String strDate, String delimiter) {
            String temp = strDate.replaceAll(delimiter, "");
     
            return isValidShortDateFormat(temp);
        }
     
        /**
         * 判断表示时间的字符是否为符合yyyyMMddHHmmss格式
         *
         * @param strDate
         * @return
         */
        public static boolean isValidLongDateFormat(String strDate) {
            if (strDate.length() != LONG_FORMAT.length()) {
                return false;
            }
     
            try {
                Long.parseLong(strDate); // ---- 避免日期中输入非数字 ----
            } catch (Exception NumberFormatException) {
                return false;
            }
     
            DateFormat df = getNewDateFormat(LONG_FORMAT);
     
            try {
                df.parse(strDate);
            } catch (ParseException e) {
                return false;
            }
     
            return true;
        }
     
        /**
         * 判断表示时间的字符是否为符合yyyyMMddHHmmss格式
         *
         * @param strDate
         * @param delimiter
         * @return
         */
        public static boolean isValidLongDateFormat(String strDate, String delimiter) {
            String temp = strDate.replaceAll(delimiter, "");
     
            return isValidLongDateFormat(temp);
        }
     
        public static String getShortDateString(String strDate) {
            return getShortDateString(strDate, "-|/");
        }
     
        public static String getShortDateString(String strDate, String delimiter) {
            if (StringUtils.isBlank(strDate)) {
                return null;
            }
     
            String temp = strDate.replaceAll(delimiter, "");
     
            if (isValidShortDateFormat(temp)) {
                return temp;
            }
     
            return null;
        }
     
        public static String getShortFirstDayOfMonth() {
            Calendar cal = Calendar.getInstance();
            Date dt = new Date();
     
            cal.setTime(dt);
            cal.set(Calendar.DAY_OF_MONTH, 1);
     
            DateFormat df = getNewDateFormat(SHORT_FORMAT);
     
            return df.format(cal.getTime());
        }
     
        public static String getWebTodayString() {
            DateFormat df = getNewDateFormat(webFormat);
     
            return df.format(new Date());
        }
     
        /**
         * 获取当月首日
         *
         * @return
         */
        public static String getWebFirstDayOfMonth() {
            Calendar cal = Calendar.getInstance();
            Date dt = new Date();
     
            cal.setTime(dt);
            cal.set(Calendar.DAY_OF_MONTH, 1);
     
            DateFormat df = getNewDateFormat(webFormat);
     
            return df.format(cal.getTime());
        }
     
        /**
         * 获取当月的总天数
         *
         * @return
         */
        public static int getDaysOfMonth() {
            Calendar cal = Calendar.getInstance(Locale.CHINA);
            return cal.getActualMaximum(Calendar.DATE);
        }
     
        public static String convert(String dateString, DateFormat formatIn, DateFormat formatOut) {
            try {
                Date date = formatIn.parse(dateString);
     
                return formatOut.format(date);
            } catch (ParseException e) {
                return "";
            }
        }
     
        public static String convert2WebFormat(String dateString) {
            DateFormat df1 = getNewDateFormat(SHORT_FORMAT);
            DateFormat df2 = getNewDateFormat(webFormat);
     
            return convert(dateString, df1, df2);
        }
     
        public static String convert2ChineseDtFormat(String dateString) {
            DateFormat df1 = getNewDateFormat(SHORT_FORMAT);
            DateFormat df2 = getNewDateFormat(chineseDtFormat);
     
            return convert(dateString, df1, df2);
        }
     
        public static String convertFromWebFormat(String dateString) {
            DateFormat df1 = getNewDateFormat(SHORT_FORMAT);
            DateFormat df2 = getNewDateFormat(webFormat);
     
            return convert(dateString, df2, df1);
        }
     
        public static boolean webDateNotLessThan(String date1, String date2) {
            DateFormat df = getNewDateFormat(webFormat);
     
            return dateNotLessThan(date1, date2, df);
        }
     
        /**
         * @param date1
         * @param date2
         * @param format
         * @return
         */
        public static boolean dateNotLessThan(String date1, String date2, DateFormat format) {
            try {
                Date d1 = format.parse(date1);
                Date d2 = format.parse(date2);
     
                return !d1.before(d2);
            } catch (ParseException e) {
                return false;
            }
        }
     
        public static String getEmailDate(Date today) {
            String todayStr;
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
     
            todayStr = sdf.format(today);
            return todayStr;
        }
     
        public static String getSmsDate(Date today) {
            String todayStr;
            SimpleDateFormat sdf = new SimpleDateFormat("MM月dd日HH:mm");
     
            todayStr = sdf.format(today);
            return todayStr;
        }
     
        public static String formatMonth(Date date) {
            if (date == null) {
                return null;
            }
     
            return new SimpleDateFormat(monthFormat).format(date);
        }
     
        /**
         * 获取系统日期的前一天日期，返回Date
         *
         * @return
         */
        public static Date getBeforeDate() {
            Date date = new Date();
     
            return new Date(date.getTime() - ONE_DAY_MILL_SECONDS);
        }
     
        /**
         * 获得指定时间当天起点时间
         *
         * @param date
         * @return
         */
        public static Date getDayBegin(Date date) {
            DateFormat df = new SimpleDateFormat("yyyyMMdd");
            df.setLenient(false);
     
            String dateString = df.format(date);
     
            try {
                return df.parse(dateString);
            } catch (ParseException e) {
                return date;
            }
        }
     
        /**
         * 根据Date对象返回今天是星期几
         *
         * @param date
         * @return 1:星期日 2:星期一 3:星期二 4:星期三 5:星期四 6:星期五 7:星期六
         */
        public static int getWeekDayFromDateEntity(Date date) {
     
            Calendar calendar = Calendar.getInstance();// 获得一个日历
            calendar.setTime(date);
            return calendar.get(Calendar.DAY_OF_WEEK);
     
        }
     
        /**
         * 判断参date上min分钟后，是否小于当前时间
         *
         * @param date
         * @param min
         * @return
         */
        public static boolean dateLessThanNowAddMin(Date date, long min) {
            return addMinutes(date, min).before(new Date());
     
        }
     
        public static boolean isBeforeNow(Date date) {
            if (date == null) {
                return false;
            }
            return date.compareTo(new Date()) < 0;
        }
     
        /**
         * 获得当前月的开始日期
         *
         * @param date
         * @return
         */
        public static Date getMinMonthDate(String date) throws ParseException {
            Calendar calendar = Calendar.getInstance();
            SimpleDateFormat fmt = new SimpleDateFormat(webFormat);
            calendar.setTime(fmt.parse(date));
            calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
            return calendar.getTime();
        }
     
        /**
         * 获得当前月的结束日期
         *
         * @param date
         * @return
         */
        public static Date getMaxMonthDate(String date) throws ParseException {
            Calendar calendar = Calendar.getInstance();
            SimpleDateFormat fmt = new SimpleDateFormat(webFormat);
            calendar.setTime(fmt.parse(date));
            calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
            return calendar.getTime();
        }
     
        public static Date parseNoSecondFormat(String sDate) throws ParseException {
            DateFormat dateFormat = new SimpleDateFormat(noSecondFormat);
            return dateFormat.parse(sDate);
        }
     
        /*
         *
         * date日期转变成 制定格式字符串
         *
         */
        public static String convertDate2String(Date date, String time_pattern) {
            SimpleDateFormat sf = new SimpleDateFormat(time_pattern);
            return sf.format(date);
     
        }
     
        /**
         * 根据Date对象返回天
         *
         * @param date
         */
        public static int getDayFromDateEntity(Date date) {
            Calendar calendar = Calendar.getInstance();// 获得一个日历
            calendar.setTime(date);
            return calendar.get(Calendar.DATE);
     
        }
     
        public static int compareDateStr(String dateStr, String anotherDateStr) throws ParseException {
            DateFormat df = new SimpleDateFormat(webMonthFormat);
            Date dt1 = df.parse(dateStr);
            Date dt2 = df.parse(anotherDateStr);
            return Long.compare(dt1.getTime(), dt2.getTime());
        }
     
        public static String getCurMonth() {
            return format(new Date(), webMonthFormat);
        }
     
        public static String getChineseYMString(String date) throws ParseException {
            SimpleDateFormat sdf = new SimpleDateFormat(chineseYMFormat);
            Date datea = sdf.parse(date);
            DateFormat dateFormat = getNewDateFormat(chineseYMFormat);
            return getDateString(datea, dateFormat);
        }
     
        public static Date getPreMonthDate(String date) throws ParseException {
            SimpleDateFormat sdf = new SimpleDateFormat(webMonthFormat);
            Date datea = sdf.parse(date);
            Calendar cal = Calendar.getInstance();
            cal.setTime(datea);
            cal.add(Calendar.MONTH, -1);
            return cal.getTime();
        }
     
        public static Date getNextMonthDate(String date) throws ParseException {
            SimpleDateFormat sdf = new SimpleDateFormat(webMonthFormat);
            Date datea = sdf.parse(date);
            Calendar cal = Calendar.getInstance();
            cal.setTime(datea);
            cal.add(Calendar.MONTH, 1);
            return cal.getTime();
        }
     
        /**
         * 获取指定日期的当月的第一天
         *
         * @param date
         * @return
         */
        public static String getAssignedDateFirstDayOfMonth(Date date) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
            DateFormat df = getNewDateFormat(webFormat);
            return df.format(cal.getTime());
        }
     
        /**
         * 获取指定日期的当月的最后一天
         *
         * @param date
         * @return
         */
        public static String getAssignedDateLastDayOfMonth(Date date) {
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
            DateFormat df = getNewDateFormat(webFormat);
            return df.format(cal.getTime());
        }
     
        public static Date getNextDate(Date date) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.DAY_OF_MONTH, 1);
            return new Date(calendar.getTimeInMillis());
        }
     
        /**
         * 根据年 月 获取对应的月份 天数
         */
        public static int getDaysByYearMonth(int year, int month) {
            Calendar a = Calendar.getInstance();
            a.set(Calendar.YEAR, year);
            a.set(Calendar.MONTH, month - 1);
            a.set(Calendar.DATE, 1);
            a.roll(Calendar.DATE, -1);
            return a.get(Calendar.DATE);
        }
     
    }

## BeanUtil 实体对象转换 ##

pom文件依赖

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.4.0</version>
            <relativePath/>
        </parent>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
            </dependency>

完整代码如下：

import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.BeanUtils;
    import org.springframework.beans.BeanWrapperImpl;
     
    import java.beans.FeatureDescriptor;
    import java.lang.reflect.Field;
    import java.util.*;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
     
    /**
     * Bean拷贝工具类
     *
     * @author tarzan liu
     * @version V1.0
     * @date 2021年5月11日
     */
    public class BeanUtil {
     
     
        /**
         * 方法描述 不copy为null的属性
         *
         * @param @param source
         * @param @param target
         * @return void
         * @throws
         */
        public static void copyPropertiesExcludeNull(Object source, Object target) {
            BeanWrapperImpl wrappedSource = new BeanWrapperImpl(source);
            String[] ignoreProperties = Stream.of(wrappedSource.getPropertyDescriptors()).map(FeatureDescriptor::getName).filter(propertyName -> wrappedSource.getPropertyValue(propertyName) == null)
                    .toArray(String[]::new);
            BeanUtils.copyProperties(source, target, ignoreProperties);
        }
     
        /**
         * 复制bean的属性
         *
         * @param source 源 要复制的对象
         * @param target 目标 复制到此对象
         */
        public static void copyProperties(Object source, Object target) {
            BeanUtils.copyProperties(source, target);
        }
     
        /**
         * 复制对象
         *
         * @param source 源 要复制的对象
         * @param target 目标 复制到此对象
         * @param <T>
         * @return
         */
        public static <T> T copy(Object source, Class<T> target) {
            try {
                T newInstance = target.newInstance();
                BeanUtils.copyProperties(source, newInstance);
                return newInstance;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
     
        /**
         * 复制list
         *
         * @param source
         * @param target
         * @param <T>
         * @param <K>
         * @return
         */
        public static <T, K> List<K> copyList(List<T> source, Class<K> target) {
            if (null == source || source.isEmpty()) {
                return Collections.emptyList();
            }
            return source.stream().map(e -> copy(e, target)).collect(Collectors.toList());
        }
     
        public static <T> Map<String, T> objectToMap(Object requestParameters) {
            Map<String, T> map = new HashMap<>();
            // 获取f对象对应类中的所有属性域
            Field[] fields = requestParameters.getClass().getDeclaredFields();
            for (int i = 0, len = fields.length; i < len; i++) {
                String varName = fields[i].getName();
                // 获取原来的访问控制权限
                boolean accessFlag = fields[i].isAccessible();
                // 修改访问控制权限
                fields[i].setAccessible(true);
                // 获取在对象f中属性fields[i]对应的对象中的变量
                Object o = null;
                try {
                    o = fields[i].get(requestParameters);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                if (o != null && StringUtils.isNotBlank(o.toString().trim())) {
                    map.put(varName, (T) o);
                    // 恢复访问控制权限
                    fields[i].setAccessible(accessFlag);
                }
            }
            return map;
        }
    }