JLUPIN PLATFORM WEBSITE
tutorials
  • Rating:
  • Views: 39
  • Author: JLupin
  • Skill level: easy
  • Comments: 0

Overview

This tutorial will show you how to create servlet (Spring BOOT) microservice for JLupin Platform. What is servlet microservice? It is just a microservice which uses servlet container to serve its logic. JLupin Platform is using Spring Boot to allow users to choose servlet container that they want.

Requirements

To complete this tutorial you will need JLupin Platform version 1.5.0.3. You can download it from here.

Configure project

When you create service which will be available to other users of your system, you probably want to tell them how to use it. For native microservice you will create separate interfaces module. But servlet microservice probably won't be accessed with use of proxy objects but with simple json calls or will serve HTTP pages. To keep microservice structure similar for both types we will create implementation module for servlet microservice, but we won't create interfaces module.

We will use Maven feature called reactor. It is built-in mechanism for handling multi-module project. So we are going to start with standard Maven structure.

+--implementation
|  |
|  +--src
|  |  |
|  |  +--main
|  |     |
|  |     +--java
|  |     |
|  |     +--resources
|  |
|  +--pom.xml
|
+--pom.xml

Below pom files with proper configuration are presented.

pom.xml

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

    <artifactId>welcome-servlet-microservice</artifactId>
    <groupId>com.example.application</groupId>
    <version>1.0.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>implementation</module>
    </modules>

    <properties>
        <maven.surefire.skipTests>false</maven.surefire.skipTests>

        <maven.failsafe.plugin.version>2.20</maven.failsafe.plugin.version>
        <maven.surefire.plugin.version>2.20</maven.surefire.plugin.version>

        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${maven.surefire.plugin.version}</version>
                <configuration>
                    <skipTests>${maven.surefire.skipTests}</skipTests>
                </configuration>
            </plugin>
        </plugins>

        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-failsafe-plugin</artifactId>
                    <version>${maven.failsafe.plugin.version}</version>
                    <executions>
                        <execution>
                            <id>integration-test</id>
                            <goals>
                                <goal>integration-test</goal>
                                <goal>verify</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <includes>
                            <include>**/Test*.java</include>
                            <include>**/*Test.java</include>
                            <include>**/*Tests.java</include>
                            <include>**/*TestCase.java</include>
                        </includes>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

implementation/pom.xml

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>

    <name>welcome-servlet-microservice</name>
    <groupId>com.example.application</groupId>
    <artifactId>welcome-servlet-microservice-implementation</artifactId>
    <packaging>war</packaging>
    <version>1.0.0</version>

    <repositories>
        <!-- Repository is also accessible using https connection: -->
        <!-- https://support.jlupin.com/maven2/ -->
        <repository>
            <id>jlupin-central</id>
            <name>jlupin</name>
            <url>http://support.jlupin.com/maven2/</url>
        </repository>
    </repositories>

    <pluginRepositories>
        <!-- Repository is also accessible using https connection: -->
        <!-- https://support.jlupin.com/maven2/ -->
        <pluginRepository>
            <id>jlupin-central</id>
            <name>jlupin</name>
            <url>http://support.jlupin.com/maven2/</url>
        </pluginRepository>
    </pluginRepositories>

    <properties>
        <jlupin.platform.client.version>1.5.0.3</jlupin.platform.client.version>
        <jlupin.platform.maven.plugin.version>1.5.0.0</jlupin.platform.maven.plugin.version>
        <jlupin.servlet.monitor.version>1.5.0.0</jlupin.servlet.monitor.version>
    </properties>

    <dependencies>
        <!-- JLupin dependencies -->
        <dependency>
            <groupId>com.jlupin</groupId>
            <artifactId>jlupin-client-assembly</artifactId>
            <version>${jlupin.platform.client.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.jlupin</groupId>
            <artifactId>jlupin-spring-boot-2-servlet-monitor</artifactId>
            <version>${jlupin.servlet.monitor.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

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

    <build>
        <finalName>${project.name}</finalName>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>com.jlupin</groupId>
                <artifactId>jlupin-platform-maven-plugin</artifactId>
                <version>${jlupin.platform.maven.plugin.version}</version>
                <executions>
                    <execution>
                        <id>jlupin-zip</id>
                        <goals>
                            <goal>zip</goal>
                        </goals>
                        <configuration>
                            <additionalFilesDirectories>
                                <param>../additional-files</param>
                            </additionalFilesDirectories>
                            <includeDependenciesInZip>false</includeDependenciesInZip>
                        </configuration>
                    </execution>
                    <execution>
                        <id>jlupin-deploy</id>
                        <phase>pre-integration-test</phase>
                        <goals>
                            <goal>deploy</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

JLupin Maven repository is configured to get access to required artifacts. Also dependencies required for this tutorial and development are added. JLupin Platform Maven Plugin is configured to zip microservice and deploy it. Also content of additional-files is added to created zip file. You need to create this directory on same level as implementation directory. Configuration files will be placed here. You should end up with structure:

+--additional-files
|
+--implementation
|  |
|  +--src
|  |  |
|  |  +--main
|  |     |
|  |     +--java
|  |     |
|  |     +--resources
|  |
|  +--pom.xml
|
+--pom.xml

Microservice implementation

At first create suitable package structure. In this tutorial com.example.application will be used as main package. Recommended structure (also used by this tutorial) is presented below.

+--additional-files
|
+--implementation
|  |
|  +--src
|  |  |
|  |  +--main
|  |     |
|  |     +--java
|  |     |  |
|  |     |  +--com
|  |     |     |
|  |     |     +--example
|  |     |        |
|  |     |        +--application
|  |     |           |
|  |     |           +--configuration
|  |     |           |
|  |     |           +--controller
|  |     |
|  |     +--resources
|  |
|  +--pom.xml
|
+--pom.xml

When you done with package structure create basic Spring configuration file under configuration package.

package com.example.application.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

@Configuration
@ComponentScan({
    "com.example.application",
    "com.jlupin.servlet.monitor.configuration"
})
public class SpringConfiguration {
}

Ok, we have Spring configuration file created. But our microservice does nothing. Create simple REST controller which accepts name as request body and returns welcome message.

package com.example.application.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;
import java.util.Map;

@RestController
public class WelcomeController {
    @CrossOrigin
    @PostMapping(value = "/getWelcomeMessage")
    public Map<String, String> getWelcomeMessage(@RequestBody Map<String, String> map) {
        return Collections.singletonMap("message", "Hello " + map.get("name") + "!");
    }
}

Controller is ready. Now we need to create starter class for Spring Boot:

package com.example.application;

import com.example.application.configuration.SpringConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootApplicationStarter {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringConfiguration.class, args);
    }
}

We used annotations to configure Spring container. But you can configure starter class the way you want. Now create servlet_configuration.yml file and setup your microservice - example below. Put this file inside additional-files directory.

SERVERS:
  HTTP:
    type: spring_boot
    httpPrimaryPort: -1
    httpSecondaryPort: -1
    waitForFinishExecuteAllRequests: true
    waitToShutdownThreadsOnStop: 5000
    springBootLoaderClassName: org.springframework.boot.loader.WarLauncher
    contextName: /welcome-servlet-microservice
    isStartOnMainServerInitialize: true
    httpStickySession: false
  TRANSMISSION:
    readTimeout: 480000
    isWaitForFinishExecuteAllRequests: false
    waitToShutdownThreadsOnStop: 60000
    backlog: 0
    receiveBufferSize: 0
    isReuseAddress: false
    threadPoolSize: 8
    isLogPeriodicOnDebug: true
    isDestroyThreadOnTimeout: false
    threadExecutingTimeOut: 3600000
    isStartOnMainServerInitialize: true
PROPERTIES:
  platformVersion: '1.5.0.3'
  #jvmOptions1: '-Xms128M -Xmx512M -agentlib:jdwp=transport=dt_socket,address=12998,server=y,suspend=n'
  jvmOptions1: '-Xms128M -Xmx512M' #jvmOptions_2 - default the same as jvmOptions_1
  #jvmOptions2: '-Xms128M -Xmx512M'
  externalPort: '8000'
  version: '1.0.0'
  switchDelayTime: 1000
  connectionSocketTimeoutInMillis: 1000
  readTimeoutInMillis: 30000
  isKeepAlive: false
  isOOBInline: false
  isTcpNoDelay: false
  isReuseAddress: false
  sendBufferSize: 0
  receiveBufferSize: 0
  soLinger: 0
  trafficClass: 0
  #javaExecutablePath: 'c:\\jvm\\bin\\java.exe'
  #additionalClassPath: 'c:\\temp\\*'
  isStartOnMainServerInitialize: true
  priorityStartOnMainServerInitialize: 5
  waitForProcessInitResponseTimeInMillis: 90000
  waitForProcessStartResponseTimeInMillis: 90000
  waitForProcessDestroyResponseTimeInMillis: 30000
  isAllFilesToJVMAppClassLoader: true
  #isStackDumping: true
  isArchiveOnStart: false
  startLogMode: INFO
  isInitErrorCauseWithNetworkInformation: true
  isJmxEnabled: true
  jmxOptions: '-Dcom.sun.management.jmxremote.local.only=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false'
  jmxPrimaryPort: -1
  jmxSecondaryPort: -1
  isExternalHealthcheck: false
  externalHealthcheckURI: '/sampleURI/'
  httpStickySessionCookieOptions: 'option1=value1'
  checkAvailableScript: 'function isAvailable(checkResponseTimeInMillis, jrmcActiveThreads, jrmcMaxThreads,
                                              queueActiveThreads, queueMaxThreads, servletActiveThreads, servletMaxThreads,
                                              jvmMaxMemoryInBytes, jvmTotalMemoryInBytes, jvmFreeMemoryInBytes,
                                              jvmProcessCpuLoadInPercentage, userAvailableFlag) {
                           var isAvailableByUser = Boolean(userAvailableFlag);
                           if(checkResponseTimeInMillis > 20000 || !isAvailableByUser) {
                              return false;
                           }
                           return true;
                         }'
INITIALIZING_LOGGER:
  #directoryPath: '/logs/server'
  #fileName: 'file_name'
  fileExtension: 'log'
  fileSizeInMB: 20
  maxFiles: 10
MEMORY_ERRORS:
  isRestartOnError: true
  howManyTimes: 4
  percentageGrowth: 15
  isHeapDump: true
THREAD_POOLS:
  THREAD_POOL_1:
    size: 8
    waitingTimeForTasksCompletionInMillis: 10000
  #THREAD_POOL_2:
  #  size: 8
  #  waitingTimeForTasksCompletionInMillis: 10000

You should also configure logging system (Log4j2 for JLupin and Spring container). Example configuration with asynchronous appender below.

Put this into log4j2.xml file inside additional-files directory and inside resources directory.

<?xml version="1.0" encoding="UTF-8"?>

<!-- ===================================================================== -->
<!--                                                                       -->
<!--  Log4j2 Configuration                                                  -->
<!--                                                                       -->
<!-- ===================================================================== -->

<!--
   | For more configuration information and examples see the Apache Log4j2
   | website: https://logging.apache.org/log4j/2.x/index.html
-->

<Configuration status="WARN" dest="errors/welcome-servlet-microservice_log4j2_status.log">
    <!-- Extract log directory and file name into variables -->
    <Properties>
        <Property name="logDirectory">../logs/microservice/welcome-servlet-microservice</Property>
        <Property name="logFileName">microservice</Property>
    </Properties>

    <Appenders>
        <!-- RollingFileAppender configured to role every day -->
        <RollingFile name="FILE">
            <FileName>\${logDirectory}/\${logFileName}.log</FileName>
            <FilePattern>\${logDirectory}/\${logFileName}.%d{yyyy-MM-dd}.log</FilePattern>

            <!-- Compress log files to gzip -->
            <!-- More configuration https://logging.apache.org/log4j/2.x/manual/appenders.html#DefaultRolloverStrategy -->
            <!-- <FilePattern>${logDirectory}/${logFileName}.%d{yyyy-MM-dd}.log.gz</FilePattern> -->

            <!-- Do not truncate file -->
            <Append>true</Append>

            <!-- The default pattern: Date Priority [Category] (Thread) Message\n -->
            <PatternLayout pattern="%d %-5p [%c] (%t) %m%n" />

            <Policies>
                <!-- Rollover every microservice start - very useful for debugging -->
                <!-- <OnStartupTriggeringPolicy /> -->

                <!-- Rollover at the top of each day -->
                <TimeBasedTriggeringPolicy interval="1" modulate="true" />

                <!-- Rollover if file size is greater than 200 MB -->
                <!-- <SizeBasedTriggeringPolicy size="200 MB"/> -->
            </Policies>
            <CreateOnDemand>true</CreateOnDemand>

            <!-- Keep last 10 log files -->
            <!-- More configuration https://logging.apache.org/log4j/2.x/manual/appenders.html#DefaultRolloverStrategy -->
            <!-- <DefaultRolloverStrategy max="10" /> -->
        </RollingFile>

        <!-- AsyncAppender for high performance -->
        <Async name="ASYNC_FILE">
            <BufferSize>1000</BufferSize>
            <AppenderRef ref="FILE" />
        </Async>
    </Appenders>

    <Loggers>
        <!-- Setup for root logger with AsyncAppender -->
        <Root level="info">
            <AppenderRef ref="ASYNC_FILE" />
        </Root>
    </Loggers>
</Configuration>

That's all. Now your microservice is ready to deploy.

Deploying microservice

Run server (start/start.sh or start/start.cmd in main server directory). Then run maven command to deploy your microservice:

mvn clean package jlupin-platform:deploy@jlupin-deploy --projects implementation --also-make

Check microservice's list to see your microservice (start/control.sh):

./control.sh microservice list
Zone    Node   Microservice                 Type    Version #Services
default NODE_1 queueMicroservice            native  1.5.0.3 1
default NODE_1 exchange-rates               native  1.5.0.3 1
default NODE_1 channelMicroservice          native  1.5.0.3 1
default NODE_1 currency-converter-gbp       native  1.5.0.3 1
default NODE_1 exchange                     servlet 1.5.0.3 4
default NODE_1 http-session-repository      native  1.5.0.2 2
default NODE_1 currency-converter-chf       native  1.5.0.3 1
default NODE_1 currency-converter-eur       native  1.5.0.3 1
default NODE_1 welcome-servlet-microservice servlet 1.0.0   1

You can see your microservice on the list. You can check its status to see if it is running.

./control.sh microservice status welcome-servlet-microservice
Zone    Node   Microservice                 ProcessID Status  Available Activated
default NODE_1 welcome-servlet-microservice 17892     RUNNING yes       yes

Integration tests

Now it is time to add some integration tests and check our microservice. We will put them into separate module called integration test. Let's add it with proper test package structure:

+--additional-files
|
+--implementation
|  |
|  +--[...]
|
+--integration-test
|  |
|  +--src
|  |  |
|  |  +--test
|  |     |
|  |     +--java
|  |     |  |
|  |     |  +--com
|  |     |     |
|  |     |     +--example
|  |     |        |
|  |     |        +--application
|  |     |
|  |     +--resources
|  |
|  +--pom.xml
|
+--pom.xml

integration-test/pom.xml

<?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>
    <parent>
        <artifactId>welcome-servlet-microservice</artifactId>
        <groupId>com.example.application</groupId>
        <version>1.0.0</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>welcome-servlet-microservice-integration-test</artifactId>    

    <properties>
        <maven.surefire.skipTests>true</maven.surefire.skipTests>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.example.application</groupId>
            <artifactId>welcome-servlet-microservice-implementation</artifactId>
            <version>1.0.0</version>
            <classifier>classes</classifier>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.0.2.RELEASE</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Add module into modules section inside top level pom.xml file:

[...]
    <modules>
        <module>implementation</module>
        <module>integration-test</module>
    </modules>
[...]

Because we are creating war for application and we want to test our microservice in seperate module we need to generate classes also for dependency purposes. Add this to implementation/pom.xml:

<plugin>
    [...]
    <build>
        [...]
        <plugins>
            [...]
            <plugin>        
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <attachClasses>true</attachClasses>
                    <classesClassifier>classes</classesClassifier>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Now create test class.

package com.example.application;

import com.example.application.controller.WelcomeController;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@WebMvcTest(WelcomeController.class)
public class IntegrationTest {
   @Autowired
   private MockMvc mvc;

   @Test
   public void test() throws Exception {
      mvc.perform(post("/getWelcomeMessage").content("{\"name\":\"Piotr\"}").contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().json("{\"message\": \"Hello Piotr!\"}"));
   }
}

It is simple test for returned json content. The last thing is to configure logger (Log4j) for this tests. Add log4j2.xml file to test resources.

<?xml version="1.0" encoding="UTF-8"?>

<!-- ===================================================================== -->
<!--                                                                       -->
<!--  Log4j2 Configuration                                                  -->
<!--                                                                       -->
<!-- ===================================================================== -->

<!--
   | For more configuration information and examples see the Apache Log4j2
   | website: https://logging.apache.org/log4j/2.x/index.html
-->

<Configuration status="WARN">
    <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
            <!-- The default pattern: Date Priority [Category] (Thread) Message\n -->
            <PatternLayout pattern="%d %-5p [%c] (%t) %m%n" />
        </Console>

        <!-- AsyncAppender for high performance -->
        <Async name="ASYNC_STDOUT">
            <BufferSize>1000</BufferSize>
            <AppenderRef ref="STDOUT" />
        </Async>
    </Appenders>

    <Loggers>
        <!-- Setup for root logger with AsyncAppender -->
        <Root level="info">
            <AppenderRef ref="ASYNC_STDOUT" />
        </Root>
    </Loggers>
</Configuration>

It is configured to write logs to standard out. Now you're ready to run tests.

mvn clean integration-test --projects integration-test --also-make
[INFO] Scanning for projects...
[...]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running com.example.application.IntegrationTest
[...]
[INFO] Results:
[INFO] 
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] 
[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO] 
[INFO] welcome-servlet-microservice ....................... SUCCESS [ 20.122 s]
[INFO] welcome-servlet-microservice ....................... SUCCESS [  0.056 s]
[INFO] welcome-servlet-microservice-integration-test ...... SUCCESS [  5.594 s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 26.322 s
[INFO] Finished at: 2018-10-11T10:41:41+02:00
[INFO] Final Memory: 50M/544M
[INFO] ------------------------------------------------------------------------

cURL

If you want you can call endpoint with cURL to check if everything works:

curl -X POST -H "Content-Type: application/json" -d "{\"name\":\"Piotr\"}" localhost:8000/welcome-servlet-microservice/getWelcomeMessage

As a result you should see:

{"message":"Hello Piotr!"}

Done tutorial

You can download project which is result of making this tutorial from GitHub: https://github.com/jlupin/creating-servlet-microservice-jlp-1503

RATE & DISCUSS (0)

No comments found.