Java Quarkus以及如何在内存、实体和DAO中实现

我目前正在将我的数据库层（实体和DAO）从JavaEE迁移到Quarkus（或者，从wls迁移到OpenShift），无法完全理解一些细节：

目前，我拥有当前的结构：

• 信息类RegisteredTime.java
• 定义列名等的实体类，RegisteredTimeEntity.java，以及匹配的persistence.xml
• 要在RegisteredTime.java和RegisteredTimeEntity.java之间映射的MapStruct映射器类
• 使数据库访问更容易的DAO类，RegisteredTimeDAO.java
• structure.ddl定义数据库结构
• 内存类TestDB.java，它扩展了JdbcDaoSupport（springframework）并使用Derby

我的测试类注册了TimeDaoTest，它使用TestDB在内存中：

class RegisteredTimeDAOTest extends Specification {

private RegisteredTimeId registeredTimeId;
private RegisteredTimeData registeredTimeData;

private long userId;
private int userVersion;
private RegisteredTime registeredTime;
private Long userNumber;
private LocalDate startDate, endDate
private Boolean registration
private Boolean registrationApproved
private String registration
private String timeType
private LocalDate incomingDate

@Shared
private EntityManager entityManager
@Shared
private EntityManagerFactory entityManagerFactory
@Shared
private TestDB db
static SingleConnectionDataSource dataSource
private RedovisadTidEntity registeredTimeEntity
private RegisteredTimeDAO instance
private Gson gson

def setupSpec() {
    db = new TestDB("test")
    db.start()
    dataSource = new SingleConnectionDataSource(db.getJDBCUrl(), true)

    entityManagerFactory = Persistence.createEntityManagerFactory("EKN-Persistence-Test")
    entityManager = entityManagerFactory.createEntityManager()
}

def cleanupSpec() {
    if (entityManager != null) {
        entityManager.close()
    }
    if (entityManagerFactory != null) {
        entityManagerFactory.close()
    }
    db.shutdown()
}

def setup() {
    userId = 1
    userVersion = 1
    userNumber = 1991010101011L
    startDate = LocalDate.of(2020, 01, 01)
    endDate = LocalDate.of(2020, 01, 31)
    registration = false
    registrationApproved = false
    registration = null
    timeType = TimeType.STANDARD_TIME;
    incomingDate = LocalDate.of(2020, 02, 03)

    registeredTimeId = new RegisteredTimeId(userId, userVersion)
    registeredTimeData = RegisteredTimeData.newRegisteredTimeDataBuilder()
            .userNumber(userNumber)
            .startDate(startDate)
            .endDate(endDate)
            .registration(registration)
            .registrationApproved(registrationApproved)
            .timeType(timeType)
            .incomingDate(incomingDate)
            .build()

    registeredTime = new RegisteredTime().newRedovisadTidBuilder()
            .registeredTimeId(registeredTimeId)
            .registeredTimeData(registeredTimeData)
            .build()

    registeredTimeEntity = RegisteredTimeMapper.INSTANCE.toRegisteredTimeEntity(registeredTime)
    instance = new RegisteredTimeDAO(entityManager)
}

def cleanup() {
    instance = null
}

def "Save RegisteredTime"() {
    given:
    Statement statement = dataSource.getConnection().createStatement()
    statement.executeQuery("SELECT * FROM registeredtime")
    ResultSet rs = statement.getResultSet()
    gson = new Gson()

    when:
    entityManager.getTransaction().begin()
    instance.save(registeredTime)
    entityManager.getTransaction().commit()

    then:
    while (rs.next()) {
        assert rs.getInt(2) == userVersion
        assert rs.getLong(3) == userNumber
        assert gson.fromJson(rs.getString(4), RegisteredTimeData.class).equals(registeredTimeData)
        assert rs.getTime(5) != null
    }
}

def "Get RegisteredTime"() {
    when:
    entityManager.getTransaction().begin()
    RegisteredTime registeredTimeGet = instance.get(1000, userVersion)
    entityManager.getTransaction().commit()

    then:
    assert registeredTimeGet.getRegisteredTimeId().getAnsokanId() == userId
    assert registeredTimeGet.getRegisteredTimeId().getAnsokanVersion() == userVersion
    assert registeredTimeGet.getRegisteredTimeData().getKundId() == userNumber
    assert registeredTimeGet.getRegisteredTimeData().getFromdatum() == startDate
    assert registeredTimeGet.getRegisteredTimeData().getTomdatum() == endDate
    assert registeredTimeGet.getRegisteredTimeData().getAnmalanAF() == registration
    assert registeredTimeGet.getRegisteredTimeData().getFranvarogodkandAF() == registrationApproved
    assert registeredTimeGet.getRegisteredTimeData().getTimeType() == timeType
    assert registeredTimeGet.getRegisteredTimeData().getAngavsviddatum() == incomingDate
}

}

我一直潜伏在quarkus.io上，并阅读了以下内容：

（可能是最重要的一个）

（ofc）

（使用gradle）

• 仍然需要一个实体类，但EntityManagerFactory已经被取消，Datasource和EntityManger可以直接注入，对吗

• 我必须重写TestDB吗，还是有一个“开箱即用”的解决方案？我查看了Zero配置设置（DevServices），但这不允许我配置数据库。我不想再扩展springframework了

• 如果我使用Hibernate而没有华丽的外观，我需要一把刀吗

---

我假设您正在使用Spock进行测试

Quarkus仅支持JUnit5，因此您应该尝试使用基于JUnit5的Spock 2.0-M5，如果可能，通过其

Quarkus-JUnit5

扩展使用Quarkus JUnit5支持

有一个问题，你可以看

请注意，Quarkus不支持Groovy或Spock

作为替代，你也可以尝试，不知道它的状态是什么，我只是通过谷歌搜索找到它

关于你的问题：

仍然需要实体类，但正在创建EntityManagerFactory 处理完毕，数据源和EntityManger就可以注入， 对吧?

如果您正在使用Quarkus Hibernate ORM扩展，它是一个常规的Hibernate集成，因此是一个JPA实现，因此您需要定义JPA实体类。然后可以插入一个

EntityManager

。您还可以插入

数据源

，但最好使用

EntityManager

，因为它提供了更高级别的集成

我必须重写TestDB吗，还是有一个“开箱即用”的 解决方案我查看了Zero配置设置（DevServices），但是 不允许我配置数据库。我不想延长 springframework

如果您可以使用

@QuarkusTest

支持，它将启动您的应用程序，以便您可以使用H2或Derby之类的内存数据库。有通过Quarkus测试资源自动启动H2数据库的测试支持，请参阅Quarkus测试指南的一节，该节解释了如何通过

io.Quarkus.test.H2.H2 DatabaseTestResource启动H2数据库

Devservices也是一种很好的方法，它将在docker容器中运行一个真实的数据库，因此如果您没有配置任何数据源，而是使用Quarkus JDBC扩展之一（例如
Quarkus JDBC postgresql
），它将在该数据库的开发和测试中运行docker容器

还有两件事可以帮助您实现您想要的：Quarkus支持flyway或liquibase来管理数据库迁移，并且您可以通过
%test
配置文件拥有特定的测试属性（例如在测试时运行专用sql导入文件）

如果我使用Hibernate而没有华丽的外观，我需要一把刀吗

如果您需要DAO，我建议使用Hibernate和Panache，这是一个很好的扩展，可以轻松地在您的实体上实现DAO。但这取决于您希望如何设计应用程序。这取决于您是否使用DAO，以及是否为DAO使用Hibernate和Panache。
我假设您正在使用Spock进行测试

Quarkus仅支持JUnit5，因此您应该尝试使用基于JUnit5的Spock 2.0-M5，如果可能，通过其
Quarkus-JUnit5
扩展使用Quarkus JUnit5支持

有一个问题，你可以看

请注意，Quarkus不支持Groovy或Spock

作为替代，你也可以尝试，不知道它的状态是什么，我只是通过谷歌搜索找到它

关于你的问题：

仍然需要实体类，但正在创建EntityManagerFactory
处理完毕，数据源和EntityManger就可以注入，
对吧?

如果您正在使用Quarkus Hibernate ORM扩展，它是一个常规的Hibernate集成，因此是一个JPA实现，因此您需要定义JPA实体类。然后可以插入一个
EntityManager
。您还可以插入
数据源
，但最好使用
EntityManager
，因为它提供了更高级别的集成

我必须重写TestDB吗，还是有一个“开箱即用”的
解决方案我查看了Zero配置设置（DevServices），但是
不允许我配置数据库。我不想延长
springframework

如果您可以使用
@QuarkusTest
支持，它将启动您的应用程序，以便您可以使用H2或Derby之类的内存数据库。有通过Quarkus测试资源自动启动H2数据库的测试支持，请参阅Quarkus测试指南的一节，该节解释了如何通过
io.Quarkus.test.H2.H2 DatabaseTestResource启动H2数据库

Devservices也是一种很好的方法，它将在docker容器中运行一个真实的数据库，因此如果您没有配置任何数据源，而是使用Quarkus JDBC扩展之一（例如
Quarkus JDBC postgresql
），它将在该数据库的开发和测试中运行docker容器

T