Quakus以及如何实现内存、实体和DAO

Question

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

目前我有目前的结构：

• 信息类注册时间。爪哇

我的测试类注册了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，读到以下内容：

https://quarkus.io/guides/datasource

https://quarkus.io/guides/hibernate-orm（可能是最重要的一个）

https://quarkus.io/guides/getting-started（ofc）

https://quarkus.io/guides/gradle-tooling（使用gradle）

>

仍然需要一个实体类，但是EntityManagerFactory正在处理中，可以只注入数据源和EntityManger，对吗？

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

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

Answer 1

我猜你在用斯波克做测试。

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

Quarkus和斯波克的支持有问题，你可以看。

请注意，Quarkus不支持Groovy或Spock。

作为一种选择，你也可以尝试这个QuarkusSpock扩展，不知道它的状态是什么，我只是通过谷歌搜索找到它。

关于你的问题：

实体类仍然是必需的，但EntityManagerFactory正在被关闭，Datasource和EntityManger可以被注入，对吗？

如果您使用的是Quakus HiberNate ORM扩展，这是一个常规的HiberNate集成，所以是一个JPA实现，所以您需要定义JPA实体类。然后您可以注入一个EntityManager。您也可以注入一个Datassource，但是最好使用EntityManager，因为它提供了更高级别的集成。

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

如果您可以使用@aqukusTest支持，它将启动您的应用程序，以便您可以使用H2或Derby这样的内存数据库。有一个测试支持通过Quarkus测试资源自动启动H2数据库，请参阅Quarkus测试指南中的“Quarkus应用程序启动前启动服务”部分，该部分解释了如何通过io.quarkus.test.h2启动H2数据库。H2数据库测试资源。

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

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

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

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