How to Configure SSL In Spring Boot 2:-

In this post, we are going to learn How to Configure SSL in Spring Boot 2. There are two different ways to configure SSL in Spring Boot 2.

1. Using Default Configurations.
2. Using Custom Configurations.

One of the prerequisites to Configure SSL is to have an SSL Certificate.

We can generate an SSL certificate ourselves known as a self-signed certificate for the development. 

In production, you should use a certificate issued by a trusted Certificate Authority (CA). It gives you a certificate file basically which we need to use in our code.

We will see how we can use the Self Signed Certificate file to Configure SSL In Spring Boot 2.

Tools and Technologies Used:-

• Java JDK 8 (1.8.0_152)
• Spring Boot 2.0.4.RELEASE
• Maven 3.5

Using Basic Configurations to Setup SSL In Spring Boot 2:-

Spring Boot provides a way to configure SSL . We can mention few properties in our application and we are good to go.

Let’s Check a few of the properties below.

server.port=8443
security.require-ssl=true
server.ssl.key-store-type=JKS
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=frugalis007
server.ssl.key-alias=tomcat

As you can see in above properties we have used JKS keystore file type and given the name as keystore.jks This is the Self Signed Certificate has been generated and its copied under src/main/resources folder in spring boot.

While generating the Self Signed Certificate it asks for the password and we set alias which we have added in our properties.

As 8080 is considered to be a non-SSL port, We have configured the server port as 8443, to follow a standard.

Now Create a rest Service and run your application, you will be able to access the application using HTTPS. This is the simplest way to configure  SSL in any Spring Boot applications. Let’s have a look at the advanced level of configurations

Using Custom Configurations to Setup SSL in Spring Boot 2:-

Lets have a look at what we want here . We want our Keystore password to be encrypted in properties file using our own custom encryptor .

For the above requirement we need to Customize the Spring Boot SSL configurations.In Order to customize Spring Boot SSL configurations we need to Implement WebServerFactoryCustomizer

Any bean implementing this interface will get a callback with the server factory before the server itself is started . We can customize the Port ,Address,Password of the embedded Server.

package com.frugalis.ssl.App;

import java.io.File;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;
import com.frugalis.common.PasswordDecryptor;

@Component
@Profile("prod")
public class CustomServletContainer implements
		WebServerFactoryCustomizer<TomcatServletWebServerFactory> {

    @Inject
    private PasswordDecryptor passwordDecrypt;

	@Value("${key-store}")
	private String keystoreFile;
	@Value("${key-alias}")
	private String keystoreAlias;
	@Value("${key-store-type}")
	private String keystoreType;
	@Value("${key-password}")
	private String keystorePass;
        @Value("${port}")
        private int tlsPort;

	public void customize(TomcatServletWebServerFactory factory) {

		factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {

		@Override
		public void customize(Connector connector) {
		
		connector.setPort(8443);
                connector.setSecure(true);
                connector.setScheme("https");
                connector.setAttribute("keyAlias", "tomcat");
                connector.setAttribute("keystorePass", "password");

                File file = new File(keystoreFile);
                String absoluteKeystoreFile = file.getAbsolutePath();
                
                connector.setAttribute("keystoreFile", absoluteKeystoreFile);
                connector.setAttribute("clientAuth", "false");
                connector.setAttribute("sslProtocol", "TLS");
                connector.setAttribute("SSLEnabled", true);

                Http11NioProtocol proto = (Http11NioProtocol) connector.getProtocolHandler();

                proto.setSSLEnabled(true);
                proto.setKeystoreFile(keystoreFile);
                proto.setKeystorePass(keystorePass);
                proto.setKeystoreType(keystoreType);
                proto.setKeyAlias(keystoreAlias);
		}
		});
	}

    @PostConstruct
    public void ProcessPassword() {
          keystorePass = passwordDecrypt.decryptPassword(keystorePass);
    }  
}

We have Configured Profiling to enable SSL in production mode in Spring Boot 2 .

Note:- In  a typical commercial  production environment we basically don’t enable SSL in application level instead its preferred to enable in the VIP level . Let me know if you guys face any issues.

Load a File From Classpath In Spring Boot

In this post, we are going to check How to Load a File From Classpath In Spring Boot. Long back I was working on a very simple project.

We realized Reading a property source in Spring boot is easy and it can get tricky as well .

As Spring works on the concept of fat jar it is  good to know for developer the best ways to load a file from classpath  in spring boot .

In this post, we’ll see various ways to access and load the contents of a file that’s on the classpath using Spring.

I wanted to read a JSON file from the resources folder.src/main/resources Hence written a code something like this below.

	
        @Value("classpath:test.json")
	private Resource resource;

        File file = resource.getFile();

Now, this code works completely fine once I run it using,mvn:spring-boot:run but as soon I’m building and packaging the application using maven and running it as simple executable jar I’m getting an exception. Let’s go ahead and find out the solution now.

Using InputStream  

We can use InputStream to read a file from classpath in your Spring boot application . Let’s define the name of json file to be read with Resource .

        
        @Value("classpath:test.json")
	Resource resourceFile;

Let’s See How We can read the File , We will now show you actual code to Write and retrieve the content of file from your spring boot based application.

	
    private void testResource(Resource resource) {
		try {
			InputStream resourcee = resource.getInputStream();
			String text = null;
			try (final Reader reader = new InputStreamReader(resourcee)) {
				text = CharStreams.toString(reader);
			}
			System.out.println(text);

		} catch (IOException e) {
			e.printStackTrace();
		}
	}

We have seen How we can Load a File From Classpath In Spring Boot If the file is inside a jar.

Reading as a File:-

There is another way to load resources in spring boot. We are now going to check how we can load a file from classpath in spring boot if the file is present in the filesystem not inside a jar.

	
	public void testResourceFile() throws IOException {
		File resource = new ClassPathResource("test.json").getFile();
		String text = new String(Files.readAllBytes(resource.toPath()));
	}

Reading Resource as ResourceLoader:-

ResourceLoader is used to loads resources from class-path as well as file system. It is one of the very commonly used way to read a file from classpath .

@Autowired
ResourceLoader resourceLoader;
Resource resource=resourceLoader.getResource("classpath:test.json");

Now we can use resource.getInputStream() or resource.getFile() as required.

Using ResourceUtils:-

Load a file from classpath in spring boot using ResourceUtils resolves the given resource location to a,java.io.File i.e. to a file in the file system.It doesn’t check if the file exists or not.

It is my most preferred way of doing it in any spring boot based application i am working .

ResourceUtils.getFile("classpath:test.json");

Note:-   Visit this Site to Understand More about Basics Of Java and Collections.

Configure Swagger With Jersey and Spring Boot

We are going to configure Swagger With Jersey and Spring Boot. We saw applications are moving towards micro-services architecture. one of the important aspects of API development is API documentation. Great documentation results in proper experience in API consumption. We are going to use and Configure Swagger and Swagger UI for API documentation along with Jersey and Spring Boot.

Swagger is Used for standardizing API documentation and provide a consistent specification. Swagger UI  helps in visualizing and interact with our API’s.

Integration of Spring with Swagger is a straightforward task with  Spring provided annotations. Using Spring Boot Swagger with JAX-RS is a bit tricky task. Let’s continue and create a  Spring Boot Jersey Project referring our post Spring Boot Jersey Example.

Project Dependencies:-

1. Spring Boot
2. swagger-jersey2-jaxrs
3. spring-boot-starter-web

Here is our pom.xml with spring boot swagger maven dependency and other required dependencies.

<?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.frugalis</groupId>
	<artifactId>myRest</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<name>SpringBoot-Jersey</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.10.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-jersey</artifactId>
		</dependency>

		<dependency>
			<artifactId>tomcat-embed-websocket</artifactId>
			<groupId>org.apache.tomcat.embed</groupId>
			<scope>provided</scope>
		</dependency>
		
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-links</artifactId>
			<version>3.1.1.Final</version>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

	<dependency>
		<groupId>io.swagger</groupId>
		<artifactId>swagger-jersey2-jaxrs</artifactId>
		<version>1.5.20</version>
	</dependency>


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

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


</project>

Configuration Of Swagger and Jersey:-

Now we have already added swagger maven dependencies, now it’s the time to configure swagger with jersey and spring boot. Lets  add a swagger configuration in our Jersey Config as below.

package com.frugalis.SpringBootJersey;

import io.swagger.jaxrs.config.BeanConfig;
import io.swagger.jaxrs.listing.ApiListingResource;
import io.swagger.jaxrs.listing.SwaggerSerializers;

import javax.annotation.PostConstruct;
import javax.ws.rs.ApplicationPath;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

import org.glassfish.jersey.server.ResourceConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.ObjectMapper;


@Component
@ApplicationPath("/api")
public class JerseyConfig extends ResourceConfig {

	@Autowired
	public JerseyConfig(ObjectMapper objectMapper) {
	
		packages("com.frugalis.resourcesImpl");		
		register(new ObjectMapperContextResolver(objectMapper));
	}

	@Provider
	public static class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {
		private final ObjectMapper mapper;
		public ObjectMapperContextResolver(ObjectMapper mapper) {
			this.mapper = mapper;
		}

		@Override
		public ObjectMapper getContext(Class<?> type) {
			return mapper;
		}
	
	}
	
	 @PostConstruct
	  public void init() {
	    // Register components where DI is needed
	    this.SwaggerConfig();
	  }
	private void SwaggerConfig() {
		this.register(ApiListingResource.class);
		this.register(SwaggerSerializers.class);
		
	    BeanConfig swaggerConfigBean = new BeanConfig();
	    swaggerConfigBean.setConfigId("Frugalis Swagger Jersey Example");
	    swaggerConfigBean.setTitle("Using Swagger ,Jersey And Spring Boot ");
	    swaggerConfigBean.setVersion("v1");
	    swaggerConfigBean.setContact("frugalisAdmin");
	    swaggerConfigBean.setSchemes(new String[] { "http", "https" });
	    swaggerConfigBean.setBasePath("/api");
	    swaggerConfigBean.setResourcePackage("com.frugalis.resources");
	    swaggerConfigBean.setPrettyPrint(true);
	    swaggerConfigBean.setScan(true);
	  }
}

We are setting basepath asswaggerConfigBean.setBasePath("/api") this path could be anything. On successful setup, we can check our swagger setup is working or not by going to http://localhost:8080/api/swagger.json

Once we get an output JSON as response, our first step to Configure Swagger With Jersey and Spring Boot is Done.

Now the next step is Configuring Swagger UI.

Configure and Setup Swagger UI:-

Visit Swagger UI GitHub project and download dist version of the Project. Extract contents and move the dist content to /src/main/resources/static , we can create the folder structure if it is not present. The dist folder under the GitHub project contains  JavaScript, CSS, images and HTML files used for swagger UI.

We need to update index.htmlinside forsrc/main/resources/static/index.html Swagger UI to find the configuration and load the UI accordingly. Replace text withhttp://petstore.swagger.io/v2/swagger.json to your  swagger.json URL. In this case, our swagger.json is located at http://localhost:8080/api/swagger.json

<script>
    window.onload = function() {

      // Build a system
      const ui = SwaggerUIBundle({
        url: "api/swagger.json",
        dom_id: '#swagger-ui',
        deepLinking: true,
        presets: [
          SwaggerUIBundle.presets.apis,
          SwaggerUIStandalonePreset
        ],
        plugins: [
          SwaggerUIBundle.plugins.DownloadUrl
        ],
        layout: "StandaloneLayout"
      })

      window.ui = ui
    }
  </script>

Testing:-

[sociallocker id=”1183″]

 Download

[/sociallocker]

Most of the times file upload task are not simple as it looks like in any language . If you want to do in Java world with spring boot file upload and download .

In this example, we are going to check how to Upload File Using Spring Boot and REST. We are going to use Spring MultipartFile  to upload our  files using Spring Boot using  REST API . Multipart is one of the most efficient way to handle large file uploads in spring . Spring boot multiple file uploads are easily handled by spring MultipartFile in java .

We are also going to check How to download files with Spring Boot and  spring boot rest services.

Technologies Used:-

• Spring Boot 2.0
• Maven 3.0
• Java 1.8

Project Structure:-

Create File Upload Controller:-

We are going to upload a single file and upload it using  MultipartFile .

Let’s configure our Spring Boot application to enable Multipart file uploads and return the name of the uploaded file. Let’s write a request mapping and write a basic REST Controller. This is a sample controller and we will be writing logic later in the section.

package com.frugalis.SpringRestFileUpload;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Random;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {

	String UPLOAD_DIR = "D://upload//";
	
	@RequestMapping(value = "/upload", method = RequestMethod.POST)
	public @ResponseBody String handleFileUpload(@RequestParam(value = "file") MultipartFile file) throws IOException {
}	
	@RequestMapping(value = "/upload/{galleryId}", method = RequestMethod.GET)
	public ResponseEntity<byte[]> getFile(@PathVariable("galleryId")String galleryId) throws IOException {
	
	}
	
	private String getRandomString() {
		return new Random().nextInt(999999) + "_" + System.currentTimeMillis();
	}

	private File getTargetFile(String fileExtn, String fileName) {
		File targetFile = new File(UPLOAD_DIR + fileName + fileExtn);
		return targetFile;
	}

	private String getFileExtension(MultipartFile inFile) {
		String fileExtention = inFile.getOriginalFilename().substring(inFile.getOriginalFilename().lastIndexOf('.'));
		return fileExtention;
	}

}

We are configuring endpoints as /upload and /upload/{imageId} . We written methods to return random string as well as the file format as we are going to need those while saving file.

Create REST API for uploading files in Spring Boot 

@RequestMapping(value = "/upload", method = RequestMethod.POST)
	public @ResponseBody String handleFileUpload(@RequestParam(value = "file") MultipartFile file) throws IOException {

		String fileExtension = getFileExtension(file);
		String filename = getRandomString();

		File targetFile = getTargetFile(fileExtension, filename);

		byte[] bytes = file.getBytes();
		file.transferTo(targetFile);
		String UploadedDirectory = targetFile.getAbsolutePath();

		return filename;
}

} 

getTargetFile()creates a file object using UPLOAD_DIR, filename, and file extension.We are using MultipartFile.getBytes()to save the target file and return target file path in response.

Testing Code:-

Download Code