14.9. 将数据库与您的 Quarkus OptaPlanner research timetable 应用程序集成

流程

1. 使用 Hibernate 和 Panache 将 Timeslot、Room 和 lesson 实例存储在数据库中。如需更多信息，请参阅使用 Panache 简化 Hibernate ORM。
2. 通过 REST 公开实例。如需更多信息，请参阅 编写 JSON REST 服务。

3. 更新 TimeTableResource 类，在单个事务中读取和写入 TimeTable 实例：

   package org.acme.optaplanner.rest;
   
   import javax.inject.Inject;
   import javax.transaction.Transactional;
   import javax.ws.rs.GET;
   import javax.ws.rs.POST;
   import javax.ws.rs.Path;
   
   import io.quarkus.panache.common.Sort;
   import org.acme.optaplanner.domain.Lesson;
   import org.acme.optaplanner.domain.Room;
   import org.acme.optaplanner.domain.TimeTable;
   import org.acme.optaplanner.domain.Timeslot;
   import org.optaplanner.core.api.score.ScoreManager;
   import org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore;
   import org.optaplanner.core.api.solver.SolverManager;
   import org.optaplanner.core.api.solver.SolverStatus;
   
   @Path("/timeTable")
   public class TimeTableResource {
   
       public static final Long SINGLETON_TIME_TABLE_ID = 1L;
   
       @Inject
       SolverManager<TimeTable, Long> solverManager;
       @Inject
       ScoreManager<TimeTable, HardSoftScore> scoreManager;
   
       // To try, open http://localhost:8080/timeTable
       @GET
       public TimeTable getTimeTable() {
           // Get the solver status before loading the solution
           // to avoid the race condition that the solver terminates between them
           SolverStatus solverStatus = getSolverStatus();
           TimeTable solution = findById(SINGLETON_TIME_TABLE_ID);
           scoreManager.updateScore(solution); // Sets the score
           solution.setSolverStatus(solverStatus);
           return solution;
       }
   
       @POST
       @Path("/solve")
       public void solve() {
           solverManager.solveAndListen(SINGLETON_TIME_TABLE_ID,
                   this::findById,
                   this::save);
       }
   
       public SolverStatus getSolverStatus() {
           return solverManager.getSolverStatus(SINGLETON_TIME_TABLE_ID);
       }
   
       @POST
       @Path("/stopSolving")
       public void stopSolving() {
           solverManager.terminateEarly(SINGLETON_TIME_TABLE_ID);
       }
   
       @Transactional
       protected TimeTable findById(Long id) {
           if (!SINGLETON_TIME_TABLE_ID.equals(id)) {
               throw new IllegalStateException("There is no timeTable with id (" + id + ").");
           }
           // Occurs in a single transaction, so each initialized lesson references the same timeslot/room instance
           // that is contained by the timeTable's timeslotList/roomList.
           return new TimeTable(
                   Timeslot.listAll(Sort.by("dayOfWeek").and("startTime").and("endTime").and("id")),
                   Room.listAll(Sort.by("name").and("id")),
                   Lesson.listAll(Sort.by("subject").and("teacher").and("studentGroup").and("id")));
       }
   
       @Transactional
       protected void save(TimeTable timeTable) {
           for (Lesson lesson : timeTable.getLessonList()) {
               // TODO this is awfully naive: optimistic locking causes issues if called by the SolverManager
               Lesson attachedLesson = Lesson.findById(lesson.getId());
               attachedLesson.setTimeslot(lesson.getTimeslot());
               attachedLesson.setRoom(lesson.getRoom());
           }
       }
   
   }

   本例包含一个 TimeTable 实例。但是，您可以为并行多个 ultra 启用多租户和处理 TimeTable 实例。

   getTimeTable （） 方法返回数据库的最新时间。它使用 ScoreManager 方法（自动注入）来计算可时间的分数，并使其可用于 UI。

   solve （） 方法启动一个作业，以解决当前的可时间表，并将时间插槽和房间分配存储在数据库中。它使用 SolverManager.solveAndListen （） 方法侦听中间的解决方案，并相应地更新数据库。UI 在后端仍然解决时使用它来显示进度。

4. 更新 TimeTableResourceTest 类，以反映 solve （） 方法立即返回，并轮询最新的解决方案，直到解决者完成解决为止：

   package org.acme.optaplanner.rest;
   
   import javax.inject.Inject;
   
   import io.quarkus.test.junit.QuarkusTest;
   import org.acme.optaplanner.domain.Lesson;
   import org.acme.optaplanner.domain.TimeTable;
   import org.junit.jupiter.api.Test;
   import org.junit.jupiter.api.Timeout;
   import org.optaplanner.core.api.solver.SolverStatus;
   
   import static org.junit.jupiter.api.Assertions.assertFalse;
   import static org.junit.jupiter.api.Assertions.assertNotNull;
   import static org.junit.jupiter.api.Assertions.assertTrue;
   
   @QuarkusTest
   public class TimeTableResourceTest {
   
       @Inject
       TimeTableResource timeTableResource;
   
       @Test
       @Timeout(600_000)
       public void solveDemoDataUntilFeasible() throws InterruptedException {
           timeTableResource.solve();
           TimeTable timeTable = timeTableResource.getTimeTable();
           while (timeTable.getSolverStatus() != SolverStatus.NOT_SOLVING) {
               // Quick polling (not a Test Thread Sleep anti-pattern)
               // Test is still fast on fast machines and doesn't randomly fail on slow machines.
               Thread.sleep(20L);
               timeTable = timeTableResource.getTimeTable();
           }
           assertFalse(timeTable.getLessonList().isEmpty());
           for (Lesson lesson : timeTable.getLessonList()) {
               assertNotNull(lesson.getTimeslot());
               assertNotNull(lesson.getRoom());
           }
           assertTrue(timeTable.getScore().isFeasible());
       }
   
   }

5. 在这些 REST 方法之上构建 Web UI，以提供可时间的可视化表示。
6. 查看 快速入门源代码。