generator-jhipster 9.0.0-beta.0 → 9.0.0-beta.1

package/dist/generators/{spring-cache → spring-boot/generators/cache}/internal/dependencies.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013-2025 the original author or authors from the JHipster project.
+ * Copyright 2013-2026 the original author or authors from the JHipster project.
  *
  * This file is part of the JHipster project, see https://www.jhipster.tech/
  * for more information.
@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { JavaDependency, JavaDependencyVersion } from '../../java/types.ts';
+import type { JavaDependency, JavaDependencyVersion } from '../../../../java/types.ts';
 type CacheProviderDefinition = {
     versions?: JavaDependencyVersion[];
     dependencies: JavaDependency[];
@@ -25,5 +25,7 @@ type CacheProviderDependencies = {
     base: CacheProviderDefinition;
     hibernateCache?: CacheProviderDefinition;
 };
-export declare const getCacheProviderMavenDefinition: (cacheProvider: string, javaDependencies: Record<string, string>) => CacheProviderDependencies;
+export declare const getCacheProviderJavaDefinition: (cacheProvider: string, javaDependencies: Record<string, string>, opts?: {
+    springBoot4?: boolean;
+}) => CacheProviderDependencies;
 export {};

package/dist/generators/{spring-cache → spring-boot/generators/cache}/internal/dependencies.js

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013-2025 the original author or authors from the JHipster project.
+ * Copyright 2013-2026 the original author or authors from the JHipster project.
  *
  * This file is part of the JHipster project, see https://www.jhipster.tech/
  * for more information.
@@ -24,14 +24,14 @@ const hibernateJCache = {
     groupId: 'org.hibernate.orm',
     artifactId: 'hibernate-jcache',
 };
-export const getCacheProviderMavenDefinition = (cacheProvider, javaDependencies) => {
+export const getCacheProviderJavaDefinition = (cacheProvider, javaDependencies, { springBoot4 } = {}) => {
     const dependenciesForCache = {
         redis: {
             base: {
                 dependencies: [
                     {
                         groupId: 'org.testcontainers',
-                        artifactId: 'junit-jupiter',
+                        artifactId: 'testcontainers-junit-jupiter',
                         scope: 'test',
                     },
                     {
@@ -97,6 +97,14 @@ export const getCacheProviderMavenDefinition = (cacheProvider, javaDependencies)
                         artifactId: 'hazelcast-spring',
                         version: javaDependencies['hazelcast-spring'],
                     },
+                    ...(springBoot4
+                        ? [
+                            {
+                                groupId: 'org.springframework.boot',
+                                artifactId: 'spring-boot-starter-hazelcast',
+                            },
+                        ]
+                        : []),
                 ],
             },
             hibernateCache: {

package/dist/generators/{spring-cache → spring-boot/generators/cache}/resources/gradle/libs.versions.toml

@@ -12,4 +12,4 @@ xmemcached-provider = { module = 'com.google.code.simple-spring-memcached:xmemca
 
 xmemcached = { module = 'com.googlecode.xmemcached:xmemcached', version = '2.4.9' }
 
-redisson = { module = 'org.redisson:redisson', version = '3.52.0' }
+redisson = { module = 'org.redisson:redisson', version = '4.1.0' }

package/dist/generators/spring-boot/generators/cache/templates/src/main/java/_package_/config/CacheConfiguration_caffeine.java.ejs

@@ -0,0 +1,88 @@
+<%#
+ Copyright 2013-2026 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+<%_ if (enableHibernateCache) { _%>
+import org.hibernate.cache.jcache.ConfigSettings;
+import org.springframework.boot.hibernate.autoconfigure.HibernatePropertiesCustomizer;
+<%_ } _%>
+import com.github.benmanes.caffeine.jcache.configuration.CaffeineConfiguration;
+import java.util.OptionalLong;
+import java.util.concurrent.TimeUnit;
+import org.springframework.boot.cache.autoconfigure.JCacheManagerCustomizer;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Bean;
+
+import tech.jhipster.config.JHipsterProperties;
+
+@Configuration
+@EnableCaching
+public class CacheConfiguration {
+    private final javax.cache.configuration.Configuration<Object, Object> jcacheConfiguration;
+
+    public CacheConfiguration(JHipsterProperties jHipsterProperties) {
+        JHipsterProperties.Cache.Caffeine caffeine = jHipsterProperties.getCache().getCaffeine();
+
+        CaffeineConfiguration<Object, Object> caffeineConfiguration = new CaffeineConfiguration<>();
+        caffeineConfiguration.setMaximumSize(OptionalLong.of(caffeine.getMaxEntries()));
+        caffeineConfiguration.setExpireAfterWrite(OptionalLong.of(TimeUnit.SECONDS.toNanos(caffeine.getTimeToLiveSeconds())));
+        caffeineConfiguration.setStatisticsEnabled(true);
+        jcacheConfiguration = caffeineConfiguration;
+    }
+
+<%_ if (enableHibernateCache) { _%>
+    @Bean
+    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(javax.cache.CacheManager cacheManager) {
+        return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
+    }
+<%_ } _%>
+
+    @Bean
+    public JCacheManagerCustomizer cacheManagerCustomizer() {
+        return cm -> {
+<%_ if (authenticationTypeOauth2 && applicationTypeMicroservice) { _%>
+            createCache(cm, "oAuth2Authentication");
+<%_ } _%>
+<%_ if (generateBuiltInUserEntity) { _%>
+            createCache(cm, <%= packageName %>.repository.UserRepository.USERS_BY_LOGIN_CACHE);
+            createCache(cm, <%= packageName %>.repository.UserRepository.USERS_BY_EMAIL_CACHE);
+  <%_ if (enableHibernateCache) { _%>
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName());
+            createCache(cm, <%= packageName %>.domain.Authority.class.getName());
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName() + ".authorities");
+    <%_ if (authenticationTypeSession) { _%>
+            createCache(cm, <%= packageName %>.domain.PersistentToken.class.getName());
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName() + ".persistentTokens");
+    <%_ } _%>
+  <%_ } _%>
+<%_ } _%>
+            // jhipster-needle-caffeine-add-entry
+        };
+    }
+
+    private void createCache(javax.cache.CacheManager cm, String cacheName) {
+        javax.cache.Cache<Object, Object> cache = cm.getCache(cacheName);
+        if (cache != null) {
+            cache.clear();
+        } else {
+            cm.createCache(cacheName, jcacheConfiguration);
+        }
+    }
+}

package/dist/generators/spring-boot/generators/cache/templates/src/main/java/_package_/config/CacheConfiguration_ehcache.java.ejs

@@ -0,0 +1,90 @@
+<%#
+ Copyright 2013-2026 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import java.time.Duration;
+
+import org.ehcache.config.builders.*;
+import org.ehcache.jsr107.Eh107Configuration;
+
+<%_ if (enableHibernateCache) { _%>
+import org.hibernate.cache.jcache.ConfigSettings;
+import org.springframework.boot.hibernate.autoconfigure.HibernatePropertiesCustomizer;
+<%_ } _%>
+import tech.jhipster.config.JHipsterProperties;
+
+import org.springframework.boot.cache.autoconfigure.JCacheManagerCustomizer;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Bean;
+
+@Configuration
+@EnableCaching
+public class CacheConfiguration {
+    private final javax.cache.configuration.Configuration<Object, Object> jcacheConfiguration;
+
+    public CacheConfiguration(JHipsterProperties jHipsterProperties) {
+        var ehcache = jHipsterProperties.getCache().getEhcache();
+
+        jcacheConfiguration = Eh107Configuration.fromEhcacheCacheConfiguration(
+            CacheConfigurationBuilder.newCacheConfigurationBuilder(Object.class, Object.class,
+                ResourcePoolsBuilder.heap(ehcache.getMaxEntries()))
+                .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(ehcache.getTimeToLiveSeconds())))
+                .build());
+    }
+
+<%_ if (enableHibernateCache) { _%>
+    @Bean
+    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(javax.cache.CacheManager cacheManager) {
+        return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
+    }
+<%_ } _%>
+
+    @Bean
+    public JCacheManagerCustomizer cacheManagerCustomizer() {
+        return cm -> {
+<%_ if (authenticationTypeOauth2 && applicationTypeMicroservice) { _%>
+            createCache(cm, "oAuth2Authentication");
+<%_ } _%>
+<%_ if (generateBuiltInUserEntity) { _%>
+            createCache(cm, <%= packageName %>.repository.UserRepository.USERS_BY_LOGIN_CACHE);
+            createCache(cm, <%= packageName %>.repository.UserRepository.USERS_BY_EMAIL_CACHE);
+  <%_ if (enableHibernateCache) { _%>
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName());
+            createCache(cm, <%= packageName %>.domain.Authority.class.getName());
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName() + ".authorities");
+    <%_ if (authenticationTypeSession) { _%>
+            createCache(cm, <%= packageName %>.domain.PersistentToken.class.getName());
+            createCache(cm, <%= user.entityAbsoluteClass %>.class.getName() + ".persistentTokens");
+    <%_ } _%>
+  <%_ } _%>
+<%_ } _%>
+           // 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) {
+            cache.clear();
+        } else {
+            cm.createCache(cacheName, jcacheConfiguration);
+        }
+    }
+}

package/dist/generators/spring-boot/generators/cache/templates/src/main/java/_package_/config/CacheConfiguration_hazelcast.java.ejs

@@ -0,0 +1,189 @@
+<%#
+ Copyright 2013-2026 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.JHipsterProperties;
+
+import com.hazelcast.config.*;
+import com.hazelcast.core.HazelcastInstance;
+import com.hazelcast.core.Hazelcast;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+<%_ if (serviceDiscoveryAny) { _%>
+import org.springframework.boot.web.server.autoconfigure.ServerProperties;
+import org.springframework.cloud.client.ServiceInstance;
+import org.springframework.cloud.client.discovery.DiscoveryClient;
+import org.springframework.cloud.client.serviceregistry.Registration;
+<%_ } _%>
+
+import org.springframework.cache.CacheManager;
+
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+
+import jakarta.annotation.PreDestroy;
+
+@Configuration
+@EnableCaching
+public class CacheConfiguration {
+    private static final Logger LOG = LoggerFactory.getLogger(CacheConfiguration.class);
+
+    private final Environment env;
+<%_ if (serviceDiscoveryAny) { _%>
+
+    private final ServerProperties serverProperties;
+
+    private final DiscoveryClient discoveryClient;
+
+    private Registration registration;
+<%_ } _%>
+
+    public CacheConfiguration(<% if (cacheProviderHazelcast) { %>Environment env<% if (serviceDiscoveryAny) { %>, ServerProperties serverProperties, DiscoveryClient discoveryClient<% } } %>) {
+        this.env = env;
+<%_ if (serviceDiscoveryAny) { _%>
+        this.serverProperties = serverProperties;
+        this.discoveryClient = discoveryClient;
+<%_ } _%>
+    }
+<%_ if (serviceDiscoveryAny) { _%>
+
+    @Autowired(required = false)
+    public void setRegistration(Registration registration) {
+        this.registration = registration;
+    }
+<%_ } _%>
+
+    @PreDestroy
+    public void destroy() {
+        LOG.info("Closing Cache Manager");
+        Hazelcast.shutdownAll();
+    }
+
+    @Bean
+    public CacheManager cacheManager(HazelcastInstance hazelcastInstance) {
+        LOG.debug("Starting HazelcastCacheManager");
+        return new com.hazelcast.spring.cache.HazelcastCacheManager(hazelcastInstance);
+    }
+
+    @Bean
+    public HazelcastInstance hazelcastInstance(JHipsterProperties jHipsterProperties) {
+        LOG.debug("Configuring Hazelcast");
+        HazelcastInstance hazelCastInstance = Hazelcast.getHazelcastInstanceByName("<%= baseName %>");
+        if (hazelCastInstance != null) {
+            LOG.debug("Hazelcast already initialized");
+            return hazelCastInstance;
+        }
+        Config config = new Config();
+        config.setInstanceName("<%= baseName %>");
+<%_ if (serviceDiscoveryAny) { _%>
+        config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
+        if (this.registration == null) {
+            LOG.warn("No discovery service is set up, Hazelcast cannot create a cluster.");
+        } else {
+            // The serviceId is by default the application's name,
+            // see the "spring.application.name" standard Spring property
+            String serviceId = registration.getServiceId();
+            LOG.debug("Configuring Hazelcast clustering for instanceId: {}", serviceId);
+            // In development, everything goes through 127.0.0.1, with a different port
+            if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT))) {
+                LOG.debug(
+                    "Application is running with the \"dev\" profile, Hazelcast " + "cluster will only work with localhost instances"
+                );
+
+                config.getNetworkConfig().setPort(serverProperties.getPort() + 5701);
+                config.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
+                for (ServiceInstance instance : discoveryClient.getInstances(serviceId)) {
+                    String clusterMember = "127.0.0.1:" + (instance.getPort() + 5701);
+                    LOG.debug("Adding Hazelcast (dev) cluster member {}", clusterMember);
+                    config.getNetworkConfig().getJoin().getTcpIpConfig().addMember(clusterMember);
+                }
+            } else { // Production configuration, one host per instance all using port 5701
+                config.getNetworkConfig().setPort(5701);
+                config.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
+                for (ServiceInstance instance : discoveryClient.getInstances(serviceId)) {
+                    String clusterMember = instance.getHost() + ":5701";
+                    LOG.debug("Adding Hazelcast (prod) cluster member {}", clusterMember);
+                    config.getNetworkConfig().getJoin().getTcpIpConfig().addMember(clusterMember);
+                }
+            }
+        }
+<%_ } else { _%>
+        config.getNetworkConfig().setPort(5701);
+        config.getNetworkConfig().setPortAutoIncrement(true);
+
+        // In development, remove multicast auto-configuration
+        if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT))) {
+            System.setProperty("hazelcast.local.localAddress", "127.0.0.1");
+
+            config.getNetworkConfig().getJoin().getAwsConfig().setEnabled(false);
+            config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
+            config.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(false);
+        }
+      <%_ } _%>
+        config.setManagementCenterConfig(new ManagementCenterConfig());
+        config.addMapConfig(initializeDefaultMapConfig(jHipsterProperties));
+  <%_ if (enableHibernateCache) { _%>
+        config.addMapConfig(initializeDomainMapConfig(jHipsterProperties));
+  <%_ } _%>
+        return Hazelcast.newHazelcastInstance(config);
+    }
+
+    private MapConfig initializeDefaultMapConfig(JHipsterProperties jHipsterProperties) {
+        MapConfig mapConfig = new MapConfig("default");
+
+        /*
+        Number of backups. If 1 is set as the backup-count for example,
+        then all entries of the map will be copied to another JVM for
+        fail-safety. Valid numbers are 0 (no backup), 1, 2, 3.
+        */
+        mapConfig.setBackupCount(jHipsterProperties.getCache().getHazelcast().getBackupCount());
+
+        /*
+        Valid values are:
+        NONE (no eviction),
+        LRU (Least Recently Used),
+        LFU (Least Frequently Used).
+        NONE is the default.
+        */
+        mapConfig.getEvictionConfig().setEvictionPolicy(EvictionPolicy.LRU);
+
+        /*
+        Maximum size of the map. When max size is reached,
+        map is evicted based on the policy defined.
+        Any integer between 0 and Integer.MAX_VALUE. 0 means
+        Integer.MAX_VALUE. Default is 0.
+        */
+        mapConfig.getEvictionConfig().setMaxSizePolicy(MaxSizePolicy.USED_HEAP_SIZE);
+
+        return mapConfig;
+    }
+
+    private MapConfig initializeDomainMapConfig(JHipsterProperties jHipsterProperties) {
+        MapConfig mapConfig = new MapConfig("<%= packageName %>.domain.*");
+        mapConfig.setTimeToLiveSeconds(jHipsterProperties.getCache().getHazelcast().getTimeToLiveSeconds());
+        return mapConfig;
+    }
+}