Deploy Spring Boot on WildFly application server
Tags: java, maven, wildfly, springboot
Published: 2021-03-17 15:46:30

**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:
1. Setting up WildFly (standalone edition)
2. Setting up and configuring new Spring Boot project
3. Building Spring Boot project and deploying

## 1. Setting up WildFly

Firstly [download WildFly application server](https://www.wildfly.org/), 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:
```bash
> 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`](http://127.0.0.1:9990) into the browser, after entering admin credentials (defined in previous step) you should see WildFly admin console:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zbwrdtyft89uyenriov1.png)

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

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zq8mlpgcvckmfswk79vq.png)

Firstly let's create project on [Spring Boot website](https://start.spring.io/), 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)*:

```java
@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`.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qkkb3g4jeqgcfs8w279o.png)

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:

```xml
<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:
```xml
<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:
```xml
<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:
```xml
<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
<?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`.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gf3vo2o6n577q25epadi.png)

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

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8esua98t30pdk1cmiotk.png)

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

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/02lc1c19d5qi1n4w37ti.png)

> 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*