【时间】常见-时间处理函数

已于 2024-08-22 07:21:28 修改
阅读量329 收藏 1
点赞数 7
分类专栏： 代码库 文章标签： java
于 2024-08-22 00:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72560900/article/details/141107963
版权

1. 仅比较：月-日

/**
     * 判断时间是否在指定的起始和结束时间之间（包含边界）。
     *
     * @param startTime 起始时间字符串（格式为"MM-dd"）
     * @param endTime   结束时间字符串（格式为"MM-dd"）
     * @param time      需要判断的时间
     * @return 如果时间在范围内返回true，否则返回false
     */
    public static boolean isTimeBetween(String startTime, String endTime, LocalDateTime time) {
        // 定义日期格式器，仅解析月和日
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM-dd");
        // 将LocalDateTime转换为LocalDate，仅保留月和日信息
        LocalDate timeDate = time.toLocalDate();
        LocalDate startDate;
        LocalDate endDate;
        try {
            // 解析起始日期字符串，并与当前年份结合
            TemporalAccessor startTemporal = formatter.parse(startTime);
            startDate = LocalDate.of(time.getYear(), 
                                     startTemporal.get(ChronoField.MONTH_OF_YEAR), 
                                     startTemporal.get(ChronoField.DAY_OF_MONTH));
            // 解析结束日期字符串，并与当前年份结合
            TemporalAccessor endTemporal = formatter.parse(endTime);
            endDate = LocalDate.of(time.getYear(), 
                                   endTemporal.get(ChronoField.MONTH_OF_YEAR), 
                                   endTemporal.get(ChronoField.DAY_OF_MONTH));
            // 如果结束日期早于起始日期（跨年情况），将结束日期加一年
            if (endDate.isBefore(startDate)) {
                endDate = endDate.plusYears(1);
            }
        } catch (Exception e) {
            // 解析过程中如果发生异常，返回false
            System.err.println("解析日期时发生错误: " + e.getMessage());
            return false;
        }
        // 判断时间是否在起始日期和结束日期之间（包括边界）
        return !timeDate.isBefore(startDate) && !timeDate.isAfter(endDate);
    }

2. 仅比较：时-分（HH:mm）

/**
     * 判断时间是否在指定的起始和结束时间之间（包含开始时间，不包含结束时间）。
     *
     * @param startTime HH:mm格式的时间
     * @param endTime   HH:mm格式的时间
     * @param time      需要判断的时间
     * @return 如果时间在范围内返回true，否则返回false
     */
    public static boolean isTimeBetweenOfHHmm(String startTime, String endTime, LocalDateTime time) {
        // 定义时间格式器
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");

        try {
            // 补全时间格式，如果输入的时间长度为4位，例如"9:30"，补全为"09:30"
            startTime = startTime.length() == 4 ? "0" + startTime : startTime;
            endTime = endTime.length() == 4 ? "0" + endTime : endTime;

            // 解析起始时间，并与当前日期结合
            TemporalAccessor startTemporal = formatter.parse(startTime);
            LocalDateTime startDate = LocalDateTime.of(time.getYear(), time.getMonthValue(), time.getDayOfMonth(),
                    startTemporal.get(ChronoField.HOUR_OF_DAY), startTemporal.get(ChronoField.MINUTE_OF_HOUR));

            // 解析结束时间，并与当前日期结合
            TemporalAccessor endTemporal = formatter.parse(endTime);
            LocalDateTime endDate = LocalDateTime.of(time.getYear(), time.getMonthValue(), time.getDayOfMonth(),
                    endTemporal.get(ChronoField.HOUR_OF_DAY), endTemporal.get(ChronoField.MINUTE_OF_HOUR));

            // 如果结束时间为"24:00"，则将其视为第二天的00:00
            if (endTime.equals("24:00")) {
                endDate = endDate.plusDays(1).withHour(0).withMinute(0);
            }

            // 比较时间是否在起始时间和结束时间之间（包含开始时间，不包含结束时间）
            return !time.isBefore(startDate) && time.isBefore(endDate);

        } catch (Exception e) {
            // 如果解析时间格式失败，返回false
            System.err.println("解析时间时发生错误: " + e.getMessage());
            return false;
        }
    }

3. 时间先后：LocalDate **

/**
     * 判断给定日期是否在某个日期的范围内（只比较日期，忽略时间）。
     *
     * @param startDate 起始日期
     * @param endDate   结束日期
     * @param date      需要判断的日期
     * @return 如果日期在范围内（包括边界）返回true，否则返回false
     */
    public static boolean isDateBetween(LocalDate startDate, LocalDate endDate, LocalDate date) {
        // 参数检查，确保输入的日期不为空
        if (startDate == null || endDate == null || date == null) {
            return false;
        }
        // 检查起始日期是否在结束日期之后
        if (startDate.isAfter(endDate)) {
            System.err.println("起始日期不能在结束日期之后");
            return false;
        }
        // 判断给定日期是否在范围内（包括边界）
        return !date.isBefore(startDate) && !date.isAfter(endDate);
    }

4. 判断日期是否为周末

/**
     * 判断给定的时间是否为周末。
     *
     * @param time 需要判断的时间
     * @return 如果是周末返回true，否则返回false
     */
    public static boolean isWeekend(LocalDateTime time) {
        // 参数检查，确保输入的时间不为空
        if (time == null) {
            throw new IllegalArgumentException("时间不能为空");
        }
        // 获取给定时间对应的星期几
        DayOfWeek dayOfWeek = time.getDayOfWeek();
        // 如果是周六或周日，返回true
        return dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY;
    }

5. 转换-字符串为: LocalDateTime，支持多种常见格式 **

/**
     * 将字符串转换为LocalDateTime，支持多种常见格式。
     *
     * @param dateTimeStr 日期时间字符串
     * @return 转换后的LocalDateTime对象，解析失败时返回null
     */
    public static LocalDateTime parseDateTime(String dateTimeStr) {
        // 定义支持的日期时间格式
        DateTimeFormatter[] formatters = {
                DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
                DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"),
                DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm"),
                DateTimeFormatter.ofPattern("yyyyMMddHHmmss"),
                DateTimeFormatter.ISO_DATE_TIME
        };

        // 遍历所有格式，尝试解析字符串
        for (DateTimeFormatter formatter : formatters) {
            try {
                return LocalDateTime.parse(dateTimeStr, formatter);
            } catch (DateTimeParseException e) {
                // 捕获解析异常，继续尝试下一个格式
                // 可以选择打印调试信息或记录日志
            }
        }

        // 如果无法解析，打印错误并返回null
        System.err.println("无法解析日期时间字符串: " + dateTimeStr);
        return null;
    }

6. 计算两个时间-分钟差

/**
     * 获取两个时间之间的分钟差。
     *
     * @param startTime 起始时间
     * @param endTime   结束时间
     * @return 分钟差，如果起始时间晚于结束时间返回负值
     */
    public static long getMinutesBetween(LocalDateTime startTime, LocalDateTime endTime) {
        // 检查输入的时间是否为空
        if (startTime == null || endTime == null) {
            throw new IllegalArgumentException("起始时间和结束时间不能为空");
        }

        // 计算两个时间之间的分钟差
        return ChronoUnit.MINUTES.between(startTime, endTime);
    }

7. LocalDateTime-转换为指定格式-字符串 **

/**
     * 将LocalDateTime转换为指定格式的字符串。
     *
     * @param time   需要转换的时间
     * @param format 目标格式
     * @return 格式化后的字符串
     */
    public static String formatDateTime(LocalDateTime time, String format) {
        // 参数检查，确保时间和格式不为空
        if (time == null || format == null || format.isEmpty()) {
            throw new IllegalArgumentException("时间和格式不能为空");
        }

        try {
            // 创建日期时间格式化器
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
            // 将时间格式化为指定格式的字符串
            return time.format(formatter);
        } catch (IllegalArgumentException e) {
            // 捕获并处理格式无效的异常
            throw new IllegalArgumentException("无效的日期格式: " + format, e);
        }
    }

8. 判断：是否为闰年

/**
     * 判断给定时间所在的年份是否为闰年。
     *
     * @param time 需要判断的时间
     * @return 如果为闰年返回true，否则返回false
     */
    public static boolean isLeapYear(LocalDateTime time) {
        // 检查输入的时间是否为空
        if (time == null) {
            throw new IllegalArgumentException("时间不能为空");
        }

        // 将LocalDateTime转换为LocalDate，并判断是否为闰年
        return time.toLocalDate().isLeapYear();
    }

9. 转换：秒数为HH:mm:ss字符串

/**
     * 将秒数转换为HH:mm:ss格式的字符串。
     *
     * @param seconds 秒数
     * @return HH:mm:ss格式的字符串
     */
    public static String secondsToHHmmss(long seconds) {
        // 检查输入的秒数是否为负数
        if (seconds < 0) {
            throw new IllegalArgumentException("秒数不能为负数");
        }

        // 计算小时、分钟和秒
        long hours = seconds / 3600;
        long minutes = (seconds % 3600) / 60;
        long secs = seconds % 60;

        // 格式化为HH:mm:ss格式的字符串
        return String.format("%02d:%02d:%02d", hours, minutes, secs);
    }

10. 计算两个时间-天数差 **

/**
     * 获取两个日期之间的天数差。
     *
     * @param startDate 起始日期
     * @param endDate   结束日期
     * @return 天数差，如果起始日期晚于结束日期返回负值
     */
    public static long getDaysBetween(LocalDate startDate, LocalDate endDate) {
        // 检查输入的日期是否为空
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("起始日期和结束日期不能为空");
        }

        // 计算两个日期之间的天数差
        return ChronoUnit.DAYS.between(startDate, endDate);
    }

11. 计算：日期下一个指定工作日（周一至周五）

/**
     * 计算给定日期的下一个指定工作日（周一至周五）。
     *
     * @param date 给定日期
     * @return 下一个工作日
     */
    public static LocalDate getNextBusinessDay(LocalDate date) {
        // 检查输入日期是否为空
        if (date == null) {
            throw new IllegalArgumentException("日期不能为空");
        }

        // 初步将日期加一天
        LocalDate nextDate = date.plusDays(1);
        DayOfWeek dayOfWeek = nextDate.getDayOfWeek();

        // 使用switch语句处理周末的情况
        switch (dayOfWeek) {
            case SATURDAY:
                // 如果是周六，则加两天跳到下周一
                nextDate = nextDate.plusDays(2);
                break;
            case SUNDAY:
                // 如果是周日，则加一天跳到下周一
                nextDate = nextDate.plusDays(1);
                break;
            default:
                // 如果是工作日，直接返回nextDate
                break;
        }

        return nextDate;
    }

12. 获取：某天的开始时间（即 00:00:00）**

/**
     * 获取某天的开始时间（即00:00:00）。
     *
     * @param date 给定日期
     * @return 该日期的开始时间
     */
    public static LocalDateTime getStartOfDay(LocalDate date) {
        // 检查输入的日期是否为空
        if (date == null) {
            throw new IllegalArgumentException("日期不能为空");
        }

        // 使用LocalDate的atStartOfDay方法获取当天的00:00:00
        return date.atStartOfDay();
    }

13. 获取：某天的结束时间（即 23:59:59）**

 /**
     * 获取某天的结束时间（即23:59:59）。
     *
     * @param date 给定日期
     * @return 该日期的结束时间
     */
    public static LocalDateTime getEndOfDay(LocalDate date) {
        // 检查输入的日期是否为空
        if (date == null) {
            throw new IllegalArgumentException("日期不能为空");
        }

        // 设置时间为23:59:59，不包含纳秒
        return date.atTime(LocalTime.of(23, 59, 59));
    }

14. 计算：两个日期之间的工作日天数（不包括周末）

/**
     * 计算两个日期之间的工作日天数（不包括周末）。
     *
     * @param startDate 起始日期
     * @param endDate   结束日期
     * @return 工作日天数
     */
    public static long getBusinessDaysBetween(LocalDate startDate, LocalDate endDate) {
        // 检查输入的日期是否为空
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("起始日期和结束日期不能为空");
        }
        // 确保startDate不晚于endDate，否则交换两者
        if (startDate.isAfter(endDate)) {
            LocalDate temp = startDate;
            startDate = endDate;
            endDate = temp;
        }
        // 计算两日期之间的天数
        long daysBetween = ChronoUnit.DAYS.between(startDate, endDate);
        // 遍历并计算工作日
        long businessDays = 0;
        for (int i = 0; i <= daysBetween; i++) {
            DayOfWeek dayOfWeek = startDate.plusDays(i).getDayOfWeek();
            if (dayOfWeek != DayOfWeek.SATURDAY && dayOfWeek != DayOfWeek.SUNDAY) {
                businessDays++;
            }
        }

        return businessDays;
    }

15. 计算：当前时间-指定日期的 天数 **

/**
     * 计算从当前时间到指定日期的天数。
     *
     * @param targetDate 目标日期
     * @return 从当前时间到目标日期的天数。如果目标日期在当前日期之前，返回负值
     */
    public static long daysUntil(LocalDate targetDate) {
        if (targetDate == null) {
            throw new IllegalArgumentException("目标日期不能为空");
        }
        // 获取当前日期
        LocalDate today = LocalDate.now();
        // 计算从当前日期到目标日期的天数
        return ChronoUnit.DAYS.between(today, targetDate);
    }

16. 计算：两个时间-之间的 小时数

 /**
     * 计算两个时间点之间的小时数。
     *
     * @param startTime 起始时间
     * @param endTime   结束时间
     * @return 两个时间点之间的小时数。如果起始时间晚于结束时间，返回负值
     */
    public static long hoursBetween(LocalDateTime startTime, LocalDateTime endTime) {
        if (startTime == null || endTime == null) {
            throw new IllegalArgumentException("起始时间和结束时间不能为空");
        }
        // 计算两个时间点之间的小时数
        return ChronoUnit.HOURS.between(startTime, endTime);
    }

17. 判断：日期是否是-月末

 /**
     * 判断给定日期是否是本月的最后一天。
     *
     * @param date 给定日期
     * @return 如果是本月的最后一天返回true，否则返回false
     */
    public static boolean isLastDayOfMonth(LocalDate date) {
        // 检查输入的日期是否为空
        if (date == null) {
            throw new IllegalArgumentException("日期不能为空");
        }
        // 获取本月的最后一天
        LocalDate lastDayOfMonth = date.withDayOfMonth(date.lengthOfMonth());
        // 比较给定日期和本月的最后一天是否相同
        return date.equals(lastDayOfMonth);
    }

18. 获取：当前季度的开始和结束日期

/**
     * 获取当前季度的开始和结束日期。
     *
     * @return 当前季度的开始和结束日期，返回一个包含两个 LocalDate 对象的数组
     */
    public static LocalDate[] getCurrentQuarterDates() {
        LocalDate now = LocalDate.now();
        int month = now.getMonthValue();
        LocalDate startDate;
        LocalDate endDate;

        // 确定当前季度的开始和结束日期
        if (month <= 3) {
            startDate = LocalDate.of(now.getYear(), 1, 1);
            endDate = LocalDate.of(now.getYear(), 3, 31);
        } else if (month <= 6) {
            startDate = LocalDate.of(now.getYear(), 4, 1);
            endDate = LocalDate.of(now.getYear(), 6, 30);
        } else if (month <= 9) {
            startDate = LocalDate.of(now.getYear(), 7, 1);
            endDate = LocalDate.of(now.getYear(), 9, 30);
        } else {
            startDate = LocalDate.of(now.getYear(), 10, 1);
            endDate = LocalDate.of(now.getYear(), 12, 31);
        }

        return new LocalDate[]{startDate, endDate};
    }

19. 计算：日期的下一个工作日的日期（跳过节假日、周末）

 /**
     * 计算给定日期的下一个工作日的日期（跳过节假日）。
     *
     * @param date 给定日期
     * @param holidays 节假日列表
     * @return 下一个工作日的日期
     */
    public static LocalDate getNextBusinessDayWithHolidays(LocalDate date, LocalDate[] holidays) {
        if (date == null || holidays == null) {
            throw new IllegalArgumentException("日期和节假日列表不能为空");
        }

        // 将节假日列表转换为Set以提高查询效率
        Set<LocalDate> holidaySet = new HashSet<>();
        for (LocalDate holiday : holidays) {
            holidaySet.add(holiday);
        }

        LocalDate nextDate = date.plusDays(1);

        // 查找下一个工作日，跳过周末和节假日
        while (nextDate.getDayOfWeek() == DayOfWeek.SATURDAY
                || nextDate.getDayOfWeek() == DayOfWeek.SUNDAY
                || holidaySet.contains(nextDate)) {
            nextDate = nextDate.plusDays(1);
        }

        return nextDate;
    }

20. LocalDateTime 转换为 LocalDate，只保留年月日部分 **

 /**
     * 将 LocalDateTime 转换为 LocalDate，只保留年月日部分。
     *
     * @param dateTime 需要转换的 LocalDateTime 对象
     * @return 只包含年月日的 LocalDate 对象
     * @throws IllegalArgumentException 如果 dateTime 为 null
     */
    public static LocalDate toLocalDate(LocalDateTime dateTime) {
        if (dateTime == null) {
            throw new IllegalArgumentException("LocalDateTime 不能为空");
        }
        return dateTime.toLocalDate();
    }

21. LocalDate 转换为 LocalDateTime，设置时间部分为 00:00:00 **

  /**
     * 将 LocalDate 转换为 LocalDateTime，设置时间部分为 00:00:00。
     *
     * @param date 需要转换的 LocalDate 对象
     * @return LocalDateTime 对象，时间部分为 00:00:00
     * @throws IllegalArgumentException 如果 date 为 null
     */
    public static LocalDateTime toStartOfDay(LocalDate date) {
        if (date == null) {
            throw new IllegalArgumentException("LocalDate 不能为空");
        }
        return date.atStartOfDay();
    }
盖盖衍上_染染熊
关注
专栏目录
ABAP日期函数（求月末日，第几周，search help 只显示年月） 使用方法实例
cishai0841的博客
04-19 901
计算两个日期间的工作天数,就是剔除了双休日后的天数.( 待考证)DATE_CONVERT_TO_FACTORYDATE HR_HK_DIFF_BT_2_DATES 根据当前时间如何找到上月的第一天和最后一天？CAL...
Java 时间格式化格式 DateTimeFormatter ofPattern
欲穷三千界
09-07 665
java.time.format.DateTimeFormatter java.text.SimpleDateFormat
Hive--时间函数大全
小兔子乖乖
05-24 1万+
hive时间函数1. current_date()：获取当前格式化日期2. current_timestamp()：获取当前格式化时间3. unix_timestamp()：获取当前unix时间戳4. from_unixtime()：把unix时间戳转化为格式化时间5. to_date(): 当前格式化时间（含时分秒）转化为年月日6. date_format(): 对日期进行格式化7. year/quarter/month/day/hour/minute/second: 年/季度/月/日/时/分/秒8. d
MySQL 常见函数 -------分组函数
qq_45043813的博客
06-07 2351
1.sum、AVG 一般用于处理数值型 MAX、MIN、COUNT 可以处理任何类型 2.忽略NULL值 3.可以和DISTINCT搭配实现去重的运算 4.count函数单独介绍 5.和分组函数一同查询的字段要求是GROUP BY后的字段SELECT SUM() FROM ; SELECT AVG() FROM ; SELECT MAX() FROM ; SELECT MIN() FROM ; SELECT COUNT() FROM ;SELECT SUM() AS 和, AVG() AS 平均值, MAX
pandas常见的时间处理函数
春华秋实
11-07 3121
pandas常见的时间处理函数： df.loc[mask, 'origin_order_unix_time'] = df.loc[mask, 'order_unix_time'] df.loc[mask, c] = df.loc[mask, c].apply(lambda x: datetime.datetime.fromtimestamp(x)) df.loc[mask, 'date']
PostgreSQL 常见时间日期处理
weixin_45694422的博客
10-19 5513
前言 在实际业务开发过程中，通常会遇到对时间日期相关的处理，这里列出一些常见的时间日期处理方法。 1. 时间戳带时区和不带时区 创建表字段时，指定带时区时间日期数据类型 postgres=# CREATE TABLE tab_test(id serial,app_name varchar,app_release_date timestamp with time zone default now()); CREATE TABLE postgres=# INSERT INTO tab_test
MySQL常见日期时间函数总结【建议收藏】
专注Java后端技术干货、项目源码总结分享，期待您的关注。
04-12 2665
FROM_UNIXTIME(timestamp)函数：是将UNIX时间戳转化为日期时间，与UNIX_TIMESTAMP(date)函数互为反函数。注意：在使用STR_TO_DATE函数时，请确保传入的日期字符串和格式字符串的格式匹配，否则可能会得到错误的结果。DATEDIFF(expr1,expr2)函数：返回expr1−expr2，以从一个日期到另一个日期的天数表示。expr1和expr2是日期或日期和时间表达式；NOW()函数用于返回当前日期和时间，包含年、月、日、时、分、秒！为表示日期格式的字符串。
SQL中常见的时间函数
薛敬明的专栏
01-10 1万+
前言 在处理SQL中的时间字段时，很多初学者都忽略了SQL 自带的日期时间函数，本文大致介绍常用的日期时间函数以及时间格式的转换问题。 1. 日期时间函数 (1) 获取当前系统日期、时间 select getdate() (2) dateadd()  在向指定日期加上一段时间的基础上，返回新的 datetime 值； 为了将某个时间字段更新到前一天，举例如下： UPDATE
Python -- 日期时间函数
热门推荐
zhubao124的博客
04-26 2万+
Python -- 日期时间函数       Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。本文主要是对这两个模块的函数进行详细介绍。 一、时间函数    在Python中，通常有如下几种方式表示时间：    （1）时间戳；    （2）格式化的时间字符串；    （...
Oracle的日期函数：高效处理日期和时间
renkejia1988的博客
11-22 2937
Oracle 提供了一系列日期函数，使得处理日期和时间数据变得更加高效和便捷。
归纳总结-sql常见函数-介绍说明与实际案例语句
03-27
日期函数：用于处理日期和时间，如GETDATE()、DATEADD()、DATEDIFF()等。 数学函数：用于执行算术运算，如ROUND()、ABS()、SQRT()等。 聚合函数： SELECT COUNT(*) FROM employees;：计算employees表中的记录数。 ...
php把时间戳转换成多少时间之前函数的实例
10-21
在处理与时间相关的内容时，经常需要用到时间戳和时间转换的功能。...通过理解和掌握这样的时间处理技巧，开发人员可以更好地满足用户界面中对于时间表示的需求，使网站或应用的时间信息显示更加友好和直观。
Python函数-对象-模块.pdf
07-08
类与对象的定义与使用，Python数据类型转换函数，random函数，判断输入是否为数字判断相关函数，Python取整的方式，常见的Python的数学函数，时间日期相关函数，以及Python的一种异常处理机制（try...except...）
Spring Boot 学习和使用
cesske的博客
09-24 1199
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 1004
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 788
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
最新发布
y050505的博客
09-25 490
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值