Spring Boot Snippets

<properties>
[..]
  <maven-failsafe-plugin.version>2.22.0</maven-failsafe-plugin.version>
  <maven-surefire-plugin.version>2.22.0</maven-surefire-plugin.version>
</properties>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  <!-- Exclude JUnit 4 from starter-test (and all other related test-starter, i.e
those for security and project reactor -->
  <exclusions>
    <exclusion>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
    </exclusion>
  </exclusions>
</dependency>

# Full generated queries
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true

# Aggregate Query Statistics (needs logger org.hibernate.stat set to at least DEBUG)
spring.jpa.properties.hibernate.generate_statistics=true

# Increase Log Level for Hibernate
logging.level.org.hibernate.SQL=TRACE
logging.level.org.hibernate.stat=TRACE

properties.put("hibernate.generate_statistics",
  environment.getRequiredProperty("spring.jpa.properties.hibernate.generate_statistics")

package com.hascode.sample.config;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.webservices.client.WebServiceTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.ws.client.core.WebServiceTemplate;
import org.springframework.ws.transport.http.ClientHttpRequestMessageSender;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

@Configuration
public class TlsConfigModule {

    private final Resource keyStore;
    private final String keyStorePassword;

    public TlsConfigModule(@Value("${server.ssl.key-store}") Resource keyStore, @Value("${server.ssl.key-store-password}") String keyStorePassword) {
        this.keyStore = keyStore;
        this.keyStorePassword = keyStorePassword;
    }

    @Bean
    public WebServiceTemplate webServiceTemplate()
        throws KeyStoreException, IOException, NoSuchAlgorithmException, UnrecoverableKeyException, KeyManagementException, CertificateException {
        KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
        ks.load(keyStore.getInputStream(), keyStorePassword.toCharArray());

        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(
            new SSLContextBuilder()
                .loadTrustMaterial(null, new TrustSelfSignedStrategy())
                .loadKeyMaterial(ks, keyStorePassword.toCharArray()).build());
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(socketFactory).build();
        ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(
            httpClient);
        ClientHttpRequestMessageSender clientHttpRequestMessageSender = new ClientHttpRequestMessageSender(requestFactory);
        return new WebServiceTemplateBuilder().messageSenders(clientHttpRequestMessageSender).build();
    }

}

ssl.validation=off

package com.hascode.example;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;

@Configuration
@ConditionalOnProperty(name = "ssl.validation", havingValue = "off")
public class SSLValidationBypass {
    @PostConstruct
    private void ignoreCertificates() {
        System.err.println("""
        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        !!! SSL CERTIFICATE VALIDATION DISABLED !!! NEVER USE IN PRODUCTION !!!
        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        """);

        var = new TrustManager[] {new X509TrustManager() {
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }

            @Override
            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        }};

        try {
            var sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        } catch (Exception e) {}
    }
}

<dependency>
  <groupId>io.springfox</groupId>
  <artifactId>springfox-boot-starter</artifactId>
</dependency>

spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER

logging.level.org.springframework.web=DEBUG
logging.level.org.springframework.ws.client.MessageTracing.sent=DEBUG
logging.level.org.springframework.ws.server.MessageTracing.sent=DEBUG
logging.level.org.springframework.ws.client.MessageTracing.received=TRACE
logging.level.org.springframework.ws.server.MessageTracing.received=TRACE

resultActions.andDo(MockMvcResultHandlers.print()); // to print it

// or

MvcResult result = springMvc.perform(MockMvcRequestBuilders
         .get("/teh-url").accept(MediaType.APPLICATION_JSON)).andReturn();

String content = result.getResponse().getContentAsString();

// or

.alwaysDo(MockMvcResultHandlers.print())

package com.hascode.config;

import org.keycloak.adapters.springboot.KeycloakSpringBootConfigResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class KeycloakFix {
    @Bean
    public KeycloakSpringBootConfigResolver KeycloakConfigResolver() {
        return new KeycloakSpringBootConfigResolver();
    }
}

package com.hascode.example.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.env.AbstractEnvironment;
import org.springframework.core.env.EnumerablePropertySource;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.stream.StreamSupport;

@Component
public class DebuggingPropertyDumper {

    private static final Logger log = LoggerFactory.getLogger(DebuggingPropertyDumper.class);

    private static final List<String> propNameFilter = List.of("secret", "password", "credential", "cred");

    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        final Environment environment = event.getApplicationContext().getEnvironment();
        log.info("====== Dump Environment and Configuration ======");
        log.info("== Active profiles: {}", Arrays.toString(environment.getActiveProfiles()));
        final MutablePropertySources sources = ((AbstractEnvironment) environment).getPropertySources();

        StreamSupport.stream(sources.spliterator(), false)
                     .filter(ps -> ps instanceof EnumerablePropertySource)
                     .map(ps -> ((EnumerablePropertySource<?>) ps).getPropertyNames())
                     .flatMap(Arrays::stream)
                     .distinct()
                     .sorted()
                     .filter(propName -> !propNameFilter.contains(propName))
                     .forEach(prop -> log.info("Property '{}': '{}'", prop, environment.getProperty(prop)));
        log.info("===========================================");
    }
}

<plugin>
	<groupId>org.openapitools</groupId>
	<artifactId>openapi-generator-maven-plugin</artifactId>
	<version>${openapi-generator-maven-plugin.version}</version>
	<executions>
	    <execution>
		<goals>
		    <goal>generate</goal>
		</goals>
		<configuration>
		    <!-- our OpenAPI source spec -->
		    <inputSpec>${project.basedir}/src/main/resources/openapi.yaml</inputSpec>
		    <generateApiTests>false</generateApiTests>
		    <generateModelTests>false</generateModelTests>
                    <!-- use Java 8 time API -->
		    <typeMappings>
			<typeMapping>DateTime=ZonedDateTime</typeMapping>
			<typeMapping>duration=Duration</typeMapping>
		    </typeMappings>
		    <importMappings>
			<importMapping>ZonedDateTime=java.time.ZonedDateTime</importMapping>
			<importMapping>Duration=java.time.Duration</importMapping>
		    </importMappings>
                    <!-- define packages for API and Model -->
		    <apiPackage>io.hascode.myapp.api</apiPackage>
		    <modelPackage>io.hascode.myapp.model</modelPackage>
		    <generatorName>spring</generatorName>
                    <!-- spring boot 3 delegates -->
		    <configOptions>
			<useSpringBoot3>true</useSpringBoot3>
			<delegatePattern>true</delegatePattern>
		    </configOptions>
		</configuration>
	    </execution>
	</executions>
</plugin>