DEV Community: JakMar17

Deploy Spring Boot on WildFly application server

JakMar17 — Wed, 17 Mar 2021 15:46:30 +0000

By default Spring Boot comes with embedded Tomcat server, which, when build as fat jar enables deploying application as simple as running java -jar command. But one could also use some other JavaEE or application server for deployment. Let's look how to deploy Spring Boot project to WildFly.

Disclaimer

For most of the time deploying Spring Boot on application server like WildFly does not actually makes sense since embedded servers (Tomcat by default, Jetty,...) are part of Spring Boot itself.

Deploying Spring Boot project to WildFly will be divided into three parts:

Setting up WildFly (standalone edition)
Setting up and configuring new Spring Boot project
Building Spring Boot project and deploying

1. Setting up WildFly

Firstly download WildFly application server, after download is complete unzip archive, save it and open terminal in WildFly directory.

Next step is setting up WildFly user, with terminal move into bin sub directory and run ./add-user.sh on Linux or add-user.bat on Windows. Then simply follow those steps:



> What type of user do you wish to add?
a (Management User)

> Enter the details of the new user to add.
Username: wildfly
Password: w1ldFly!
Re-enter Password : w1ldFly!

> What groups do you want this user to belong to? (Please enter a comma separated list, or leave blank for none)[  ]: <LEAVE BLANK>

> Is this correct yes/no?
yes

> yes/no?
yes

> Press any key to continue . . .

With tha done, we can run WildFly server using ./standalone.sh (Linux) or .\standalone.bat (Windows). When initialization is completed you should see log:



15:28:47,740 INFO  [org.jboss.as] (Controller Boot Thread) WFLYSRV0051: Admin console listening on http://127.0.0.1:9990

Now enter http://127.0.0.1:9990 into the browser, after entering admin credentials (defined in previous step) you should see WildFly admin console:

With this we are done setting WildFly server and we are moving on to setting up Spring Boot project.

2. Setting up and configuring Spring Boot project

Firstly let's create project on Spring Boot website, here the only important thing is choosing War as packaging. And also Maven if you want to follow next steps.

Then click Generate button, download, unzip archive and import project into your favourite IDE (I will be using IntelliJ, but you could also use Eclipse, NetBeans, VSCode or anything else).

For testing purposes, we will be creating a simple HelloWorld API endpoint. Let's create Java file under /src/main/java//HelloApi.java in it write following code (package and imports are not shown for readbility, but at the end of this article I posted Git repository with source code):



@RestController
public class HelloApi {

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Spring Boot";
    }
}

You could try building (mvn clean package) and running (java -jar /target/<APP-NAME>.jar). While accessing http://localhost:8080/hello you should see Hello from Spring Boot.

Now let's configure Spring Boot project to deploy it on WebFly. Firstly we will remove Tomcat embedded server from out project. In the pom.xml find spring-boot-starter-tomcat dependency and make sure that <scope> is set to provided if not set it:



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

And lets exclude some logging libraries that may break deployment:



<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
      <exclusion>
          <groupId>ch.qos.logback</groupId>
          <artifactId>logback-classic</artifactId>
      </exclusion>
  </exclusions>
</dependency>

Next thing we will add some WildFly properties:



<properties>
    <java.version>15</java.version>
    <deploy.wildfly.host>127.0.0.1</deploy.wildfly.host>
    <deploy.wildfly.port>9990</deploy.wildfly.port>
    <deploy.wildfly.username>wildfly</deploy.wildfly.username>
    <deploy.wildfly.password>w1ldFly!</deploy.wildfly.password>
</properties>

Let's break it down: java.version defines JDK version that project is build upon (it is already set), deploy.wildfly.XX are properties that we need for deploying app on WildFly, host and port are where WildFly is "living", username and password are same as defined in previous step.

Lets use them in build plugin:



<plugin>
    <groupId>org.wildfly.plugins</groupId>
    <artifactId>wildfly-maven-plugin</artifactId>
    <version>2.0.2.Final</version>
    <executions>
        <execution>
            <phase>install</phase>
            <goals>
                <goal>deploy</goal>
            </goals>
        </execution>
    </executions>
    <configuration>                
        <filename>${project.build.finalName}.war</filename>
        <hostname>${deploy.wildfly.host}</hostname>
        <port>${deploy.wildfly.port}</port>
        <username>${deploy.wildfly.username}</username>
        <password>${deploy.wildfly.password}</password>
    </configuration>
</plugin>

With that done make sure everything is still building (run mvn clean package) and lets move on to the next step.

Last thing we will do in our Spring Boot project is setting up context root path (we will set it up to / so our app will be available on domain.com/hello). Firstly create new file under /src/main/webapp/WEB-INF/jboss-web.xml secondly add to the file:



<?xml version="1.0" encoding="UTF-8"?>
<jboss-web xmlns="http://www.jboss.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="
      http://www.jboss.com/xml/ns/javaee
      http://www.jboss.org/j2ee/schema/jboss-web_5_1.xsd">
    <context-root>/</context-root>
</jboss-web>

Here the only important part is <context-root>/</context-root> where we define context-root.

With this out of the way we build out project (mvn clean package) and deploy our Spring Boot project to WildFly server.

3. Deploying Spring Boot to WildFly

After succesful build you should find .war file in /target directory, this is our project's final form that we will deploy to WildFly.

In WildFly's admin console chose Deployments in navbar and then Upload Deployment.

Now all we have to do is uplaod war file and deploy it.

After successful deployment you could go to http://127.0.0.1:8080/hello and see our final result.

We could (and should) skip last step altogether and simply use Maven for deploying to WildFly by using

mvn clean install



Source code is available on [GitHub](https://github.com/JakMar17/SpringBoot-WildFly)

*Cover photo by Min An from Pexels*

Deploying Angular application inside Spring Boot

JakMar17 — Tue, 16 Mar 2021 19:15:58 +0000

Imagine scenario: you just developed frontend application written in Angular and powered by Spring Boot Rest API as backend. When deploying most of the time you'll deploy each application as its own container (frontend on Firebase, backend on Heroku, etc.). But did you know you can deploy both apps as a single JAR or WAR file?

When and why?

Deploying Angular/Spring Boot (or actually any Java project in general) in one file is a great way of deployment when your backend and frontend are developed together (and will be in foreseeable future) or maybe when you, your team or your company are not big fans of microservice approach (or just wanting to produce monolith project).

That kind of monolith approach simplifies (manual) deployment of the app, but it does have one big cons: whenever you update either backend or frontend you'll have to create new JAR/WAR file, so this approach may not be best for CI/CD powered projects.

How?

Disclaimer: some parts of this tutorial may not be best practices used in production or best practice for building apps used by thousands or millions of users. But it is how our team handles application deployment for production applications used every day by hundreds of users.

0. `useHash` strategy for Angular routing

This is simplest way of "fixing" refreshing and direct access to Angular app via URL. You could also rewrite all routes to index.html file (by changing your server's configuration).

Find your routing file (app-routing.module.ts) and add/replace those lines of code:

@NgModule({
imports: [RouterModule.forRoot(routes, { useHash: true })],
exports: [RouterModule],
})
export class AppRoutingModule {}

From now on all your Angular URLs has /#/ between domain (with or without port) and subpaths.
For example: localhost:4200/login/ is now localhost:4200/#/login/.

1. Build Angular frontend

Firstly check your index.html file in Angular project. In it find this line (if you cannot find it, add it between and):


<base href="/">

Secondly, build your angular project using AngularCLI:


ng build --prod

If your app is going to be run on subpath (for example domain.com/my-app/) then add --base-href=/my-app/ to build command.

2. Copy Angular dist folder to backend

After successfully building Angular check /dist folder, inside you should find subfolder named like your app, inside it you'll find some html, js and css files.

Copy those files into your backend /src/main/resources/public/ (if some of the folders are missing add them).

3. Build and run backend project

Clean build your backend using

mvn clean package

After building run it using:

java -jar ./target/.jar

However, this will not work if your project's configuration is set to building WAR if this is the case, you need to deploy application to one of Java application servers (like Tomcat, Wildfly or Glasfish). This is out of scope for this article.

After running Spring Boot app you should see logs from WelcomePageHandlerMapping, they sould be somthing like:

INFO 10732 --- [ main] o.s.b.a.w.s.WelcomePageHandlerMapping : Adding welcome page: class path resource [public/index.html]

We are done :)

4. Accessing frontend

When your project is up and runnning you can access your frontend on domain.com/#/.