Java 使用AclPermissionEvaluator的Spring引导导致IllegalStateException:未设置ServletContext

各位专家您好，

我目前正在学习SpringBoot，我想将它与SpringSecurityACL一起使用。 继Spring Security的介绍和关于的教程之后，我想我已经了解了需要什么。我也调查了这件事。我在寻找解决方案时偶然发现了另一个

基于这些信息，我构建了我的应用程序。作为参考，您可以在上找到当前应用程序

当前问题 当我启动应用程序时，我得到一个

java.lang.IllegalStateException:No ServletContext集

抛出。据我所知，这是因为在Spring Boot的自动配置魔法期间，我的

@Configuration

注释类在

ServletContext

初始化之前就被初始化了

链接到上的完整堆栈跟踪

到目前为止我做了什么 基于我的研究（主要是关于StackOverflow）和我目前对该问题的理解，将负责的

Bean

s放入自己的

@配置

注释类应该会有所帮助。不幸的是，我现在迷路了。 相关的问题让我产生了这样的想法（参见，或）

我的环境

• macOS 10.12.6
• jdk1.8.0_144
• IntelliJ IDEA 2017.3.3（最终版）
• 弹簧靴v1.5.9.1版本

相关项目文件 pom.xml

4.0.0
德莫里茨鲁普
贸易的
0.0.1-快照
罐子
交易员日记
Trader日记是一个易于使用的web应用程序，用于创建日记
关于你的交易，上面有很好的报道。
GNU通用公共许可证（GPL）v3.0
https://www.gnu.org/licenses/gpl-3.0.txt
莫里茨鲁普
莫里茨·鲁普
莫里茨。rupp@gmail.com
https://www.moritzrupp.de
判定元件
org.springframework.boot
spring启动程序父级
1.5.9.1发布
UTF-8
UTF-8
1.8
org.springframework.boot
spring引导启动器数据jpa
org.springframework.boot
弹簧启动启动器数据rest
org.springframework.data
spring数据浏览器
org.springframework.boot
弹簧靴启动器hateoas
org.springframework.boot
弹簧启动安全
org.springframework.security
spring安全acl
org.springframework.security
spring安全配置
org.springframework
spring上下文支持
net.sf.ehcache
ehcache内核
2.6.11
org.springframework.boot
弹簧靴开发工具
运行时
符合事实的
com.h2数据库
氢
org.projectlombok
龙目
符合事实的
org.springframework.boot
弹簧起动试验
测验
org.springframework.restdocs
SpringRestMVC
测验
org.springframework.security
弹簧安全性试验
测验
org.springframework.boot
springbootmaven插件

应用程序属性

#--------------------------------------------
#数据源属性
# --------------------------------------------
spring.h2.console.enabled=true
spring.h2.console.path=/h2
spring.datasource.url=jdbc:h2:mem:trader-diary-h2-db
spring.datasource.platform=h2
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.driver类名=org.h2.driver
spring.jpa.hibernate.ddl auto=validate
spring.jpa.properties.hibernate.dialogue=org.hibernate.dialogue.h2dialogue

TraderDiaryApplication.java

@springboot应用程序
公共类TraderAryApplication{
公共静态void main（字符串[]args）{
run（TraderDiaryApplication.class，args）；
}
}

DataSourceConfig.java

@配置
公共类数据源配置{
@豆子
公共数据源交易数据源（数据源属性
数据源（属性）{
返回dataSourceProperties.initializeDataSourceBuilder（）.build（）；
}
}

WebSecurityConfig.java

@配置
@EnableGlobalMethodSecurity（Prespenabled=true，securedEnabled=true）
公共类WebSecurityConfig扩展了WebSecurityConfigureAdapter{
@自动连线
@限定符（“TraderAryDataSource”）
私有数据源；
@凌驾
受保护的无效配置（HttpSecurity http）引发异常{
//我认为这与问题无关，参见GitHub回购协议
...
}
@豆子
公共密码编码器PasswordEncoder（）{
//我认为这与问题无关，参见GitHub回购协议
...
}
@豆子
公共DaoAuthenticationProvider DaoAuthenticationProvider（…）{
//我认为这与问题无关，参见GitHub回购协议
...
}
@豆子
public MethodSecurityExpressionHandler aclExpressionHandler（）{
DefaultMethodSecurityExpressionHandler expressionHandler=
新的DefaultMethodSecurityExpressionHandler（）；
AclPermissionCacheOptimizer permissionCacheOptimizer=
新的AclPermissionCacheOptimizer（aclService（））；
setPermissionEvaluator（permissionEvaluator（））；
表达式处理程序
.setPermissionCacheOptimizer（permissionCacheOptimizer）；
返回表达式处理程序；
}
@豆子
公共许可评估器许可评估器（）{
返回新的AclPermissionEvaluator（aclService（））；
}
@豆子
公共JdbcMutableAclService aclService（）{
返回新的JdbcMutableAclService（数据源，lookupStrategy（），
aclCache（））；
}
@豆子
@Configuration
@EnableGlobalMethodSecurity( prePostEnabled = true, securedEnabled = true )
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {


@Override
protected MethodSecurityExpressionHandler createExpressionHandler() {
    return defaultMethodSecurityExpressionHandler();

}

@Override
protected void configure( final AuthenticationManagerBuilder authenticationManagerBuilder ) throws Exception {
    authenticationManagerBuilder.authenticationProvider( authenticationProvider() );
}


@Bean
public JdbcDaoImpl jdbcDao() {

    JdbcDaoImpl jdbcDao = new JdbcDaoImpl();
    jdbcDao.setDataSource( dataSource() );

    return jdbcDao;
}


@Bean
public DaoAuthenticationProvider authenticationProvider() {

    final DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
    authenticationProvider.setUserDetailsService( jdbcDao() );
    authenticationProvider.setPasswordEncoder( encoder() );

    return authenticationProvider;
}

@Bean
public PasswordEncoder encoder() {
    return new BCryptPasswordEncoder( 11 );
}


@Bean( name = "myDS")
public DataSource dataSource() {

    BasicDataSource dataSource = new BasicDataSource();
    dataSource.setDriverClassName( "com.mysql.cj.jdbc.Driver" );
    dataSource.setUrl( "jdbc:mysql://localhost:3306/java_spring_angular_rest_security_acl2" );
    dataSource.setUsername( "root" );
    dataSource.setPassword( "alphax" );

    return dataSource;
}

@Bean
public EhCacheBasedAclCache aclCache() {
    return new EhCacheBasedAclCache(aclEhCacheFactoryBean().getObject(), permissionGrantingStrategy(), aclAuthorizationStrategy());
}

@Bean
public EhCacheFactoryBean aclEhCacheFactoryBean() {

    EhCacheFactoryBean ehCacheFactoryBean = new EhCacheFactoryBean();
    ehCacheFactoryBean.setCacheManager(aclCacheManager().getObject());
    ehCacheFactoryBean.setCacheName("aclCache");
    return ehCacheFactoryBean;
}

@Bean
public EhCacheManagerFactoryBean aclCacheManager() {
    return new EhCacheManagerFactoryBean();
}


@Bean
public LookupStrategy lookupStrategy() {
    return new BasicLookupStrategy(dataSource(), aclCache(), aclAuthorizationStrategy(), permissionGrantingStrategy());
}

@Bean
public AclAuthorizationStrategy aclAuthorizationStrategy() {
    return new AclAuthorizationStrategyImpl(new SimpleGrantedAuthority("ROLE_ADMIN"));
}


@Bean
public PermissionGrantingStrategy permissionGrantingStrategy() {
    return new DefaultPermissionGrantingStrategy(new ConsoleAuditLogger());
}


@Bean( name = "defaultMethodSecurityExpressionHandler")
public MethodSecurityExpressionHandler defaultMethodSecurityExpressionHandler() {

    DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();
    AclPermissionEvaluator permissionEvaluator = new AclPermissionEvaluator(aclService());

    expressionHandler.setPermissionEvaluator(permissionEvaluator);
    expressionHandler.setPermissionCacheOptimizer( new AclPermissionCacheOptimizer( aclService() ) );

    return expressionHandler;
}

@Bean( name = "myAclService")
public JdbcMutableAclService aclService() {

    JdbcMutableAclService jdbcMutableAclService =  new JdbcMutableAclService(dataSource(), lookupStrategy(), aclCache());
    jdbcMutableAclService.setClassIdentityQuery( "SELECT @@IDENTITY" );
    jdbcMutableAclService.setSidIdentityQuery( "SELECT @@IDENTITY" );

    return jdbcMutableAclService;
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.fireduptech.spring.rest</groupId>
<artifactId>hero</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>hero</name>
<description>Demo project for Spring Boot</description>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>

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

    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>6.0.6</version>
    </dependency>


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

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


            <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-dbcp2</artifactId>
        <version>2.2.0</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-acl -->
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-acl</artifactId>
        <version>5.0.1.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>5.0.3.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache-core -->
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache-core</artifactId>
        <version>2.6.11</version>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>