Java数据审计工具：Envers and JaVers比较

在Java世界中，有两种数据审计工具：Envers和JaVers。 Envers已经存在了很长时间，它被认为是主流。 JaVers提供全新的方法和技术独立性。如果您考虑哪种工具更适合您的项目，本文是一个很好的起点。

本文分为三个部分。首先，是高层次的比较。在第二部分中，我将展示用于管理组织结构的简单演示应用程序 Javers和Envers进行的数据审计。在第三部分中，我将检查这两种工具如何应对对审计数据的查询。

当与Spring Data JPA集成时Javers，Envers都内不能记录JPQL、和本机SQL语句修改的数据，所以要尽量避免使用JPQL、和本机SQL语句修改数据（只查询数据没问题）；

当与Spring Data JPA集成时Javers默认就可以记录操作认证用户，Envers需要自己定制RevisionEntity、RevisionListener ；


 
@Data
@Entity
@RevisionEntity(UserRevisionListener.class)
public class UserRevEntity extends DefaultRevisionEntity {
 
    private String username;
 
}


public class UserRevisionListener implements RevisionListener {
 
    @Override
    public void newRevision(Object revisionEntity) {
        String username;
        if (SecurityContextHolder.getContext().getAuthentication() != null) {
            org.springframework.security.core.userdetails.User principal = (org.springframework.security.core.userdetails.User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            username = Optional.of(principal.getUsername()).orElse(null);
        } else {
            username = "unauthenticated";
        }
        UserRevEntity exampleRevEntity = (UserRevEntity) revisionEntity;
 
        exampleRevEntity.setUsername(username);
    }

高级比较

JaVers和Envers之间有两个很大的区别：

Envers是Hibernate插件。它与Hibernate有很好的集成，但你只能将它用于传统的SQL数据库。如果您选择了 NoSQL 数据库或 SQL，但使用了其他持久性框架（例如JOOQ） — Envers 不是一个选项。

相反，JaVers可以与任何类型的数据库和任何类型的持久性框架。目前，JaVers附带了MongoDB和流行的 SQL 数据库。将来可能会添加其他数据库（如Cassandra，Elastic）。
Envers的审计模型是面向表格的。您可以将 Envers 视为对数据库记录进行版本控制的工具。
正如文档所说：对于每个被审计的实体，都会创建一个审计表。缺省情况下，审计表名是通过在原始名称中添加_AUD后缀来创建的。这可能是一个优势，您可以将审计数据存储在实时数据附近。恩弗斯的桌子看起来很熟悉。使用 SQL 查询它们很容易。

JaVers的审计模型是面向对象的。这一切都与对象的快照有关。 JaVers 将它们保存到单个表（或 Mongo 中的集合）作为具有统一结构的 JSON 文档。优势？您可以专注于域对象并处理持久性和审核作为基础设施方面。由于审核数据与实时数据分离，因此您可以选择存储它们的位置。默认情况下，JaVers 会将快照保存到应用程序的数据库中，但您可以指向另一个快照。例如，SQL for Application 和 MongoDB for JaVers （甚至是为公司中的所有应用程序共享的集中式 JaVers 数据库）。

演示应用程序

我们的演示项目是基于Spring Boot的简单Groovy应用程序。从https://github.com/javers/javers-vs-envers 克隆它。

让我们从域模型开始。只有两个类：员工和地址。员工以树状结构进行组织。

Employee.groovy


@Entity
class Employee {
    @Id
    String name
 
    @ManyToOne
    Employee boss
 
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "boss")
    Set subordinates = new HashSet()
 
    @Embedded
    Address address
 
    Integer salary
    
    Position position
 
    Employee() {
    }
    
    ...
}

Address.groovy


@Embeddable
class Address {
    @Column(name = "address_city")
    String city
 
    @Column(name = "address_street")
    String street
 
    Address() {
    }
 
    Address(String city) {
        this.city = city
    }
}

数据库配置

该应用程序配置为与本地 PostgreSQL 一起使用。您可以轻松更改它（不要忘记合适的 JDBC 驱动程序）。

application.properties

spring.datasource.url=jdbc:postgresql://localhost:5432/javers-vs-envers

build.gradle

compile 'postgresql:postgresql:9.1-901-1.jdbc4'

要运行应用程序并填充数据库，请执行InitHierarchyTest.groovy测试：


def "should init and persist organization structure"(){
  given:
  def boss = hierarchyService.initStructure()
 
  boss.prettyPrint()
 
  expect:
  boss.name == "Gandalf"
}

您可以从命令行运行它：

./gradlew test --tests InitHierarchyTest

现在，您应该在表中填充了初始数据。Employee

select * from Employee

启用 Envers 审计

要启用 Envers，我们需要添加依赖项：hibernate-envers

compile 'org.hibernate:hibernate-envers:'+hibernateVersion

对我们实体的注释：@Audited


import org.hibernate.envers.Audited
 
@Entity
@Audited
class Employee {
    ...
}

就是这样。现在，我们可以做一些审核的更改：

SimpleChangeTest.groovy


def "should persist Employee's property change"(){
    given:
    def boss = hierarchyService.initStructure()
 
    hierarchyService.giveRaise(boss, 200)
 
    expect:
    hierarchyService.findByName("Gandalf").salary == 10200
}

Envers 创建两个表：和。revinfoemployee_aud

select * from revinfo

select * from employee_aud

到目前为止，这并不奇怪。我们有两个修订与审计表中的记录相关联。 Revtype 0 表示插入，1 表示更新。奇怪的是修订时间戳的类型。为什么是长而不是日期？幸运的是，您可以使用自定义修订实体进行修复。此外，修订实体是您可以挂钩修订元数据（如更改作者）的地方。

启用 JaVers 审核

要启用 JaVers，我们需要将此依赖项添加到 JaVers Spring Boot 启动器 for SQL 中：

compile 'org.javers:javers-spring-boot-starter-sql:6.8.0'

将JaVers与Spring应用程序
集成的最简单方法是将注释添加到Spring Data CRUD存储库中。此注释启用自动审核方面。@JaversSpringDataAuditable

EmployeeRepository.groovy


import org.javers.spring.annotation.JaversSpringDataAuditable
import org.springframework.data.repository.CrudRepository
 
@JaversSpringDataAuditable
interface EmployeeRepository extends CrudRepository {
}

就这样。现在，当您重新运行时， JaVers 将创建三个表：SimpleChangeTest

jv_commit,
jv_global_id,
jv_snapshot

（还有第四个表 — ，但我们的应用程序没有触及它）。jv_commit_property

JaVers'Commit 与 Envers'Revision 的概念类似（来自 Git 和 Subversion 的灵感是显而易见的）。每个提交都有时间戳和作者。在这里，作者字段未知，如果您启用 Spring 安全性，它将设置为当前用户（请参阅作者提供程序）。

select * from jv_commit

现在，让我们看看对象的快照是如何存储的。

在JaVers中，每个审核的对象都有GlobalId。对于实体，它是类型名称和本地 ID 对。 ValueObjects（如地址）被视为实体的组件，因此，它们由以下一对标识：拥有实体 GlobalId 和路径（通常是属性名称）。
到目前为止，我们有 18 个对象，因此存储了 18 个 GlobalId。

select * from jv_global_id

对于每个 GlobalId，JaVers 都会创建一个或多个对象的快照。到目前为止，我们只做了一个更改（甘道夫上升了），所以我们有 18 个初始快照以及甘道夫的一个更新快照。似乎没错。

select * from jv_snapshot

JaVers 与 Envers 的区别在于专栏，这里是实时快照本身。它是包含 JSON 文档的文本列。多亏了这一点，JaVers没有耦合到任何特定类型的数据库。只要数据库支持文本或 JSON 类型，就可以了。事实上，MongoDB对JaVers来说比SQL更自然。因为MongoDB旨在存储JSON文档。state

快照状态文档是映射，其中键是属性名称，值是，好吧，属性值（非常像Javascript）。对其他对象的引用将冻结并存储为 GlobalId。

比如，这是甘道夫的现状：


{
  "address": {
    "valueObject": "org.javers.organization.structure.Address",
    "ownerId": {
      "entity": "org.javers.organization.structure.Employee",
      "cdoId": "Gandalf"
    },
    "fragment": "address"
  },
  "name": "Gandalf",
  "position": "CEO",
  "salary": 10200,
  "subordinates": [
    {
      "entity": "org.javers.organization.structure.Employee",
      "cdoId": "Elrond"
    },
    {
      "entity": "org.javers.organization.structure.Employee",
      "cdoId": "Aragorn"
    }
  ]
}

查询竞赛

某些应用程序仅出于以防万一而实施了数据审核。例如，如果 IT 审计员意外和令人生畏地访问您询问问题。在此方案中，应用程序不需要具有任何用于浏览审核数据的特殊 UI。任何开发人员都可以直接连接到数据库，生成一些报告并让审计员满意。

在其他应用中，数据审计非常重要，以至于它成为提供给用户的功能之一。例如，维基百科具有页面历史记录视图，其中显示了对任何页面所做的更改。

我专注于第二种情况，我们的演示应用程序针对审计数据运行查询，以显示奖学金的历史记录。

按类型浏览对象历史记录

让我们从基本查询开始 — 按类型查询。我们正在为甘道夫和阿拉贡增加一个名字，我们也在改变他们的地址。这意味着四个变化。


given:
    def gandalf = hierarchyService.initStructure()
    def aragorn = gandalf.getSubordinate('Aragorn')
    gandalf.prettyPrint()
 
    //changes
    hierarchyService.giveRaise(gandalf, 200)
    hierarchyService.updateCity(gandalf, 'Shire')
    hierarchyService.giveRaise(aragorn, 100)
    hierarchyService.updateCity(aragorn, 'Shire')

然后我们想浏览我们在Envers和JaVers中员工的历史。

恩弗斯方式

EnversQueryTest.groovy#L27


@Transactional
def "should browse Envers history of objects by type"(){
  given:
    ...
 
  when:
    List folks = AuditReaderFactory
            .get(entityManager)
            .createQuery()
            .forRevisionsOfEntity( Employee, false, true )
            .add(AuditEntity.revisionType().eq(MOD)) // without initial versions
            .getResultList()
 
    println 'envers history of Employees:'
    folks.each {
        println 'revision:' + it[1].id + ', entity: '+ it[0]
    }
 
  then:
    folks.size() == 4
}

转换器输出：


envers history of Employees:
revision:33, entity: Employee{ Gandalf CEO, $10200, Middle-earth, subordinates:Aragorn,Elrond }
revision:34, entity: Employee{ Gandalf CEO, $10200, Shire, subordinates:Aragorn,Elrond }
revision:35, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates:Thorin }
revision:36, entity: Employee{ Aragorn CTO, $8100, Shire, subordinates:Thorin }

贾弗斯方式

JaversQueryTest.groovy#L23


def "should browse JaVers history of objects by type"(){
  given:
    ...
 
  when:
    List> shadows = javers.findShadows(
            QueryBuilder.byClass(Employee)
                        .withSnapshotTypeUpdate()
                        .build())
 
    println 'javers history of Employees:'
    shadows.each { shadow ->
        println 'commit:' + shadow.commitMetadata.id + ', entity: '+ shadow.get()
    }
 
  then:
    shadows.size() == 4
    shadows[0].commitMetadata.id.majorId == 5
    shadows[3].commitMetadata.id.majorId == 2
}

贾弗斯输出：


javers history of Employees:
commit:5.0, entity: Employee{ Aragorn CTO, $8100, Shire, subordinates:Thorin }
commit:4.0, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates:Thorin }
commit:3.0, entity: Employee{ Gandalf CEO, $10200, Shire, subordinates:Aragorn,Elrond }
commit:2.0, entity: Employee{ Gandalf CEO, $10200, Middle-earth, subordinates:Aragorn,Elrond }

比较

这两个工具都完成了这项工作并显示了正确的历史记录。这两个工具都加载了相关实体。

艺术印象呢？有一些有趣的区别。

Envers 查询结果按时间顺序排序。最早的更改位于列表的第一个。浏览历史记录时，通常您希望先查看最新更改。反向时间顺序更自然，这就是Javers的排序方式。我没有在 Envers 中找到反向排序的方法(注：Envers 可以反向排序 AuditQuery query = reader.createQuery()
.forRevisionsOfEntity(User.class, false, true)
.addOrder(AuditEntity.revisionNumber().desc());
)。
JaVers 查询 API 似乎更优雅。它被称为JQL（JaVers Query Language）。
Envers的查询中真正神秘的是结果类型。为什么返回非参数化列表？什么清单？好吧，这取决于第二个标志传到命名。如果为 true，它将是一个实体列表，否则是三元素数组的列表，包含：实体实例、修订实体和修订类型。不酷。在Groovy中这不是问题，但在Java中，你必须大量投射才能获得数据。在 JaVers 中，您可以获得类型安全的阴影列表。简而言之，Shadow 是一对历史实体和提交元数据。getResultList()forRevisionsOfEntity()selectEntitiesOnly
两个工具都加载了相关实体（下属和老板），虽然我们没有要求这个。 Envers使用众所周知的Hibernate延迟加载方法。相反，JaVers 总是急切地加载数据基于查询范围。这两种方法都有优点和缺点。延迟加载看起来很吸引人，您可以根据需要获得尽可能多的数据而不会打扰关于基础数据库查询。缺点是持续的威胁。此外，Hibernate动态代理和持久集合使您的对象图混乱。LazyInitializationException

查询筛选器

如果没有搜索过滤器，浏览对象历史记录不是很有用。

在下一个示例中，我们将展示如何实现两种常见的搜索用例：

按 ID 搜索，以显示指定员工的历史记录。
按更改的属性搜索，以显示整个组织中的工资变化历史记录。

恩弗斯方式

EnversQueryTest.groovy#L57


@Transactional
def "should browse Envers history of objects by type with filters"(){
  given:
    def gandalf = hierarchyService.initStructure()
    def aragorn = gandalf.getSubordinate('Aragorn')
    def thorin = aragorn.getSubordinate('Thorin')
 
    //changes
    [gandalf, aragorn, thorin].each {
        hierarchyService.giveRaise(it, 100)
        hierarchyService.updateCity(it, 'Shire')
    }
 
  when: 'query with Id filter'
    List aragorns = AuditReaderFactory
          .get(entityManager)
          .createQuery()
          .forRevisionsOfEntity( Employee, false, true )
          .add(AuditEntity.id().eq( 'Aragorn' ))
          .getResultList()
 
  then:
    println 'envers history of Aragorn:'
    aragorns.each {
        println 'revision:' + it[1].id + ', entity: '+ it[0]
    }
    aragorns.size() == 3
 
  when: 'query with Property filter'
  List folks = AuditReaderFactory
          .get(entityManager)
          .createQuery()
          .forRevisionsOfEntity( Employee, false, true )
          .add(AuditEntity.property('salary').hasChanged())
          .add(AuditEntity.revisionType().eq(MOD))
          .getResultList()
 
  then:
    println 'envers history of salary changes:'
    folks.each {
        println 'revision:' + it[1].id + ', entity: '+ it[0]
    }
    folks.size() == 3
}

我们的查询没有太大变化。要按 ID 搜索，我们使用：

.add(AuditEntity.id().eq( 'Aragorn' ))

为了按更改的属性进行搜索，我们添加了：

.add(AuditEntity.property('salary').hasChanged())

看起来不错，但是运行此测试时会发生什么？哎呦！第二个查询引发异常：

org.hibernate.QueryException: could not resolve property: salary_MOD of: org.javers.organization.structure.Employee_AUD [select e__, r from org.javers.organization.structure.Employee_AUD e__, org.hibernate.envers.DefaultRevisionEntity r where e__.salary_MOD = :_p0 and e__.REVTYPE = :_p1 and e__.originalId.REV.id = r.id order by e__.originalId.REV.id asc]

看起来表中缺少一列。但是这个表是由Envers管理的，为什么他在自己的表格中找不到列？salary_MODemployee_AUD

在用户指南中进行一些挖掘后，我们可以找到答案——修改标志。如果我们想按更改的属性进行查询，我们需要为我们的类启用它们：


@Entity
@Audited( withModifiedFlag=true )
class Employee {
    ...

然后，Envers 将布尔矩阵添加到表中：employee_AUD

当我们看到这些标志时，它们变得很明显。 Envers 使用它们来查找对给定属性进行更改的记录。

现在，Envers 输出似乎是正确的：


envers history of Aragorn:
revision:6554, entity: Employee{ Aragorn CTO, $8000, Minas Tirith, subordinates:'Thorin' }
revision:6557, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates:'Thorin' }
revision:6558, entity: Employee{ Aragorn CTO, $8100, Shire, subordinates:'Thorin' }
 
envers history of salary changes:
revision:6555, entity: Employee{ Gandalf CEO, $10100, Middle-earth, subordinates:'Aragorn','Elrond' }
revision:6557, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates:'Thorin' }
revision:6559, entity: Employee{ Thorin TEAM_LEAD, $5100, Lonely Mountain, subordinates:'Bombur','Frodo','Fili','Kili','Bifur' }

相反，JaVers 查询开箱即用。

贾弗斯方式

JaversQueryTest.groovy#L52


def "should browse JaVers history of objects by type with filters"(){
  given:
    def gandalf = hierarchyService.initStructure()
    def aragorn = gandalf.getSubordinate('Aragorn')
    def thorin = aragorn.getSubordinate('Thorin')
 
    //changes
    [gandalf, aragorn, thorin].each {
        hierarchyService.giveRaise(it, 100)
        hierarchyService.updateCity(it, 'Shire')
    }
 
  when: 'query with Id filter'
    List> shadows = javers.findShadows(
            QueryBuilder.byInstanceId('Aragorn', Employee).build())
 
  then:
    println 'javers history of Aragorn:'
    shadows.each { shadow ->
      println 'commit:' + shadow.commitMetadata.id + ', entity: '+ shadow.get()
    }
    shadows.size() == 3
 
  when: 'query with Property filter'
    shadows = javers.findShadows(
            QueryBuilder.byClass(Employee)
                        .withChangedProperty('salary')
                        .withSnapshotTypeUpdate()
                        .build())
 
  then:
    println 'javers history of salary changes:'
    shadows.each { shadow ->
        println 'commit:' + shadow.commitMetadata.id + ', entity: '+ shadow.get()
    }
    shadows.size() == 3
}

贾弗斯输出：


javers history of Aragorn:
commit:5.1, entity: Employee{ Aragorn CTO, $8100, Shire, subordinates: }
commit:4.1, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates: }
commit:1.1, entity: Employee{ Aragorn CTO, $8000, Minas Tirith, subordinates: }
 
javers history of salary changes:
commit:6.0, entity: Employee{ Thorin TEAM_LEAD, $5100, Lonely Mountain, subordinates: }
commit:4.1, entity: Employee{ Aragorn CTO, $8100, Minas Tirith, subordinates: }
commit:2.1, entity: Employee{ Gandalf CEO, $10100, Middle-earth, subordinates: }

比较

这两个工具再次完成了这项工作并显示了正确的历史记录。

按 ID 搜索。只是按预期工作。
按更改的属性搜索。在这里，一开始，Envers 抛出了一个例外，我们不得不添加表架构的修改标志。我喜欢这些标志的设计，因为它很简单。问题是默认情况下它们是禁用的。
如果您的应用程序在生产环境中运行了一段时间，该怎么办而且您从一开始就没有启用标志？将它们添加到现有表中可能会很痛苦...
我认为Javers以更优雅的方式解决了这个问题。默认情况下，每个快照都包含已更改属性名称（in）的列表。快照结构是固定的，不再纠结于标志配置。jv_snapshot.changed_properties

重建完整的对象图

最后一项任务是竞争中最困难的部分。我们想要重建给定时间点的完整对象图。这意味着时间感知型联接很棘手。

在此用例中，我们加载一个员工的历史版本我们检查相关员工是否以正确的版本加入。

为了使案件更难（也更现实），我们独立更新员工。我们希望从Javers和Envers那里得到的是回忆那个特定的时间点。当所有的人都有相同的薪水时——6000 美元。


given:
    def gandalf = hierarchyService.initStructure()
    def aragorn = gandalf.getSubordinate('Aragorn')
    def thorin = aragorn.getSubordinate('Thorin')
    def bombur = thorin.getSubordinate("Bombur")
    
    [gandalf,aragorn, bombur].each {
      hierarchyService.updateSalary(it, 6000)
    }
    
    hierarchyService.giveRaise(thorin, 1000)
    //this state we want to reconstruct,
    //when all the four guys have salary $6000
    gandalf.prettyPrint()
    
    [gandalf, aragorn, thorin, bombur].each {
      hierarchyService.giveRaise(it, 500)
    }

让我们从Envers开始挑战。

恩弗斯方式

EnversQueryTest.groovy#L102


@Transactional
def "should reconstruct a full object graph with Envers"(){
  given:
  ...
 
  when:
    def start = System.currentTimeMillis()
    List thorins = AuditReaderFactory
          .get(entityManager)
          .createQuery()
          .forRevisionsOfEntity( Employee, false, true )
          .add( AuditEntity.id().eq( 'Thorin' ) )
          .getResultList()
 
  then:
    def thorinShadow = thorins.collect{it[0]}.find{it.salary == 6000}
 
    [thorinShadow,
     thorinShadow.getBoss(),
     thorinShadow.getBoss().getBoss(),
     thorinShadow.getSubordinate("Bombur")].each
    {
        println it
        assert it.salary == 6000
    }
    println "Envers query executed in " + (System.currentTimeMillis() - start) + " millis"
}

转换器输出：


Employee{ Thorin TEAM_LEAD, $6000, Lonely Mountain, subordinates:'Bombur','Frodo','Fili','Kili','Bifur' }
Employee{ Aragorn CTO, $6000, Minas Tirith, subordinates:'Thorin' }
Employee{ Gandalf CEO, $6000, Middle-earth, subordinates:'Aragorn','Elrond' }
Employee{ Bombur SCRUM_MASTER, $6000, Lonely Mountain, subordinates: }
Envers query executed in 47 millis

贾弗斯方式

JaversQueryTest.groovy#L90


def "should reconstruct a full object graph with JaVers"(){
  given:
    ... 
 
  when:
    def start = System.currentTimeMillis()
    List> shadows = javers.findShadows(
            QueryBuilder.byInstanceId('Thorin', Employee)
                        .withScopeDeepPlus()
                        .build())
 
  then:
    def thorinShadow = shadows.collect{it.get()}.find{it.salary == 6000}
    [thorinShadow,
     thorinShadow.getBoss(),
     thorinShadow.getBoss().getBoss(),
     thorinShadow.getSubordinate("Bombur")].each
    {
        println it
        assert it.salary == 6000
    }
    println "JaVers query executed in " + (System.currentTimeMillis() - start) + " millis"
}

贾弗斯输出：


Employee{ Thorin TEAM_LEAD, $6000, Lonely Mountain, subordinates:'Bombur','Frodo','Fili','Kili','Bifur' }
Employee{ Aragorn CTO, $6000, Minas Tirith, subordinates:'Thorin' }
Employee{ Gandalf CEO, $6000, Middle-earth, subordinates:'Aragorn','Elrond' }
Employee{ Bombur SCRUM_MASTER, $6000, Lonely Mountain, subordinates: }
JaVers query executed in 48 millis

比较

这两个工具都成功地重建了正确的对象图。索林的版本与正确的阿拉贡版本，与正确的
甘道夫版本相连。信不信由你，这种重建并非微不足道因为它是在不知道时间维度的普通 SQL 数据库之上实现的。

性能基准超出了本文的范围。当您尝试在生产数据库上重建大型对象图时，您可能会在 JaVers 和 Envers 中面临性能问题。

在 JaVers 中，您可以启用一个简单的探查器工具，该工具记录查询执行统计信息到标准记录器：slf4j

然后，可以分析 JQL 查询执行中的日志：


[main] org.javers.core.Javers  : Commit(id:6.1, snapshots:1, author:unknown, changes - ValueChange:1), done in 68 millis (diff:64, persist:4)
[main] org.javers.core.Javers  : Commit(id:7.1, snapshots:1, author:unknown, changes - ValueChange:1), done in 54 millis (diff:52, persist:2)
[main] org.javers.core.Javers  : Commit(id:8.0, snapshots:1, author:unknown, changes - ValueChange:1), done in 66 millis (diff:64, persist:2)
[main] org.javers.core.Javers  : Commit(id:9.0, snapshots:1, author:unknown, changes - ValueChange:1), done in 62 millis (diff:57, persist:5)
[main] org.javers.JQL          : SHALLOW query: 4 snapshots loaded (entities: 3, valueObjects: 1)
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Aragorn' at commitId 8.0, 4 snapshot(s) loaded, gaps filled so far: 1
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Gandalf' at commitId 8.0, 4 snapshot(s) loaded, gaps filled so far: 2
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Elrond' at commitId 8.0, 2 snapshot(s) loaded, gaps filled so far: 3
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Frodo' at commitId 8.0, 2 snapshot(s) loaded, gaps filled so far: 4
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Kili' at commitId 8.0, 2 snapshot(s) loaded, gaps filled so far: 5
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Fili' at commitId 8.0, 2 snapshot(s) loaded, gaps filled so far: 6
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Bifur' at commitId 8.0, 2 snapshot(s) loaded, gaps filled so far: 7
[main] org.javers.JQL          : DEEP_PLUS query for '...Employee/Bombur' at commitId 8.0, 3 snapshot(s) loaded, gaps filled so far: 8
[main] org.javers.JQL          : queryForShadows executed: 
JqlQuery {
  IdFilter{ globalId: ...Employee/Thorin }
  QueryParams{ aggregate: true, limit: 100 }
  ShadowScopeDefinition{ shadowScope: DEEP_PLUS, maxGapsToFill: 10 }
  Stats{  
    executed in millis: 36  
    DB queries: 9  
    all snapshots: 25  
    SHALLOW snapshots: 4  
    DEEP_PLUS snapshots: 21  
    gaps filled: 8  
  }
}

经验法则 — 尽量保持每个 JQL 查询执行的数据库查询数尽可能小。使用正确的影子范围（阅读有关范围的更多信息）。

其他查询类型

Envers 只有一种类型的查询结果 — 对象的历史版本，这是对象历史的最自然视图。

在JaVers中，这种查询类型称为影子查询（这就是我们在查询示例中使用的原因）。除此之外，JaVers 还提供了另外两种查询类型：快照查询和更改查询。findShadows()

快照包含与阴影相同的数据，但它们已冻结。什么意思？

快照是 JaVers 类的一个实例，而影子只是用户域类的一个实例。CdoSnapshot
快照是独立的，可以轻松地序列化/反序列化为 JSON 并通过网络发送。例如，当您为前端应用程序构建 REST API 时，快照可能很有用（请参阅我们如何在JaVers GUI 的 POC 中使用快照）。

更改是将对象历史记录呈现为统一更改日志的最佳选择。 JaVers 提供了格式化程序，它创建的文本更改日志如下所示：SimpleTextChangeLog


commit 3.0, author: hr.manager, 2015-04-16 22:16:50
  changed object: Employee/Bob
    list changed on 'subordinates' property: [(0).added:'Employee/Trainee One', (1).added:'Employee/Trainee Two']
commit 2.0, author: hr.director, 2015-04-16 22:16:50
  changed object: Employee/Bob
    value changed on 'position' property: 'Scrum master' -> 'Team Lead'
    value changed on 'salary' property: '9000' -> '11000'

实现自己的更改日志格式化程序很容易（请参阅示例）。

结语

那么哪种工具更好呢？

作为Javers的作者，我在回答这个问题时不能客观（你可以很容易地猜到我的意见）。事实上，本文的目的是提供Javers和Envers的公平比较。这为您提供了足够的信息来做出有意识的决定。

相关阅读:
微信小程序查看官方样式及修改checkbox样式为圆圈
 动态规划12（Leetcode221最大正方形）
Android 12.0系统申请动态权限之高德定位
 Vue框架的学习(Vue的基础指令操作二 V-For)第二课
 单调队列-滑动窗口
 C语言--每日五道选择题-- Day22
40个Linux常用命令组合
 一些java笔试题解
 Java描述 LeetCode，572. 另一棵树的子树，欧拉筛选法
 《C和指针》笔记22: 指针初始化和NULL指针
原文地址：https://blog.csdn.net/allway2/article/details/128090900

Java数据审计工具：Envers and JaVers比较

高级比较

演示应用程序

数据库配置

启用 Envers 审计

启用 JaVers 审核

查询竞赛

按类型浏览对象历史记录

查询筛选器

更多查询筛选器

重建完整的对象图

其他查询类型

结语