javax.validation.ValidationException: HV000183: 无法加载 'javax.el.ExpressionFactory'

Question

我尝试用休眠验证器编写非常简单的应用程序：

我的步骤：

在 pom.xml 中添加了以下依赖项：

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.1.1.Final</version>
</dependency>

写了以下代码：

class Configuration {
    Range(min=1,max=100)
    int threadNumber;
    //...
    
    public static void main(String[] args) {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();

        Validator validator = factory.getValidator();
        
        Configuration configuration = new Configuration();
        configuration.threadNumber = 12;
            //...
        
        Set<ConstraintViolation<Configuration>> constraintViolations = validator.validate(configuration);
        System.out.println(constraintViolations);

    }
}

我得到以下堆栈跟踪：

Exception in thread "main" javax.validation.ValidationException: Unable to instantiate Configuration.
    at javax.validation.Validation$GenericBootstrapImpl.configure(Validation.java:279)
    at javax.validation.Validation.buildDefaultValidatorFactory(Validation.java:110)
    ...
    at org.hibernate.validator.internal.engine.ConfigurationImpl.<init>(ConfigurationImpl.java:110)
    at org.hibernate.validator.internal.engine.ConfigurationImpl.<init>(ConfigurationImpl.java:86)
    at org.hibernate.validator.HibernateValidator.createGenericConfiguration(HibernateValidator.java:41)
    at javax.validation.Validation$GenericBootstrapImpl.configure(Validation.java:276)
    ... 2 more

我做错了什么？

Answer 1

添加到pom.xml以下依赖项后，它正在工作：

<dependency>
   <groupId>javax.el</groupId>
   <artifactId>javax.el-api</artifactId>
   <version>2.2.4</version>
</dependency>
<dependency>
   <groupId>org.glassfish.web</groupId>
   <artifactId>javax.el</artifactId>
   <version>2.2.4</version>
</dependency>

Hibernate Validator 入门：

Hibernate Validator 还需要统一表达式语言 ( JSR 341 ) 的实现来评估约束违反消息中的动态表达式。 当您的应用程序在 Java EE 容器（例如WildFly ）中运行时，容器已经提供了 EL 实现。 但是，在 Java SE 环境中，您必须将实现作为依赖项添加到 POM 文件中。 例如，您可以添加以下两个依赖项以使用 JSR 341参考实现：

 <dependency> <groupId>javax.el</groupId> <artifactId>javax.el-api</artifactId> <version>2.2.4</version> </dependency> <dependency> <groupId>org.glassfish.web</groupId> <artifactId>javax.el</artifactId> <version>2.2.4</version> </dependency>

Answer 2

只做

<dependency>
   <groupId>javax.el</groupId>
   <artifactId>javax.el-api</artifactId>
   <version>2.2.4</version>
</dependency>

Answer 3

如果您不需要javax.el （例如在 JavaSE 应用程序中），请使用Hibernate validator 中的ParameterMessageInterpolator 。 Hibernate 验证器是一个独立的组件，它可以在没有Hibernate本身的情况下使用。

依赖休眠验证器

<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-validator</artifactId>
   <version>6.0.16.Final</version>
</dependency>

使用 ParameterMessageInterpolator

import javax.validation.Validation;
import javax.validation.Validator;
import org.hibernate.validator.messageinterpolation.ParameterMessageInterpolator;

private static final Validator VALIDATOR =
  Validation.byDefaultProvider()
    .configure()
    .messageInterpolator(new ParameterMessageInterpolator())
    .buildValidatorFactory()
    .getValidator();

Answer 4

如果您使用 tomcat 作为服务器运行时并且在测试中遇到此错误（因为在测试期间 tomcat 运行时不可用），那么包含 tomcat el 运行时而不是 glassfish 中的运行时是有意义的）。 这将是：

    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-el-api</artifactId>
        <version>8.5.14</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>tomcat-jasper-el</artifactId>
        <version>8.5.14</version>
        <scope>test</scope>
    </dependency>

Answer 5

如果您将 spring boot 与 starters 一起使用 - 此依赖项会同时添加tomcat-embed-el和hibernate-validator依赖项：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Answer 6

关于Hibernate 验证器文档页面，您必须定义对JSR-341实现的依赖：

<dependency>
   <groupId>org.glassfish</groupId>
   <artifactId>javax.el</artifactId>
   <version>3.0.1-b11</version>
</dependency>

Answer 7

Hibernate Validator 需要——但不包括——表达式语言 (EL)实现。 添加对一个的依赖将解决这个问题。

<dependency>
   <groupId>org.glassfish</groupId>
   <artifactId>jakarta.el</artifactId>
   <version>3.0.3</version>
</dependency>

此要求记录在Hibernate Validator 入门文档中。 在 Java EE 环境中，它将由容器提供。 在像您这样的独立应用程序中，需要提供它。

Hibernate Validator 还需要统一表达式语言 ( JSR 341 ) 的实现来评估约束违反消息中的动态表达式。

当您的应用程序在 Java EE 容器（例如WildFly ）中运行时，容器已经提供了 EL 实现。

但是，在 Java SE 环境中，您必须将实现作为依赖项添加到 POM 文件中。 例如，您可以添加以下依赖项以使用 JSR 341 参考实现：

 <dependency> <groupId>org.glassfish</groupId> <artifactId>jakarta.el</artifactId> <version>${version.jakarta.el-api}</version> </dependency>

表达式语言实现

存在几种 EL 实现。 一种是文档中提到的 Jakarta EE Glassfish参考实现。 另一个是嵌入式Tomcat ，当前版本的Spring Boot默认使用它。 该版本的 EL 可以按如下方式使用：

<dependency>
   <groupId>org.apache.tomcat.embed</groupId>
   <artifactId>tomcat-embed-el</artifactId>
   <version>9.0.48</version>
</dependency>

如本评论中所述，必须选择表达式语言的兼容版本。 Glassfish 实现被指定为 Hibernate Validator 提供的-scope 依赖项，因此那里指定的版本应该可以正常工作。 特别是， Hibernate Validator 7使用 Glassfish EL 实现的第 4 版，而Hibernate 6使用第 3 版。

弹簧靴

在 Spring Boot 项目中，通常会使用spring-boot-starter-validation依赖项，而不是直接指定 Hibernate 验证器和 EL 库。 该依赖项包括org.hibernate.validator:hibernate-validator和tomcat-embed-el 。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
    <version>2.4.3.RELEASE</version>
</dependency>

Answer 8

如果使用 Spring Boot，这很有效。 即使使用 Spring Reactive Mongo。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

和验证配置：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.mapping.event.ValidatingMongoEventListener;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

@Configuration
public class MongoValidationConfig {

    @Bean
    public ValidatingMongoEventListener validatingMongoEventListener() {
        return new ValidatingMongoEventListener(validator());
    }

    @Bean
    public LocalValidatorFactoryBean validator() {
        return new LocalValidatorFactoryBean();
    }
}

Answer 9

对于 sbt，请使用以下版本

val glassfishEl = "org.glassfish" % "javax.el" % "3.0.1-b09"

val hibernateValidator = "org.hibernate.validator" % "hibernate-validator" % "6.0.17.Final"

val hibernateValidatorCdi = "org.hibernate.validator" % "hibernate-validator-cdi" % "6.0.17.Final"

Answer 10

雅加达命名空间

作为从Oracle向Eclipse Foundation移交的一部分， Java EE被重命名为Jakarta EE 。 在 Jakarta EE 9 中，Java 包名称从javax.*更改为jakarta.* 。

关于雅加达，贾斯汀先生的回答是正确的。 我添加了这个答案来提供更多的解释和具体的例子。

接口与实现

Jakarta Bean Validation是 Java 中的 API 规范。 此规范的二进制库仅包含接口，而不包含可执行代码。 所以我们还需要这些接口的实现。

我只知道Jakarta Bean Validation版本 2 和 3 规范的一种实现： Hibernate Validator版本 6 和 7（分别）。

桌面和控制台应用程序

对于 Web 应用程序，符合 Jakarta 标准的 Web 容器将提供执行 Bean 验证所需的接口和实现。

对于桌面和控制台应用程序，我们没有这样的符合 Jakarta 标准的 Web 容器。 因此，您必须将接口jar和实现 jar 与您的应用程序捆绑在一起。

您可以使用依赖管理工具（例如Maven 、 Gradle或Ivy ）来下载和捆绑接口和实现 jar。

雅加达表达语言

要运行Jakarta Bean Validation ，我们还需要另一个 Jakarta 工具： Jakarta Expression Language ，一种用于嵌入和评估表达式的专用编程语言。 Jakarta Expression Language也简称为EL 。

Jakarta 表达式语言由 Jakarta EE 定义为一种规范，您必须为其下载接口 jar。 并且您还需要在另一个 jar 中获取这些接口的实现。

您可以选择实现。 截至 2021 年 3 月，我知道 Eclipse 基金会的Eclipse Glassfish提供了一个作为单独库的实现，我们可以免费下载。 可能还有其他实现，例如 IBM Corporation 的Open Liberty 。 货比三家，寻找适合您需求的实现。

Maven POM 依赖

将所有这些信息放在一起，您需要四个 jar： Jakarta Bean Validation和Jakarta Expression Language两个项目中的每一个的一对接口和实现 jar。

• Jakarta Bean 验证
  • 界面
  • 执行
• 雅加达表达语言
  • 界面
  • 执行

以下是您需要添加到 Maven POM 文件的四个依赖项，如果 Maven 是您选择的工具。

如上所述，您可以找到另一种 EL 实现来替代我在这里使用的 Glassfish 库。

<!--********| Jakarta Bean Validation  |********-->

<!-- Interface -->

<!-- https://mvnrepository.com/artifact/jakarta.validation/jakarta.validation-api -->
<dependency>
    <groupId>jakarta.validation</groupId>
    <artifactId>jakarta.validation-api</artifactId>
    <version>3.0.0</version>
</dependency>

<!-- Implementation -->

<!-- https://mvnrepository.com/artifact/org.hibernate.validator/hibernate-validator -->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>7.0.1.Final</version>
</dependency>

<!-- Jakarta Expression Language -->

<!-- Interface -->

<!-- https://mvnrepository.com/artifact/jakarta.el/jakarta.el-api -->
<dependency>
    <groupId>jakarta.el</groupId>
    <artifactId>jakarta.el-api</artifactId>
    <version>4.0.0</version>
</dependency>

<!-- Implementation -->

<!-- https://mvnrepository.com/artifact/org.glassfish/jakarta.el -->
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.el</artifactId>
    <version>4.0.1</version>
</dependency>

这应该消除javax.validation.ValidationException: HV000183: Unable to load 'javax.el.ExpressionFactory'错误。

示例用法

您可以使用以下简单类Car测试您的设置。 我们对三个成员字段中的每一个都进行了验证。

package work.basil.example.beanval;

import jakarta.validation.constraints.*;

public class Car
{
    // ---------------|  Member fields  |----------------------------
    @NotNull
    private String manufacturer;

    @NotNull
    @Size ( min = 2, max = 14 )
    private String licensePlate;

    @Min ( 2 )
    private int seatCount;

    // ---------------|  Constructors  |----------------------------
    public Car ( String manufacturer , String licensePlate , int seatCount )
    {
        this.manufacturer = manufacturer;
        this.licensePlate = licensePlate;
        this.seatCount = seatCount;
    }

    // ---------------|  Object overrides  |----------------------------

    @Override
    public String toString ( )
    {
        return "Car{ " +
                "manufacturer='" + manufacturer + '\'' +
                " | licensePlate='" + licensePlate + '\'' +
                " | seatCount=" + seatCount +
                " }";
    }
}

或者，如果使用 Java 16 及更高版本，请改用更简短的record 。

package work.basil.example.beanval;

import jakarta.validation.constraints.*;

public record Car (
        @NotNull
        String manufacturer ,
        @NotNull
        @Size ( min = 2, max = 14 )
        String licensePlate ,
        @Min ( 2 )
        int seatCount
)
{
}

运行验证。 首先，我们使用成功配置的Car对象运行。 然后我们实例化第二个有问题的Car对象，违反了对三个字段中的每一个的一个约束。

package work.basil.example.beanval;

import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;

import java.util.Set;

public class App
{
    public static void main ( String[] args )
    {
        App app = new App();
        app.demo();
    }

    private void demo ( )
    {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();

        // No violations.
        {
            Car car = new Car( "Honda" , "ABC-789" , 4 );
            System.out.println( "car = " + car );

            Set < ConstraintViolation < Car > > violations = validator.validate( car );
            System.out.format( "INFO - Found %d violations.\n" , violations.size() );
        }

        // 3 violations.
        {
            Car car = new Car( null , "X" , 1 );
            System.out.println( "car = " + car );

            Set < ConstraintViolation < Car > > violations = validator.validate( car );
            System.out.format( "INFO - Found %d violations.\n" , violations.size() );
            violations.forEach( carConstraintViolation -> System.out.println( carConstraintViolation.getMessage() ) );
        }
    }
}

跑的时候。

car = Car{ manufacturer='Honda' | licensePlate='ABC-789' | seatCount=4 }
INFO - Found 0 violations.
car = Car{ manufacturer='null' | licensePlate='X' | seatCount=1 }
INFO - Found 3 violations.
must be greater than or equal to 2
must not be null
size must be between 2 and 14

Answer 11

对于 gradle ：

compile 'javax.el:javax.el-api:2.2.4'

Answer 12

我遇到了同样的问题，上面的答案没有帮助。 我需要调试并找到它。

 <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-common</artifactId>
        <version>2.6.0-cdh5.13.1</version>
        <exclusions>
            <exclusion>
                <artifactId>jsp-api</artifactId>
                <groupId>javax.servlet.jsp</groupId>
            </exclusion>
        </exclusions>
    </dependency>

排除jsp-api后，它对我有用。

Answer 13

对于使用 Hibernate Validator 7 (org.hibernate.validator:hibernate-validator:7.0.0.Final) 作为 Jakarta Bean Validation 3.0 实现的任何人都应该使用依赖项：

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.el</artifactId>
    <version>4.0.0</version>
</dependency>

如Hibernate Validator 文档中所述

Answer 14

我被旧技术困住了，所以我不得不添加以下内容：

    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>javax.el-api</artifactId>
        <version>3.0.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.glassfish</groupId>
        <artifactId>javax.el</artifactId>
        <version>3.0.0</version>
        <scope>test</scope>
    </dependency>

其他答案报告了相同的依赖关系，我只更新了版本。

Answer 15

如果您的服务器是 websphere 并且您使用spring-boot-starter-validation ，请排除tomcat-embed-el 。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>

    <exclusions>
         <exclusion>
              <groupId>org.apache.tomcat.embed</groupId>
              <artifactId>tomcat-embed-el</artifactId>
         </exclusion>
    </exclusions>
</dependency>