How to deploy a Spring Boot Application into Tomcat

How to deploy a Spring Boot Application into Tomcat

Deploying applications is hard. In this tutorial you’ll see an easier way using Tomcat: you’ll create an authenticated web app and deploy it through the browser using the latest versions of Tomcat, Spring Boot, and Java.

Deploying applications is hard. In this tutorial you’ll see an easier way using Tomcat: you’ll create an authenticated web app and deploy it through the browser using the latest versions of Tomcat, Spring Boot, and Java.

Since version 9, Oracle has decreased the Java release cadence to six months so major version numbers are increasing at a much faster rate than before. The latest release is Java SE 11 (Standard Edition) which came out in September 2018. The biggest licensing change in this new release has led to one clear takeaway: to use the OpenJDK from now on. Open JDK is the free version of Java that you can now also get from Oracle. Also, Java 11 has long term support so this is the version you should be using for new projects going forward.

Start Your Java 11 App

Open up a console and run java -version to see what version of Java you are using.

[[email protected] demo]$ java -version
openjdk version "1.8.0_111"
OpenJDK Runtime Environment (build 1.8.0_111-b16)
OpenJDK 64-Bit Server VM (build 25.111-b16, mixed mode)
[[email protected] demo]$

Java 8 is shown as version 1.8.0.

SDKMAN is a great tool for keeping your development libraries up to date. To install it run

$ curl -s "https://get.sdkman.io" | bash

Note that SDKMAN only works on Linux and Unix-like systems. Windows users will need to install the latest Java manually.

If SDKMAN installs properly you will see instructions for getting the command to work in your current terminal.

All done!

Please open a new terminal, or run the following in the existing one:

	source "/home/karl/.sdkman/bin/sdkman-init.sh"

Then issue the following command:

	sdk help

Enjoy!!!
[[email protected] demo]$

Run the source command shown and the sdk command should be active.

Now install the latest Java simply with sdk install java.

[[email protected] demo]$ sdk install java

Downloading: java 11.0.2-open

In progress...

Once done java -version should show 11.0.2.

Done installing!

Setting java 11.0.2-open as default.
[[email protected] demo]$ java -version
openjdk version "11.0.2" 2019-01-15
OpenJDK Runtime Environment 18.9 (build 11.0.2+9)
OpenJDK 64-Bit Server VM 18.9 (build 11.0.2+9, mixed mode)
[[email protected] demo]$

NOTE: If you already have SDKMAN! and Java 11 installed, you can set it as the default using sdk default java 11.0.2-open.

Create a Spring Boot Project for Tomcat

The most popular way to start a Spring project is with Spring Initializr.

Navigate to start.spring.io in your favorite web browser, then choose your project options:

  • Leave as Maven, Java, and the latest stable Spring Boot (2.1.4)
  • Change the group and artifact if you wish
  • Click on More options and select Java 11
  • In the Dependencies box, type and choose Web, Security and Devtools. They should appear as Dependencies selected on the right

Now click Generate Project and a zip file will download with the project inside. Simply unzip and enter the directory from the command line. If you ls you’ll see five files and one directory (src).

[[email protected] demo]$ ls
HELP.md  mvnw  mvnw.cmd  pom.xml  src

mvnw is a script that allows you to use Maven without installing it globally. mvnw.cmd is the Windows version of this script. pom.xml describes your project, and src has your Java code inside. (Note there’s also a hidden .mvn directory where the embedded maven files sit!)

Let’s see what the project does. Type ./mvnw spring-boot:run and press enter. It may take a while for everything to install, but eventually, you should see something like this:

Tomcat started on port(s): 8080 (http) with context path ''
2019-03-17 19:56:49.342  INFO 10744 --- [  restartedMain] com.karl.demo.DemoApplication        	: Started DemoApplication in 3.022 seconds (JVM running for 3.56)

Note the message Tomcat started on port(s): 8080. Open a browser window to <a href="http://localhost:8080" target="_blank">http://localhost:8080</a> and you should see a login page.

You can authenticate using “user” for a username and the password that’s been printed to your terminal. After logging in, you’ll see a 404 error page because you haven’t created any code to show a landing page at /.

Add Secure Authentication to Your Spring Boot App

Let’s add authentication with Okta. Why Okta? Because you don’t want to worry about managing your users and hashing their passwords, do you? Friends don’t let friends write authentication - let the experts at Okta do it for you instead! After all, Okta’s API is built with Java and Spring Boot too!

Once you’ve signed up for a free account, go to Applications on your dashboard. Click Add Application, select Web, and click Next.

You should now be in the Application Settings page. Replace the Login Redirect URIs field with the following:

http://localhost:8080/login/oauth2/code/okta

Click Done at the bottom. Copy your Client ID and Client secret from the Client Credentials section and keep them somewhere safe. Now right at the top click the API tab (next to Applications) and then Authorization Servers. Make note of the Issuer URI which looks like:

https://{yourOktaDomain}/oauth2/default

Create a file in your project at src/main/resources/application.yml and put those values inside:

okta:  
  oauth2:
    issuer: https://{yourOktaDomain}/oauth2/default  
    client-id: {clientId}
    client-secret: {clientSecret}

Now add the Okta Spring Boot Starter library as a dependency in your pom.xml.

<dependency>
    <groupId>com.okta.spring</groupId>
    <artifactId>okta-spring-boot-starter</artifactId>
    <version>1.1.0</version>
</dependency>

Now edit your main Java entry file – which is probably somewhere like src/main/java/com/example/demo/DemoApplication.java – and add the @RestController annotation to the class, as well as a homepage entry point:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.core.Authentication;
import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
   	 SpringApplication.run(DemoApplication.class, args);
    }

    @GetMapping
    @ResponseBody
    public String currentUserName(Authentication authentication) {
    	DefaultOidcUser userDetails = (DefaultOidcUser) authentication.getPrincipal();
    	return "Hello, " + userDetails.getFullName();
    }
}

Restart your app using ./mvnw spring-boot:run or use your IDE to run it.

Now when you visit <a href="http://localhost:8080" target="_blank">http://localhost:8080</a> you should see the Okta login screen.

Once you’ve entered in the details of an attached Okta user (you can use the same login as your Okta developer account here) you should see a welcome message with the full name you entered when you registered:

Hot Tip: Logging out of an OAuth2 session is more nuanced than one might first imagine. To keep testing the login process, I recommend you use private browsing windows to ensure the login screen returns; close them down when you are finished.

Stop your Spring Boot app so you can run Tomcat on its default port of 8080.

Set up Tomcat 9 for Your Spring Boot App

Getting Tomcat up and running couldn’t be easier. Start by downloading the binary compatible with your platform. Make sure to use the .zip or .tar.gz file and not the installer. Extract to a location and inside the bin directory run the startup script - startup.sh for Linux/Mac and startup.bat for Windows.

[[email protected] bin]$ ./startup.sh
Using CATALINA_BASE:   /home/karl/Downloads/apache-tomcat-9.0.19
Using CATALINA_HOME:   /home/karl/Downloads/apache-tomcat-9.0.19
Using CATALINA_TMPDIR: /home/karl/Downloads/apache-tomcat-9.0.19/temp
Using JRE_HOME:    	/home/karl/.sdkman/candidates/java/current
Using CLASSPATH:   	/home/karl/Downloads/apache-tomcat-9.0.19/bin/bootstrap.jar:/home/karl/Downloads/apache-tomcat-9.0.19/bin/tomcat-juli.jar
Tomcat started.
[[email protected] bin]$

Hot Tip: You can also use ./catalina.sh run to start your app. This command will print the logs to your terminal so you don’t need to tail them to see what’s happening.

Browse to <a href="http://localhost:8080" target="_blank">http://localhost:8080</a> and you should see the Tomcat installation page.

Create a WAR File from Your Spring Boot Project

You now need to create a WAR file from your Spring Boot application. Add the following just after the <description> node in your pom.xml.

<packaging>war</packaging>

Remove the embedded Tomcat server by adding the following to your dependencies list:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

Finally enable your application as a servlet by extending your main class with SpringBootServletInitializer:

import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication extends SpringBootServletInitializer {
    ...
}

Now clean and package your application with the following command:

./mvnw clean package

You should see a message like the following:

[INFO] Building war: /home/karl/tst/demo/target/demo-0.0.1-SNAPSHOT.war

Take note where your new .war lives.

Deploy a WAR to Tomcat from the Browser

You may have noticed that on the right-hand side of the Tomcat welcome screen was three buttons: Server Status, Manager App, and Host Manager. You can deploy a WAR from Manager App but it needs authentication (and there are no users defined by default).

Add the following to conf/tomcat-users.xml in your Tomcat directory:

<user username="karl" password="secret" roles="manager-gui" />

You’ll need to restart Tomcat for this change to take effect. Because you started it directly you need to stop the process yourself. Find the process id using ps aux | grep tomcat.

[[email protected] bin]$ ps aux | grep tomcat
karl 	11813  180  1.9 7389172 159596 pts/0  Sl   09:44   0:07 /home/karl/.sdkman/candidates/java/current/bin/java -Djava.util.logging.config.file=/home/karl/Downloads/apache-tomcat-9.0.19/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -classpath /home/karl/Downloads/apache-tomcat-9.0.19/bin/bootstrap.jar:/home/karl/Downloads/apache-tomcat-9.0.19/bin/tomcat-juli.jar -Dcatalina.base=/home/karl/Downloads/apache-tomcat-9.0.19 -Dcatalina.home=/home/karl/Downloads/apache-tomcat-9.0.19 -Djava.io.tmpdir=/home/karl/Downloads/apache-tomcat-9.0.19/temp org.apache.catalina.startup.Bootstrap start
karl 	11881  0.0  0.0   6268  2280 pts/0	S+   09:44   0:00 grep tomcat
[[email protected] bin]$

Here my process ID is 11813. Use the kill command to kill it.

kill 11813

Restart the server by using startup.sh as before. When you click on the Manager App button the user details you entered above should get you to the manager screen.

Scroll to the bottom to the WAR file to deploy section. Click Browse… and select the WAR file from before. Click Deploy.

If you scroll up you should see something like /demo-0.0.1-SNAPSHOT listed in the Applications section. Click on this will take us to <a href="http://localhost:8080/demo-0.0.1-SNAPSHOT" target="_blank">http://localhost:8080/demo-0.0.1-SNAPSHOT</a> which is where Tomcat is serving our application from. You’ll see a Bad Request error.

This is because the redirect URL is now wrong in our Okta app configuration - everything should be prepended with demo-0.0.1-SNAPSHOT. That name is a bit cumbersome. To change it rename your WAR file to demo.war (you can do this permanently by adding <finalName>demo</finalName> to the build section of your pom.xml). Now click Undeploy next to your app name in the manager window, and redeploy the WAR. Now the app should be under /demo.

Now in your Okta application config prepend all the URLs with /demo, e.g. <a href="http://localhost:8080/demo/login/oauth2/code/okta" target="_blank">http://localhost:8080/demo/login/oauth2/code/okta</a> (you do this by clicking Edit and then Save). Now clicking on your /demo app in the manager (or browsing to <a href="http://localhost:8080/demo" target="_blank">http://localhost:8080/demo</a>) should show you the welcome screen as before.

Hot Tip: To ensure your local development setup matches the machine you are deploying to, make sure the embedded Tomcat version is the same as your external server by adding the following to your pom.xml:

<properties>
    <tomcat.version>9.0.19</tomcat.version>
</properties>

Angular 9 Tutorial: Learn to Build a CRUD Angular App Quickly

What's new in Bootstrap 5 and when Bootstrap 5 release date?

What’s new in HTML6

How to Build Progressive Web Apps (PWA) using Angular 9

What is new features in Javascript ES2020 ECMAScript 2020

Spring Boot Tutorials - Spring Boot Full Course

Spring Boot Tutorials - Spring Boot Full Course

Spring Boot Tutorials | Full Course - What is Spring? Spring Boot is an open source Java-based framework used to create a Micro Service. Spring Boot contains a comprehensive infrastructure support for developing a micro service and enables you to develop enterprise-ready applications that you can “just run”.

  1. What is Spring ? – 00:05
  2. Dependency Injection? – 05:34
  3. Spring Tool Suite | Spring Boot IDE – 13:40
  4. Spring, Autowire, Dependency Injection – 22:17
  5. Web App using Spring Boot – 40:39
  6. Application Properties File – 55:33
  7. Accepting Client Data – 01:00:11
  8. ModelAndView – 01:08:51
  9. Model Object – 01:16:12
  10. JPA | MVC | H2 Example – 01:20:29
  11. JPA | MVC | H2 Example Part 2 – 01:35:29
  12. Data JPA | MVC | H2 | Query Methods Example – 01:45:12
  13. Data JPA | MVC | H2 | REST Example – 01:54:43
  14. Data JPA | MVC | H2 | REST Example – 02:02:22
  15. Postman | Data JPA | MVC | H2 | REST Example – 02:06:55
  16. Content Negotiation | Data JPA | MVC | H2 | REST – 02:11:29
  17. Spring Boot | MVC | REST Post Example – 2:19:36
  18. Spring Boot | MVC | REST PUT DELETE Example – 02:27:35
  19. Spring Boot Data REST Example – 02:36:30

Spring Boot Tutorials | Full Course:- https://github.com/navinreddy20/Spring-Boot

Spring Boot Tutorial For Beginner- Spring Boot Full Course

Spring Boot Tutorial For Beginner- Spring Boot Full Course

This "Spring Boot Tutorial For Beginner- Spring Boot Full Course" video will help you learn Spring Boot Framework from scratch with examples. This Spring Tutorial is ideal for both beginners as well as professionals who want to master the Spring Boot Framework

Spring Boot Full Course - Learn Spring Boot In 4 Hours | Spring Boot Tutorial For Beginner

Below are the topics covered in this Spring Boot Tutorial for Beginners video:

  • 1:40 What is Spring Boot?
  • 2:35 Features of Spring Boot
  • 3:50 Why Do We Need Spring Boot?
  • 4:30 Spring Boot Market Trend
  • 5:15 Spring vs Spring Boot
  • 6:25 Install & Setup Spring Boot
  • 6:45 System Requirements
  • 7:35 Install & Set up Spring Boot CLI
  • 14:00 Install & Setup Spring Tool Suite
  • 25:40 Model View Controller
  • 26:00 What is MVC?
  • 27:35 Model View Controller Workflow
  • 29:00 What is Dependency Injection?
  • 31:50 Inversion of Control
  • 33:10 Types of Dependency Injection
  • 34:05 Benefits of Dependency Injection
  • 48:35 Auto wire
  • 49:50 Create First Web Application Using Spring Boot
  • 1:06:50 Create a Web Application To Pass Client Data
  • 1:13:40 Model View & Object Example
  • 1:20:30 Create a Submission Form In Spring Boot
  • 1:40:50 Connect Web Application To Database
  • 2:04:50 REST API
  • 2:07:35 What is REST API?
  • 2:08:50 Features of REST API
  • 2:09:35 Principles of REST API
  • 2:11:40 Methods of REST API
  • 2:12:20 REST API Hands-On
  • 2:35:55 Spring Data REST
  • 2:36:55 Spring Data REST Hands-On
  • 2:46:35 Spring Security
  • 2:47:30 Secure Applications Using Spring Boot
  • 2:58:56 Spring Boot Interview Questions

Full-stack Reactive Java with Spring Framework, Spring Boot and Project Reactor

Full-stack Reactive Java with Spring Framework, Spring Boot and Project Reactor

Reactive programming offers Java developers a way to build message-driven, elastic, resilient, and responsive services...yet many Java developers don't know where to begin.

Reactive programming offers Java developers a way to build message-driven, elastic, resilient, and responsive services...yet many Java developers don't know where to begin.

The Reactive Streams initiative provides a baseline and Project Reactor provides a great way to become immediately productive, leveraging reactive capabilities from end to end. Whether you're coming from a Spring MVC environment or a functional perspective, Reactor empowers you to spin up fully reactive Spring Boot 2 applications quickly and efficiently.

In this talk, the presenter dives into the net-new Netty-based web runtime and shows you how to:

  • integrate easily with existing Spring-stack technologies
  • easily transition from blocking to reactive applications & systems
  • define your API in an imperative style and functionally, reaping all benefits both ways
  • leverage powerful new testing mechanisms to make code better and life easier

Thanks for reading

If you liked this post, share it with all of your programming buddies!

Follow us on Facebook | Twitter

Further reading about Java Spring Framework and Spring Boot

Java Programming Masterclass for Software Developers

100+ Java Interview Questions and Answers In 2019

Build a microservices architecture with Spring Boot and Spring Cloud

Spring Framework - Top 50 Questions for Interview In 2019

Building a Simple CRUD App using Spring Boot, MySQL, JPA/Hibernate

Full Stack Web Development with Angular and Spring MVC