Spring boot Jhipster EHCache3.x如何定义cachaManager中的磁盘持久性

我使用jhipster generator 6.10.5生成项目，使用ehcache作为缓存提供程序

package com.xxx.generated.config;

import java.time.Duration;

import org.ehcache.config.builders.*;
import org.ehcache.config.units.MemoryUnit;
import org.ehcache.jsr107.Eh107Configuration;

import org.hibernate.cache.jcache.ConfigSettings;
import io.github.jhipster.config.JHipsterProperties;

import org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.boot.info.BuildProperties;
import org.springframework.boot.info.GitProperties;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import io.github.jhipster.config.cache.PrefixedKeyGenerator;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.serviceregistry.Registration;
import org.springframework.context.annotation.*;

@Configuration
@EnableCaching
public class CacheConfiguration {
    private GitProperties gitProperties;
    private BuildProperties buildProperties;
    private final javax.cache.configuration.Configuration<Object, Object> jcacheConfiguration;

    public CacheConfiguration(JHipsterProperties jHipsterProperties) {
        JHipsterProperties.Cache.Ehcache ehcache = jHipsterProperties.getCache().getEhcache();

        jcacheConfiguration = Eh107Configuration.fromEhcacheCacheConfiguration(
            CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
                ResourcePoolsBuilder.heap(ehcache.getMaxEntries()).disk(100, MemoryUnit.MB))
                .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(ehcache.getTimeToLiveSeconds())))
                .build());
    }

    @Bean
    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(javax.cache.CacheManager cacheManager) {
        return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
    }

    @Bean
    public JCacheManagerCustomizer cacheManagerCustomizer() {
        return cm -> {
            createCache(cm, com.ehc.generated.repository.UserRepository.USERS_BY_LOGIN_CACHE);
            createCache(cm, com.ehc.generated.repository.UserRepository.USERS_BY_EMAIL_CACHE);
            createCache(cm, com.ehc.generated.domain.User.class.getName());
            createCache(cm, com.ehc.generated.domain.Authority.class.getName());
            createCache(cm, com.ehc.generated.domain.User.class.getName() + ".authorities");
            createCache(cm, com.ehc.generated.domain.Book.class.getName());
            createCache(cm, "byId");
            // jhipster-needle-ehcache-add-entry
        };
    }


    private void createCache(javax.cache.CacheManager cm, String cacheName) {
        javax.cache.Cache<Object, Object> cache = cm.getCache(cacheName);
        if (cache == null) {
            cm.createCache(cacheName, jcacheConfiguration);
        }
    }

    @Autowired(required = false)
    public void setGitProperties(GitProperties gitProperties) {
        this.gitProperties = gitProperties;
    }

    @Autowired(required = false)
    public void setBuildProperties(BuildProperties buildProperties) {
        this.buildProperties = buildProperties;
    }

    @Bean
    public KeyGenerator keyGenerator() {
        return new PrefixedKeyGenerator(this.gitProperties, this.buildProperties);
    }
}

package com.xxx.generated.config；
导入java.time.Duration；
导入org.ehcache.config.builders.*；
导入org.ehcache.config.units.MemoryUnit；
导入org.ehcache.jsr107.eh107配置；
导入org.hibernate.cache.jcache.ConfigSettings；
导入io.github.jhipster.config.JHipsterProperties；
导入org.springframework.boot.autoconfigure.cache.jCacheManagerConstomizer；
导入org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer；
导入org.springframework.boot.info.BuildProperties；
导入org.springframework.boot.info.GitProperties；
导入org.springframework.cache.interceptor.KeyGenerator；
导入org.springframework.beans.factory.annotation.Autowired；
导入io.github.jhipster.config.cache.PrefixedKeyGenerator；
导入org.springframework.cache.annotation.EnableCaching；
导入org.springframework.cloud.client.ServiceInstance；
导入org.springframework.cloud.client.DiscoveryClient；
导入org.springframework.cloud.client.serviceregistry.Registration；
导入org.springframework.context.annotation.*；
@配置
@启用缓存
公共类缓存配置{
私人房产；
私人楼宇物业；
私有最终javax.cache.configuration.configuration jcacheConfiguration；
公共缓存配置（JHipsterProperties JHipsterProperties）{
JHipsterProperties.Cache.Ehcache Ehcache=JHipsterProperties.getCache（）.getEhcache（）；
jcacheConfiguration=Eh107Configuration.FromEHCacheConfiguration(
CacheConfigurationBuilder.newCacheConfigurationBuilder（Object.class、Object.class、，
ResourcePoolsBuilder.heap（ehcache.getMaxEntries（））.disk（100，MemoryUnit.MB））
.withExpiry（ExpiryPolicyBuilder.timeToLiveExpiration（持续时间.秒（ehcache.getTimeOliveSeconds（）））
.build（））；
}
@豆子
公共HibernatePropertiesCustomizer HibernatePropertiesCustomizer（javax.cache.CacheManager缓存管理器）{
返回hibernateProperties->hibernateProperties.put（ConfigSettings.CACHE\u MANAGER，cacheManager）；
}
@豆子
公共JCacheManagerCircustomizer缓存管理器Circustomizer（）{
返回cm->{
createCache（cm，com.ehc.generated.repository.UserRepository.USERS\u BY\u LOGIN\u CACHE）；
createCache（cm，com.ehc.generated.repository.UserRepository.USERS\u BY\u EMAIL\u CACHE）；
createCache（cm，com.ehc.generated.domain.User.class.getName（））；
createCache（cm，com.ehc.generated.domain.Authority.class.getName（））；
createCache（cm，com.ehc.generated.domain.User.class.getName（）+“.authorities”）；
createCache（cm，com.ehc.generated.domain.Book.class.getName（））；
createCache（cm，“byId”）；
//jhipster缓存添加项
};
}
私有void createCache（javax.cache.CacheManager cm，字符串cacheName）{
javax.cache.cache cache=cm.getCache（cacheName）；
if（缓存==null）{
createCache（cacheName，jcacheConfiguration）；
}
}
@自动连线（必需=错误）
公共void setGitProperties（GitProperties GitProperties）{
this.gitProperties=gitProperties；
}
@自动连线（必需=错误）
公共void setBuildProperties（BuildProperties BuildProperties）{
this.buildProperties=buildProperties；
}
@豆子
公钥生成器KeyGenerator（）{
返回新的PrefixedKeyGenerator（this.gitProperties，this.buildProperties）；
}
}

我可以在ResourcePoolsBuilder上设置.disk，但如何在cacheManager中设置持久性呢。 jhipster用户Jcache，我找不到任何函数可以配置它。 在Ehcahe文档中，它将使用CacheManagerBuilder配置持久性。

private final javax.cache.configuration.configuration jcacheConfiguration；
专用JCacheCacheCacheManager JCacheCacheCacheManager；
公共缓存配置（JHipsterProperties JHipsterProperties）{
JHipsterProperties.Cache.Ehcache Ehcache=JHipsterProperties.getCache（）.getEhcache（）；
jcacheConfiguration=Eh107Configuration
.FromEhcacheConfiguration(
缓存配置生成器
.newCacheConfigurationBuilder（String.class、User.class、，
ResourcePoolsBuilder.heap（ehcache.getMaxEntries（））.disk（10，MemoryUnit.MB，
正确的）
.WithExpire（ExpireyPolicyBuilder
.timeToLiveExpiration（持续时间为秒（ehcache.getTimeOliveSeconds（）））
.build（））；
CachingProvider CachingProvider=Caching.getCachingProvider（）；
EhcacheCachingProvider ehcacheProvider=（EhcacheCachingProvider）cachingProvider；
DefaultConfiguration=new DefaultConfiguration（ehcacheProvider.getDefaultClassLoader（），
新的DefaultPersistenceConfiguration（新文件（“D:/training/EHCache/cache”）；
CacheManager CacheManager=ehcacheProvider.getCacheManager（ehcacheProvider.getDefaultURI（），配置）；
createCache（cacheManager，com.ehc.generated.repository.UserRepository.USERS\u BY\u LOGIN\u CACHE）；
createCache（cacheManager，com.ehc.generated.repository.UserRepository.USERS\u BY\u EMAIL\u CACHE）；
jCacheCacheManager=新的jCacheCacheManager（cacheManager）；
}
@豆子
公共HibernatePropertiesCustomizer HibernatePropertiesCustomizer（CacheManager CacheManager）{
返回hibernateProperties->hibernateProperties.put（ConfigSettings.CACHE\u MANAGER，cacheManager）；
}
@豆子
public org.springframework.cache.CacheManager CacheManager（）{
返回JCacheCacheCacheManager；
}
@豆子
公共Ca
 private final javax.cache.configuration.Configuration<String, User> jcacheConfiguration;
    private JCacheCacheManager jCacheCacheManager;

    public CacheConfiguration(JHipsterProperties jHipsterProperties) {
        JHipsterProperties.Cache.Ehcache ehcache = jHipsterProperties.getCache().getEhcache();

        jcacheConfiguration = Eh107Configuration
                .fromEhcacheCacheConfiguration(
                        CacheConfigurationBuilder
                                .newCacheConfigurationBuilder(String.class, User.class,
                                        ResourcePoolsBuilder.heap(ehcache.getMaxEntries()).disk(10, MemoryUnit.MB,
                                                true))
                                .withExpiry(ExpiryPolicyBuilder
                                        .timeToLiveExpiration(Duration.ofSeconds(ehcache.getTimeToLiveSeconds())))
                                .build());
        CachingProvider cachingProvider = Caching.getCachingProvider();
        EhcacheCachingProvider ehcacheProvider = (EhcacheCachingProvider) cachingProvider;
        DefaultConfiguration configuration = new DefaultConfiguration(ehcacheProvider.getDefaultClassLoader(),
                new DefaultPersistenceConfiguration(new File("D:/training/EHCache/cache")));
        CacheManager cacheManager = ehcacheProvider.getCacheManager(ehcacheProvider.getDefaultURI(), configuration);

        createCache(cacheManager, com.ehc.generated.repository.UserRepository.USERS_BY_LOGIN_CACHE);
        createCache(cacheManager, com.ehc.generated.repository.UserRepository.USERS_BY_EMAIL_CACHE);
        jCacheCacheManager = new JCacheCacheManager(cacheManager);
    }

    @Bean
    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(CacheManager cacheManager) {
        return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
    }

    @Bean
    public org.springframework.cache.CacheManager cacheManager() {
        return jCacheCacheManager;
    }

    @Bean
    public CacheManager cacheManagers() {
        return jCacheCacheManager.getCacheManager();
    }