java 获取前一天凌晨时间

可以使用以下代码获取前一天凌晨时间：

Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
cal.set(Calendar.HOUR_OF_DAY, );
cal.set(Calendar.MINUTE, );
cal.set(Calendar.SECOND, );
cal.set(Calendar.MILLISECOND, );
Date yesterday = cal.getTime();

这段代码会获取当前时间的前一天凌晨时间。

相关问题

JAVA 获取前一天2点的时间

在Java中，获取前一天的凌晨两点（即昨天的2:00 AM）可以使用`java.time`包下的`LocalDate`和`LocalTime`类配合。这里是一个示例代码：

import java.time.LocalDate;
import java.time.LocalTime;

public class Main {
    public static void main(String[] args) {
        // 获取当前日期的前一天
        LocalDate yesterday = LocalDate.now().minusDays(1);
        
        // 设置时间为凌晨两点
        LocalTime midnight = LocalTime.of(0, 0); // 0代表小时，0代表分钟
        
        // 合并日期和时间
        LocalDateTime dateTime =昨日.atTime(midnight);

        System.out.println("前一天的凌晨两点：" + dateTime);
    }
}

这段代码首先获取当前日期减去一天得到昨天的日期，然后设置时间为凌晨两点（0点和0分），最后将这两个组合成`LocalDateTime`对象。

java定时任务，每天凌晨三点，迁移数据，然后将30天之前的数据del属性改为10，删除del为10的数据，核对数据是否正确

以下是Java代码实现：

import java.time.LocalTime;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.Calendar;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;

public class DailyDataMigrationJob {

    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void migrateData() {
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 获取今天凌晨三点的时间
        LocalDateTime migrateTime = LocalDateTime.of(LocalDate.now(), LocalTime.of(3, 0));
        // 如果当前时间在凌晨三点之前，则需要将迁移时间设置为昨天的凌晨三点
        if (now.isBefore(migrateTime)) {
            migrateTime = migrateTime.minusDays(1);
        }
        // 获取迁移时间的日期
        LocalDate migrateDate = migrateTime.toLocalDate();
        // 获取迁移时间的前一天日期
        LocalDate previousDate = migrateDate.minusDays(1);
        // 获取迁移时间的前30天日期
        LocalDate thirtyDaysAgo = migrateDate.minusDays(30);
        // 获取迁移时间的当天凌晨时间
        LocalDateTime migrateDateTime = LocalDateTime.of(migrateDate, LocalTime.of(0, 0));
        // 获取迁移时间的前一天晚上11点59分59秒的时间
        LocalDateTime previousDateTime = LocalDateTime.of(previousDate, LocalTime.of(23, 59, 59));
        // 获取迁移时间的前30天凌晨时间
        LocalDateTime thirtyDaysAgoDateTime = LocalDateTime.of(thirtyDaysAgo, LocalTime.of(0, 0));
        // 获取迁移时间的前30天晚上11点59分59秒的时间
        LocalDateTime thirtyDaysAgoEndDateTime = LocalDateTime.of(thirtyDaysAgo, LocalTime.of(23, 59, 59));
        // 如果当前时间在迁移时间之前，直接返回
        if (now.isBefore(migrateDateTime)) {
            return;
        }
        // 如果当前时间在迁移时间到前一天晚上11点59分59秒之间，执行迁移操作
        if (now.isBefore(previousDateTime)) {
            // 查询需要迁移的数据
            List<Data> dataToMigrate = entityManager.createQuery("SELECT d FROM Data d WHERE d.createTime >= :thirtyDaysAgo AND d.createTime <= :previousDateTime", Data.class)
                    .setParameter("thirtyDaysAgo", Date.from(thirtyDaysAgoDateTime.atZone(ZoneId.systemDefault()).toInstant()))
                    .setParameter("previousDateTime", Date.from(previousDateTime.atZone(ZoneId.systemDefault()).toInstant()))
                    .getResultList();
            // 修改30天之前的数据的del属性为10
            for (Data data : dataToMigrate) {
                data.setDel(10);
            }
            // 删除del为10的数据
            entityManager.createQuery("DELETE FROM Data d WHERE d.del = 10")
                    .executeUpdate();
            // 提交事务
            entityManager.flush();
            entityManager.clear();
            // 核对数据是否正确
            long migratedDataCount = entityManager.createQuery("SELECT COUNT(d) FROM Data d WHERE d.del = 10", Long.class)
                    .getSingleResult();
            if (migratedDataCount == dataToMigrate.size()) {
                System.out.println("数据迁移成功，共迁移了 " + migratedDataCount + " 条数据");
            } else {
                System.out.println("数据迁移失败，实际迁移了 " + migratedDataCount + " 条数据，期望迁移 " + dataToMigrate.size() + " 条数据");
            }
        }
        // 如果当前时间在前一天晚上11点59分59秒之后，执行删除操作
        if (now.isAfter(previousDateTime)) {
            // 删除del为10的数据
            int deletedCount = entityManager.createQuery("DELETE FROM Data d WHERE d.del = 10")
                    .executeUpdate();
            // 提交事务
            entityManager.flush();
            entityManager.clear();
            // 核对数据是否正确
            long remainingDataCount = entityManager.createQuery("SELECT COUNT(d) FROM Data d", Long.class)
                    .getSingleResult();
            if (remainingDataCount == deletedCount) {
                System.out.println("数据删除成功，共删除了 " + deletedCount + " 条数据");
            } else {
                System.out.println("数据删除失败，实际删除了 " + deletedCount + " 条数据，期望删除 " + remainingDataCount + " 条数据");
            }
        }
    }

}

以上代码中，假设需要迁移的数据实体类为`Data`，其中包含一个名为`del`的属性表示是否删除，初始值为0表示未删除，10表示已删除。`Data`类的代码如下：

import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Data {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private int del;

    private Date createTime;

    // 省略getter和setter方法

}

在以上代码中，`@PersistenceContext`注解表示通过依赖注入获取`EntityManager`对象，`@Transactional`注解表示该方法需要在事务中执行。在`migrateData()`方法中，首先获取当前时间和需要迁移的时间，然后判断当前时间是否在迁移时间之前，如果是，则直接返回；如果不是，则判断当前时间是否在迁移时间到前一天晚上11点59分59秒之间，如果是，则执行迁移操作；否则执行删除操作。在迁移操作中，首先查询需要迁移的数据，然后修改30天之前的数据的del属性为10，删除del为10的数据，最后提交事务并核对数据是否正确。在删除操作中，直接删除del为10的数据，最后提交事务并核对数据是否正确。如果数据核对正确，则输出操作成功的信息，否则输出操作失败的信息。