SpringBoot

Contents

SpringBoot

Common properties for spring boot

https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

   1 # disable web container/server
   2 spring.main.web-environment=false
   3 spring.jmx.enabled=false
   4 #spring.main.banner-mode=off
   5 spring.main.banner-mode=console
   6 spring.banner.location=classpath:banner.txt

Example

pom.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   3     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   4     <modelVersion>4.0.0</modelVersion>
   5     <groupId>hello</groupId>
   6     <artifactId>test-spring-boot</artifactId>
   7     <version>0.1.0</version>
   8     <parent>
   9         <groupId>org.springframework.boot</groupId>
  10         <artifactId>spring-boot-starter-parent</artifactId>
  11         <version>1.4.0.RELEASE</version>
  12     </parent>
  13     <dependencies>
  14         <dependency>
  15             <groupId>org.springframework.boot</groupId>
  16             <artifactId>spring-boot-starter-thymeleaf</artifactId>
  17         </dependency>
  18         <dependency>
  19             <groupId>org.mariadb.jdbc</groupId>
  20             <artifactId>mariadb-java-client</artifactId>
  21             <version>1.4.4</version>
  22         </dependency>
  23         <dependency>
  24             <groupId>commons-dbcp</groupId>
  25             <artifactId>commons-dbcp</artifactId>
  26             <version>1.4</version>
  27         </dependency>
  28 
  29          <dependency>
  30             <groupId>org.springframework</groupId>
  31             <artifactId>spring-jdbc</artifactId>
  32             <version>4.3.2.RELEASE</version>
  33         </dependency>
  34 
  35     </dependencies>
  36     <properties>
  37         <start-class>hello.Application</start-class>
  38     </properties>
  39     <build>
  40         <plugins>
  41             <plugin>
  42                 <groupId>org.springframework.boot</groupId>
  43                 <artifactId>spring-boot-maven-plugin</artifactId>
  44             </plugin>
  45         </plugins>
  46     </build>
  47     <repositories>
  48         <repository>
  49             <id>spring-milestone</id>
  50             <url>http://repo.spring.io/libs-release</url>
  51         </repository>
  52     </repositories>
  53     <pluginRepositories>
  54         <pluginRepository>
  55             <id>spring-milestone</id>
  56             <url>http://repo.spring.io/libs-release</url>
  57         </pluginRepository>
  58     </pluginRepositories>
  59 </project>

GreetingController.java

   1 //src/main/java/hello/GreetingController.java
   2 package hello;
   3 
   4 import org.springframework.stereotype.Controller;
   5 import org.springframework.ui.Model;
   6 import org.springframework.web.bind.annotation.RequestMapping;
   7 import org.springframework.web.bind.annotation.RequestParam;
   8 
   9 import org.slf4j.Logger;
  10 import org.slf4j.LoggerFactory;
  11 import org.springframework.web.bind.annotation.ResponseBody;
  12 import org.springframework.beans.factory.annotation.Autowired;
  13 
  14 import java.util.List;
  15 import java.util.ArrayList;
  16 
  17 @Controller
  18 public class GreetingController {
  19     private final Logger logger = LoggerFactory.getLogger(GreetingController.class);
  20     @Autowired
  21     DummyDAO dummyDAO;
  22 
  23     public GreetingController(){
  24         logger.debug("Greeting controller created.");
  25     }
  26 
  27     @RequestMapping("/greeting")
  28     // http://localhost:8080/greeting?name=nnnn 
  29     public String greeting(@RequestParam(value="name", required=false, defaultValue="World") String name, Model model) {
  30         logger.info("Greeting endpoint called.");
  31         model.addAttribute("name", name);
  32         return "greeting";
  33     }
  34 
  35     @RequestMapping(value="/dummy",produces="application/json")
  36     @ResponseBody
  37     // http://localhost:8080/dummy
  38     public List<Dummy> dummy(){
  39       List<Dummy> list= new java.util.ArrayList<Dummy>();
  40       Dummy dummy = new Dummy();
  41       dummy.setFieldA("AAA");
  42       dummy.setFieldB("CCC");
  43       list.add(dummy);
  44 
  45       Dummy dummy2 = new Dummy();
  46       dummy2.setFieldA("AAA2");
  47       dummy2.setFieldB("CCC2");
  48       list.add(dummy2);
  49 
  50       return list;
  51     }
  52 
  53     @RequestMapping(value="/dummyname",produces="application/json")
  54     @ResponseBody
  55     // http://localhost:8080/dummyname
  56     public String getDummyName(){
  57       return dummyDAO.getNameFromDummy();
  58     }
  59 
  60 
  61 }

Application.java

   1 package hello;
   2 
   3 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   4 import org.springframework.boot.SpringApplication;
   5 import org.springframework.context.annotation.ComponentScan;
   6 import org.springframework.context.annotation.Bean;
   7 import org.springframework.beans.factory.annotation.Autowired;
   8 import org.springframework.beans.factory.annotation.Qualifier;
   9 
  10 import org.apache.commons.dbcp.BasicDataSource;
  11 import org.springframework.jdbc.core.JdbcTemplate;
  12 
  13 import org.slf4j.Logger;
  14 import org.slf4j.LoggerFactory;
  15 
  16 @ComponentScan
  17 @EnableAutoConfiguration
  18 public class Application {
  19     private static Logger logger;
  20 
  21     public static void main(String[] args) {
  22         logger = LoggerFactory.getLogger(Application.class);
  23         logger.info("Starting application");
  24         SpringApplication.run(Application.class, args);
  25     }
  26 
  27     @Bean(name="basicDataSource",destroyMethod="close")
  28     public BasicDataSource createBasicDataSource(){
  29       logger.info("Creating basicDataSource");
  30       BasicDataSource bds = new BasicDataSource();
  31       bds.setDriverClassName("org.mariadb.jdbc.Driver");
  32       bds.setUrl("jdbc:mariadb://localhost:3306/springmvchtml");
  33       bds.setUsername("usertest");
  34       bds.setPassword("usertest");
  35       bds.setInitialSize(3);
  36       return bds;
  37     }
  38 /*
  39     @Bean(name="jdbcTemplate")
  40     public JdbcTemplate jdbcTemplate(){
  41       logger.info("Creating jdbcTemplate");
  42       return new JdbcTemplate( basicDataSource() );
  43     }
  44 */
  45     @Bean(name="jdbcTemplate")
  46     public JdbcTemplate createJdbcTemplate(@Autowired @Qualifier("basicDataSource") BasicDataSource bds  ){
  47       logger.info("Creating jdbcTemplate");
  48       return new JdbcTemplate( bds );
  49     }
  50 
  51 }

ThreadTimer.java

   1 package hello;
   2 
   3 import org.springframework.stereotype.Component;
   4 import javax.annotation.PostConstruct;
   5 import org.springframework.beans.factory.annotation.Autowired;
   6 import java.text.MessageFormat;
   7 import org.slf4j.Logger;
   8 import org.slf4j.LoggerFactory;
   9 import java.util.ArrayList;
  10 
  11 @Component
  12 public class ThreadTimer extends Thread {
  13   private int delaySeconds;
  14   private Logger logger;
  15   private boolean running;
  16   private Object monitor=new Object();
  17   private ArrayList<Object> subscribers;
  18 
  19   //@Autowired
  20   //WaitThread waitThread;
  21 
  22   public ThreadTimer() {
  23     this.logger = LoggerFactory.getLogger(ThreadTimer.class);
  24     logger.info("Created instance of " + this.getClass().getSimpleName());
  25     this.running = true;
  26     this.delaySeconds = 5 * 1000;
  27     this.setName(this.getClass().getSimpleName() + "_" + this.getName());
  28     this.subscribers = new ArrayList<Object>();
  29   }
  30 
  31   public void addSubscriber(Object subscriber){
  32     this.subscribers.add(subscriber);
  33   }
  34 
  35   @PostConstruct
  36   public void init() {
  37     logger.info("Starting the thread");
  38     this.start();
  39   }
  40 
  41   @Override
  42   public void run() {
  43     while (running) {
  44       try {
  45         Thread.sleep(this.delaySeconds);
  46         logger.info("Delay " + this.getClass().getSimpleName());
  47 
  48         for(Object o: this.subscribers){
  49           synchronized(o){
  50             o.notify();
  51           }
  52         }
  53       }
  54       catch (InterruptedException e) {
  55           logger.info("ThreadTimer interrupted exception:" + e.getMessage() );
  56       }
  57       catch (Exception e) {
  58           e.printStackTrace();
  59           logger.info("ThreadTimer exception:" + e.getMessage() );
  60           stopRunning();
  61       }
  62     }
  63     logger.info("Exited " + this.getClass().getSimpleName());
  64   }
  65 
  66   public void startRunning() {
  67     this.running = true;
  68   }
  69 
  70   public void stopRunning() {
  71     this.running = false;
  72   }
  73 
  74   public void destroy(){
  75     logger.info("Called destroy");
  76     this.stopRunning();
  77     this.interrupt();
  78   }
  79 }

WaitThread.java

   1 package hello;
   2 
   3 import org.springframework.stereotype.Component;
   4 import javax.annotation.PostConstruct;
   5 import java.text.MessageFormat;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 import org.springframework.beans.factory.annotation.Autowired;
   9 
  10 @Component
  11 public class WaitThread extends Thread {
  12   private Logger logger;
  13   private boolean running;
  14   private Object monitor;
  15 
  16   @Autowired
  17   ThreadTimer timerThread;
  18 
  19   public WaitThread() {
  20     this.logger = LoggerFactory.getLogger(WaitThread.class);
  21     logger.info("Created instance of " + this.getClass().getSimpleName());
  22     this.running = true;
  23     this.setName(this.getClass().getSimpleName() + "_" + this.getName());
  24     this.monitor=new Object();
  25   }
  26 
  27   @PostConstruct
  28   public void init() {
  29     this.timerThread.addSubscriber(this);
  30     logger.info("Starting the thread");
  31     this.start();
  32   }
  33 
  34   public void run() {
  35     while (running) {
  36       try {
  37         synchronized(this){
  38           this.wait();
  39           logger.info("Notification received.");
  40         }
  41       }
  42       catch (InterruptedException e) {
  43           logger.info("ThreadTimer interrupted exception:" + e.getMessage() );
  44       }
  45       catch (Exception e) {
  46           logger.info("WaitThread exception:" + e.getMessage() );
  47           stopRunning();
  48       }
  49     }
  50     logger.info("Exited " + this.getClass().getSimpleName());
  51   }
  52 
  53   public void startRunning() {
  54     this.running = true;
  55   }
  56 
  57   public void stopRunning() {
  58     this.running = false;
  59   }
  60 
  61   public void destroy(){
  62     logger.info("Called destroy");
  63     this.stopRunning();
  64     this.interrupt();
  65   }
  66 }

src/main/java/hello/Dummy.java

   1 package hello;
   2 
   3 public class Dummy{
   4   private String fieldA;
   5   private String fieldB;
   6 
   7   public Dummy(){
   8   }
   9 
  10   public String getFieldA(){
  11     return fieldA;
  12   }
  13 
  14   public String getFieldB(){
  15     return fieldB;
  16   }
  17 
  18   public void setFieldA(String arg){
  19     fieldA = arg;
  20   }
  21 
  22   public void setFieldB(String arg){
  23     fieldB = arg;
  24   }
  25 }

DummyDAO.java

   1 package hello;
   2 
   3 import org.slf4j.Logger;
   4 import org.slf4j.LoggerFactory;
   5 
   6 import org.springframework.beans.factory.annotation.Autowired;
   7 import org.springframework.beans.factory.annotation.Qualifier;
   8 import org.springframework.jdbc.core.JdbcTemplate;
   9 import org.springframework.stereotype.Component;
  10 
  11 @Component
  12 public class DummyDAO {
  13   @Autowired
  14   @Qualifier("jdbcTemplate")
  15   private JdbcTemplate jdbcTemplate;
  16   private Logger logger;
  17 
  18   public DummyDAO() {
  19     logger = LoggerFactory.getLogger(DummyDAO.class);
  20     logger.info("Created " + this.getClass().getSimpleName());
  21   }
  22 
  23   public String getNameFromDummy() {
  24     return this.jdbcTemplate.queryForObject("select name from dummy limit 1", String.class);
  25   }
  26 }

greeting.html

src/main/resources/templates/greeting.html

   1 <!DOCTYPE HTML>
   2 <html xmlns:th="http://www.thymeleaf.org">
   3 <head>
   4     <title>Getting Started: Serving Web Content</title>
   5     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   6 </head>
   7 <body>
   8     <p th:text="'Hello, ' + ${name} + '!'" />
   9 </body>
  10 </html>

application.properties

src/main/resources/application.properties

   1 logging.file=/tmp/testout.log

src/main/resources/logback-spring.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <configuration>
   3 <!--
   4     <include resource="org/springframework/boot/logging/logback/defaults.xml" />
   5     <property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}spring.log}"/>
   6     <include resource="org/springframework/boot/logging/logback/file-appender.xml" />
   7 -->
   8     <!-- override spring logback default behaviour -->
   9     <appender name="FILE" class="ch.qos.logback.core.FileAppender">
  10         <file>${filelog}</file>
  11         <encoder>
  12                 <pattern>%date{ISO8601} [%thread] %-5level %logger{35} - %msg%n</pattern>
  13         </encoder>
  14     </appender>
  15 
  16     <appender name="GREETFILE" class="ch.qos.logback.core.FileAppender">
  17         <file>/tmp/greet.log</file>
  18         <encoder>
  19                 <pattern>%date{ISO8601} [%thread] %-5level %logger{35} - %msg%n</pattern>
  20         </encoder>
  21     </appender>
  22 
  23     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  24         <layout class="ch.qos.logback.classic.PatternLayout">
  25                 <Pattern>%yellow(%date{ISO8601}) %green([%thread]) %highlight(%-5level) %cyan(%logger{35}) - %white(%msg%n) </Pattern>
  26         </layout>
  27     </appender>
  28 
  29     <root level="INFO">
  30         <appender-ref ref="FILE" />
  31         <appender-ref ref="CONSOLE"/>
  32     </root>
  33 
  34     <logger name="hello.GreetingController" level="debug" additivity="false">
  35         <appender-ref ref="GREETFILE"/>
  36         <appender-ref ref="CONSOLE" />
  37     </logger>
  38 
  39 </configuration>

src/main/resources/test.sql

   1 --JDBC URL: jdbc:mariadb://localhost:3306/springmvchtml
   2 --mysql -u root -p
   3 create database springmvchtml;
   4 create user 'usertest'@'%' identified by '????????';
   5 create user 'usertest'@'localhost' identified by '????????';
   6 grant all on springmvchtml.* to 'usertest'@'%';
   7 grant all on springmvchtml.* to 'usertest'@'localhost';
   8 show grants for 'usertest'@'%';
   9 show grants for 'usertest'@'localhost';
  10 create table springmvchtml.dummy (name varchar(255) ) ;
  11 insert into springmvchtml.dummy (name) values('aaaa');
  12 insert into springmvchtml.dummy (name) values('bbbb');
  13 commit;
  14 -- mysql -u usertest -p
  15

JAR files list

   1 jar tf target/test-spring-boot-0.1.0.jar | grep "\.jar"

BOOT-INF/lib/jackson-core-2.8.1.jar
BOOT-INF/lib/spring-web-4.3.2.RELEASE.jar
BOOT-INF/lib/unbescape-1.1.0.RELEASE.jar
BOOT-INF/lib/javassist-3.20.0-GA.jar
BOOT-INF/lib/mariadb-java-client-1.4.4.jar
BOOT-INF/lib/jul-to-slf4j-1.7.21.jar
BOOT-INF/lib/groovy-2.4.7.jar
BOOT-INF/lib/hibernate-validator-5.2.4.Final.jar
BOOT-INF/lib/classmate-1.3.1.jar
BOOT-INF/lib/tomcat-embed-el-8.5.4.jar
BOOT-INF/lib/tomcat-embed-core-8.5.4.jar
BOOT-INF/lib/commons-pool-1.6.jar
BOOT-INF/lib/thymeleaf-spring4-2.1.5.RELEASE.jar
BOOT-INF/lib/spring-context-4.3.2.RELEASE.jar
BOOT-INF/lib/thymeleaf-2.1.5.RELEASE.jar
BOOT-INF/lib/spring-boot-starter-tomcat-1.4.0.RELEASE.jar
BOOT-INF/lib/thymeleaf-layout-dialect-1.4.0.jar
BOOT-INF/lib/spring-boot-autoconfigure-1.4.0.RELEASE.jar
BOOT-INF/lib/snakeyaml-1.17.jar
BOOT-INF/lib/spring-boot-starter-web-1.4.0.RELEASE.jar
BOOT-INF/lib/spring-boot-starter-logging-1.4.0.RELEASE.jar
BOOT-INF/lib/spring-webmvc-4.3.2.RELEASE.jar
BOOT-INF/lib/spring-beans-4.3.2.RELEASE.jar
BOOT-INF/lib/slf4j-api-1.7.21.jar
BOOT-INF/lib/spring-jdbc-4.3.2.RELEASE.jar
BOOT-INF/lib/jackson-annotations-2.8.1.jar
BOOT-INF/lib/commons-dbcp-1.4.jar
BOOT-INF/lib/ognl-3.0.8.jar
BOOT-INF/lib/spring-boot-starter-1.4.0.RELEASE.jar
BOOT-INF/lib/tomcat-embed-websocket-8.5.4.jar
BOOT-INF/lib/spring-boot-starter-thymeleaf-1.4.0.RELEASE.jar
BOOT-INF/lib/spring-tx-4.3.2.RELEASE.jar
BOOT-INF/lib/logback-classic-1.1.7.jar
BOOT-INF/lib/spring-boot-1.4.0.RELEASE.jar
BOOT-INF/lib/spring-expression-4.3.2.RELEASE.jar
BOOT-INF/lib/logback-core-1.1.7.jar
BOOT-INF/lib/validation-api-1.1.0.Final.jar
BOOT-INF/lib/spring-core-4.3.2.RELEASE.jar
BOOT-INF/lib/jackson-databind-2.8.1.jar
BOOT-INF/lib/jcl-over-slf4j-1.7.21.jar
BOOT-INF/lib/log4j-over-slf4j-1.7.21.jar
BOOT-INF/lib/spring-aop-4.3.2.RELEASE.jar
BOOT-INF/lib/jboss-logging-3.3.0.Final.jar

Add HTTPS/SSL support

Keystore creation

   1 #create keystore with key springboot
   2 keytool -genkey -alias springboot -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore springboot.p12 -validity 3650
   3 
   4 #Enter keystore password: 12345678
   5 #Re-enter new password: 12345678
   6 #What is your first and last name?
   7 #  [Unknown]:  Spring Boot
   8 #What is the name of your organizational unit?
   9 #  [Unknown]:  Boot
  10 #What is the name of your organization?
  11 #  [Unknown]:  Boot
  12 #What is the name of your City or Locality?
  13 #  [Unknown]:  Lisbon
  14 #What is the name of your State or Province?
  15 #  [Unknown]:  Estremadura
  16 #What is the two-letter country code for this unit?
  17 #  [Unknown]:  PT
  18 #Is CN=Spring Boot, OU=Boot, O=Boot, L=Lisbon, ST=Estremadura, C=PT correct?
  19 #  [no]:  yes
  20 
  21 #list keys 
  22 keytool -list -v -keystore springboot.p12 -storetype pkcs12

Code to add in Application class/configuration

   1 // import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
   2 // import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
   3 // import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
   4 // import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
   5 // import java.io.FileNotFoundException;
   6 // import org.apache.catalina.connector.Connector;
   7 // import org.springframework.beans.factory.annotation.Value;
   8 // import javax.inject.Inject;
   9 // import org.springframework.util.ResourceUtils;
  10 
  11 public class TCC implements TomcatConnectorCustomizer{
  12     private String keystoreFile;
  13     private String keystorePassword;
  14     private String keystoreType;
  15     private String keystoreAlias;
  16 
  17     public TCC(String keystoreFile, String keystorePassword, String keystoreType, String keystoreAlias){
  18         this.keystoreFile=keystoreFile;
  19         this.keystorePassword=keystorePassword;
  20         this.keystoreType=keystoreType;
  21         this.keystoreAlias=keystoreAlias;
  22     }
  23 
  24     public void customize(Connector connector){
  25         connector.setSecure(true);
  26         connector.setScheme("https");
  27         connector.setAttribute("keystoreFile", keystoreFile);
  28         connector.setAttribute("keystorePass", keystorePassword);
  29         connector.setAttribute("keystoreType", keystoreType);
  30         connector.setAttribute("keyAlias", keystoreAlias);
  31         connector.setAttribute("clientAuth", "false");
  32         connector.setAttribute("sslProtocol", "TLS");
  33         connector.setAttribute("SSLEnabled", true);
  34     }
  35 }
  36 
  37 public class ESCC implements EmbeddedServletContainerCustomizer{
  38     private String keystoreFile;
  39     private String keystorePassword;
  40     private String keystoreType;
  41     private String keystoreAlias;
  42 
  43     public ESCC(String keystoreFile, String keystorePassword, String keystoreType, String keystoreAlias){
  44         this.keystoreFile=keystoreFile;
  45         this.keystorePassword=keystorePassword;
  46         this.keystoreType=keystoreType;
  47         this.keystoreAlias=keystoreAlias;
  48     }
  49 
  50     public void customize(ConfigurableEmbeddedServletContainer container){
  51         TomcatEmbeddedServletContainerFactory containerFactory = (TomcatEmbeddedServletContainerFactory) container;
  52 
  53         TomcatConnectorCustomizer tcc = new TCC(keystoreFile,keystorePassword,keystoreType,keystoreAlias);
  54         containerFactory.addConnectorCustomizers(tcc);
  55     }
  56 }
  57 
  58 @Bean
  59 @Inject
  60 public EmbeddedServletContainerCustomizer containerCustomizer(
  61     @Value("${keystore.file}") String keystoreFile,
  62     @Value("${keystore.password}") String keystorePassword,
  63     @Value("${keystore.type}") String keystoreType,
  64     @Value("${keystore.alias}") String keystoreAlias) throws FileNotFoundException
  65 {
  66     final String absoluteKeystoreFile = ResourceUtils.getFile(keystoreFile).getAbsolutePath();
  67     EmbeddedServletContainerCustomizer escc = new ESCC(absoluteKeystoreFile,keystorePassword,keystoreType,keystoreAlias);
  68     return escc;
  69 }

pom.xml

   1 <!-- Add dependency to support @Inject annotation -->
   2 <dependency>
   3     <groupId>javax.inject</groupId>
   4     <artifactId>javax.inject</artifactId>
   5     <version>1</version>
   6 </dependency>

Add server.port=8443 to application.properties or use system property -Dserver.port=8443
Run java -Dfilelog=/tmp/out.log -Dkeystore.file=springboot.p12 -Dkeystore.password=12345678 -Dkeystore.type=PKCS12 -Dkeystore.alias=springboot -jar target/test-spring-boot-0.1.0.jar
Access https://localhost:8443/greeting?name=x

Environment variables

src/main/resources/application.properties

logging.file=/tmp/testout.log
server.port=8443
foo.bar=bohica

   1 import javax.annotation.Resource;
   2 import org.springframework.core.env.Environment;
   3 import org.springframework.beans.factory.annotation.Value;
   4 //....................
   5     @Resource
   6     Environment env;
   7     @Value("${foo.bar}")
   8     private String fooBar;
   9 
  10     @RequestMapping(value="/env",produces="application/json")
  11     @ResponseBody
  12     public List<String> getEnv(){
  13       List<String> ret = new ArrayList<String>();
  14       ret.add( env.getProperty("foo.bar") );
  15       ret.add(fooBar);
  16       return ret;
  17     }
  18 //....................
  19

Override value in application.properties

   1 java -jar target/test-spring-boot-0.1.0.jar --foo.bar=snafu

It's also possible to override values with environment variables as for example

FOO_BAR=snafu java -jar target/test-spring-boot-0.1.0.jar

The *.* should be replaced by *_* and the lowercase characters must be capitalized.

Instead of using @Autowired or @Inject use @Resource (javax.annotation.Resource).

Example JPA RabbitMQ HttpSession Redis

Structure

.
./pom.xml
./src
./src/main
./src/main/java
./src/main/java/hello
./src/main/java/hello/GreetingController.java
./src/main/java/hello/Application.java
./src/main/java/hello/ThreadTimer.java
./src/main/java/hello/WaitThread.java
./src/main/java/hello/Dummy.java
./src/main/java/hello/DummyDAO.java
./src/main/java/hello/DummyJPA.java
./src/main/java/hello/MessageHandler.java
./src/main/java/hello/BroadcastMessageHandler.java
./src/main/java/hello/ConfigHttpSession.java
./src/main/resources
./src/main/resources/templates
./src/main/resources/templates/greeting.html
./src/main/resources/application.properties
./src/main/resources/logback-spring.xml
./src/main/resources/test.sql
./src/main/resources/META-INF
./src/main/resources/META-INF/persistence.xml

WaitThread.java

   1 package hello;
   2 
   3 import org.springframework.stereotype.Component;
   4 import javax.annotation.PostConstruct;
   5 import java.text.MessageFormat;
   6 import org.slf4j.Logger;
   7 import org.slf4j.LoggerFactory;
   8 import org.springframework.beans.factory.annotation.Autowired;
   9 
  10 @Component
  11 public class WaitThread extends Thread {
  12   private Logger logger;
  13   private boolean running;
  14   private Object monitor;
  15 
  16   @Autowired
  17   ThreadTimer timerThread;
  18 
  19   public WaitThread() {    
  20     this.logger = LoggerFactory.getLogger(WaitThread.class);
  21     logger.info("Created instance of " + this.getClass().getSimpleName());
  22     this.running = true;
  23     this.setName(this.getClass().getSimpleName() + "_" + this.getName());
  24     this.monitor=new Object();
  25   }
  26 
  27   @PostConstruct
  28   public void init() {
  29     this.timerThread.addSubscriber(this);
  30     logger.info("Starting the thread");
  31     this.start();
  32   }
  33 
  34   public void run() {
  35     while (running) {
  36       try {
  37         synchronized(this){
  38           this.wait();
  39           logger.info("Notification received.");
  40         }
  41       }
  42       catch (InterruptedException e) {
  43           logger.info("ThreadTimer interrupted exception:" + e.getMessage() );
  44       }
  45       catch (Exception e) {
  46           logger.info("WaitThread exception:" + e.getMessage() );
  47           stopRunning();
  48       }      
  49     }
  50     logger.info("Exited " + this.getClass().getSimpleName());
  51   }
  52 
  53   public void startRunning() {
  54     this.running = true;
  55   }
  56 
  57   public void stopRunning() {
  58     this.running = false;
  59   }
  60   
  61   public void destroy(){
  62     logger.info("Called destroy");
  63     this.stopRunning();
  64     this.interrupt();    
  65   }
  66 }

ThreadTimer.java

   1 package hello;
   2 
   3 import org.springframework.stereotype.Component;
   4 import javax.annotation.PostConstruct;
   5 import org.springframework.beans.factory.annotation.Autowired;
   6 import java.text.MessageFormat;
   7 import org.slf4j.Logger;
   8 import org.slf4j.LoggerFactory;
   9 import java.util.ArrayList;
  10 
  11 @Component
  12 public class ThreadTimer extends Thread {
  13   private int delaySeconds;
  14   private Logger logger;
  15   private boolean running;
  16   private Object monitor=new Object();
  17   private ArrayList<Object> subscribers;
  18 
  19   public ThreadTimer() {    
  20     this.logger = LoggerFactory.getLogger(ThreadTimer.class);
  21     logger.info("Created instance of " + this.getClass().getSimpleName());
  22     this.running = true;
  23     this.delaySeconds = 5 * 1000;
  24     this.setName(this.getClass().getSimpleName() + "_" + this.getName());
  25     this.subscribers = new ArrayList<Object>();
  26   }
  27 
  28   public void addSubscriber(Object subscriber){
  29     this.subscribers.add(subscriber);
  30   }
  31 
  32   @PostConstruct
  33   public void init() {
  34     logger.info("Starting the thread");
  35     this.start();
  36   }
  37 
  38   @Override
  39   public void run() {
  40     while (running) {
  41       try {
  42         Thread.sleep(this.delaySeconds);
  43         logger.info("Delay " + this.getClass().getSimpleName());
  44 
  45         for(Object o: this.subscribers){
  46           synchronized(o){
  47             o.notify();
  48           }
  49         }
  50       }
  51       catch (InterruptedException e) {
  52           logger.info("ThreadTimer interrupted exception:" + e.getMessage() );
  53       }
  54       catch (Exception e) {
  55           e.printStackTrace();
  56           logger.info("ThreadTimer exception:" + e.getMessage() );
  57           stopRunning();
  58       }      
  59     }
  60     logger.info("Exited " + this.getClass().getSimpleName());
  61   }
  62 
  63   public void startRunning() {
  64     this.running = true;
  65   }
  66 
  67   public void stopRunning() {
  68     this.running = false;
  69   }
  70   
  71   public void destroy(){
  72     logger.info("Called destroy");
  73     this.stopRunning();
  74     this.interrupt();    
  75   }
  76 }

MessageHandler.java

   1 package hello;
   2 
   3 import java.nio.charset.StandardCharsets;
   4 import org.slf4j.Logger;
   5 import org.slf4j.LoggerFactory;
   6 
   7 public class MessageHandler{
   8     private final Logger logger = LoggerFactory.getLogger(MessageHandler.class);
   9     
  10     public void handleMessage(byte[] message){
  11         String msg = new String(message, StandardCharsets.UTF_8);
  12         logger.info("Received msg " + msg   );
  13     }
  14 
  15     public void handleMessage(String message){
  16         logger.info("Received msg " + message   );
  17     }
  18 
  19 }

GreetingController.java

   1 package hello;
   2 
   3 import org.springframework.stereotype.Controller;
   4 import org.springframework.ui.Model;
   5 import org.springframework.web.bind.annotation.RequestMapping;
   6 import org.springframework.web.bind.annotation.RequestParam;
   7 
   8 import org.slf4j.Logger;
   9 import org.slf4j.LoggerFactory;
  10 import org.springframework.web.bind.annotation.ResponseBody;
  11 import org.springframework.beans.factory.annotation.Autowired;
  12 
  13 import java.util.List;
  14 import java.util.ArrayList;
  15 import org.springframework.web.bind.annotation.PathVariable;
  16 //import javax.inject.Inject;
  17 import org.springframework.core.env.Environment;
  18 import org.springframework.beans.factory.annotation.Value;
  19 import javax.annotation.Resource;
  20 
  21 import org.springframework.amqp.rabbit.core.RabbitTemplate;
  22 import javax.servlet.http.HttpSession;
  23 
  24 @Controller
  25 public class GreetingController {
  26     private final Logger logger = LoggerFactory.getLogger(GreetingController.class);
  27     @Resource
  28     DummyDAO dummyDAO;
  29 
  30     @Resource
  31     Environment env;
  32 
  33     @Resource
  34     RabbitTemplate rabbitTemplate;
  35  
  36     @Value("${instance.name}")
  37     String instanceName;
  38     
  39     public GreetingController(){
  40         logger.debug("Greeting controller created.");
  41     }
  42 
  43     @RequestMapping("/greeting")
  44     public String greeting(@RequestParam(value="name", required=false, defaultValue="World") String name, Model model  ) {        
  45         model.addAttribute("name", name);
  46         rabbitTemplate.convertAndSend("topicExchange","myQueue", name  );
  47         rabbitTemplate.convertAndSend("fanoutExchange","", name  );
  48         return "greeting";
  49     }
  50 
  51     @RequestMapping("/setvalue/{value}")
  52     @ResponseBody
  53     public String setValue(@PathVariable("value") String value, Model model,HttpSession httpSession) {
  54         httpSession.setAttribute("name", value );
  55         return httpSession.getId();
  56     }
  57 
  58     @RequestMapping("/getvalue")
  59     @ResponseBody
  60     public String setValue(Model model,HttpSession httpSession) {
  61         return (String) httpSession.getAttribute("name");        
  62     }
  63     
  64     @RequestMapping("/instancename")
  65     @ResponseBody
  66     public String setValue(Model model) {
  67         return this.instanceName;        
  68     }
  69     
  70     @RequestMapping("/greeting/add/{name}")
  71     public String addGreeting(@PathVariable("name") String name, Model model) {
  72         model.addAttribute("name", name);
  73         dummyDAO.addName(name);
  74         return "greeting";
  75     }
  76     
  77     @RequestMapping(value="/dummy",produces="application/json")
  78     @ResponseBody
  79     public List<DummyJPA> dummy(){
  80       return dummyDAO.getAllNames();
  81     }
  82 
  83     @RequestMapping(value="/dummyname",produces="application/json")
  84     @ResponseBody
  85     public String getDummyName(){
  86       return dummyDAO.getNameFromDummy();
  87     }
  88 
  89     @Value("${foo.bar}")
  90     private String fooBar;
  91 
  92     @RequestMapping(value="/env",produces="application/json")
  93     @ResponseBody
  94     public List<String> getEnv(){
  95       List<String> ret = new ArrayList<String>(); 
  96       ret.add( env.getProperty("foo.bar") );
  97       ret.add(fooBar);
  98       return ret;
  99     }
 100     
 101 }

DummyJPA.java

   1 package hello;
   2 
   3 import javax.persistence.Entity;
   4 import javax.persistence.GeneratedValue;
   5 import javax.persistence.GenerationType;
   6 import javax.persistence.Id;
   7 import javax.persistence.NamedQuery;
   8 import javax.persistence.NamedQueries;
   9 
  10 @Entity
  11 @NamedQueries({
  12     @NamedQuery(name="DummyJPA.getAll",  query="Select e From DummyJPA e")
  13 })
  14 public class DummyJPA{
  15   @Id
  16   @GeneratedValue(strategy=GenerationType.AUTO)
  17   private Long id;
  18   private String dummy;
  19 
  20   public DummyJPA(){
  21   } 
  22 
  23   public String getDummy(){
  24     return this.dummy;
  25   }
  26 
  27   public void setDummy(String dummy){
  28     this.dummy=dummy;
  29   }
  30 
  31   @Override
  32   public String toString(){
  33     return String.format("Dummy %s", this.dummy);
  34   }
  35 }

DummyDAO.java

   1 package hello;
   2 
   3 import org.slf4j.Logger;
   4 import org.slf4j.LoggerFactory;
   5 import org.springframework.beans.factory.annotation.Autowired;
   6 import org.springframework.beans.factory.annotation.Qualifier;
   7 import org.springframework.jdbc.core.JdbcTemplate;
   8 import org.springframework.stereotype.Component;
   9 import javax.persistence.PersistenceContext;
  10 import javax.persistence.EntityManager;
  11 import javax.persistence.Query;
  12 import javax.transaction.Transactional;
  13 import java.util.List;
  14 
  15 @Component
  16 public class DummyDAO {
  17   @Autowired
  18   @Qualifier("jdbcTemplate")
  19   private JdbcTemplate jdbcTemplate;
  20   private Logger logger;
  21 
  22   @PersistenceContext(unitName="default")
  23   EntityManager em;
  24 
  25   public DummyDAO() {
  26     logger = LoggerFactory.getLogger(DummyDAO.class);
  27     logger.info("Created " + this.getClass().getSimpleName());
  28   }
  29 
  30   public String getNameFromDummy() {
  31     return this.jdbcTemplate.queryForObject("select name from dummy limit 1", String.class);
  32   }
  33 
  34   @Transactional
  35   public void addName(String name){
  36     DummyJPA djpa = new DummyJPA();
  37     djpa.setDummy(name);
  38     em.persist(djpa);
  39   }
  40 
  41   @Transactional
  42   public List<DummyJPA> getAllNames(){
  43     return em.createNamedQuery("DummyJPA.getAll",DummyJPA.class).getResultList();
  44   }
  45 
  46 }

Dummy.java

   1 package hello;
   2 
   3 public class Dummy{
   4   private String fieldA;
   5   private String fieldB;
   6   
   7   public Dummy(){
   8   }
   9 
  10   public String getFieldA(){
  11     return fieldA;
  12   }
  13   
  14   public String getFieldB(){
  15     return fieldB;
  16   }
  17   
  18   public void setFieldA(String arg){
  19     fieldA = arg;
  20   }
  21   
  22   public void setFieldB(String arg){
  23     fieldB = arg;
  24   }
  25 }

ConfigHttpSession.java

   1 /* 
   2 http://docs.spring.io/spring-session/docs/current/reference/html5/guides/boot.html
   3 
   4 pkg install redis #freebsd
   5 add redis_enable="YES" to /etc/rc.conf
   6 /usr/local/etc/rc.d/redis start
   7 
   8 /usr/local/etc/redis.conf
   9 requirepass 12345678
  10 
  11 keys *
  12 hgetall <hashkey>
  13 
  14 Same as in application.properties spring.redis.password=12345678
  15 
  16 https://localhost:8443/setvalue/valx
  17 147569e4-9e6d-4363-a373-b20261513f11
  18 
  19 https://localhost:8443/getvalue
  20 SESSION=147569e4-9e6d-4363-a373-b20261513f11
  21 
  22 2 instances of spring boot using the same redis server
  23 curl -k -v --cookie "SESSION=147569e4-9e6d-4363-a373-b20261513f11" https://localhost:8443/getvalue
  24 curl -k -v --cookie "SESSION=147569e4-9e6d-4363-a373-b20261513f11" https://localhost:8444/getvalue 
  25 */
  26 package hello;
  27 
  28 import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
  29 
  30 @EnableRedisHttpSession
  31 public class ConfigHttpSession{
  32     // springSessionRepositoryFilterbean is responsible for replacing the HttpSession with a custom implementation that is backed by Spring Session.    
  33 }

BroadcastMessageHandler.java

   1 package hello;
   2 
   3 import java.nio.charset.StandardCharsets;
   4 import org.slf4j.Logger;
   5 import org.slf4j.LoggerFactory;
   6 
   7 public class BroadcastMessageHandler{
   8     private final Logger logger = LoggerFactory.getLogger(BroadcastMessageHandler.class);
   9     
  10     public void handleMessage(byte[] message){
  11         String msg = new String(message, StandardCharsets.UTF_8);
  12         logger.info("Received msg " + msg   );
  13     }
  14 
  15     public void handleMessage(String message){
  16         logger.info("Received msg " + message   );
  17     }
  18 }

Application.java

   1 package hello;
   2 
   3 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   4 import org.springframework.boot.SpringApplication;
   5 import org.springframework.context.annotation.ComponentScan;
   6 import org.springframework.context.annotation.Bean;
   7 import org.springframework.beans.factory.annotation.Autowired;
   8 import org.springframework.beans.factory.annotation.Qualifier;
   9 import org.apache.commons.dbcp.BasicDataSource;
  10 import org.springframework.jdbc.core.JdbcTemplate;
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13 import org.springframework.boot.autoconfigure.domain.EntityScan;
  14 import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
  15 import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
  16 import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
  17 import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
  18 import java.io.FileNotFoundException;
  19 import org.apache.catalina.connector.Connector;
  20 import org.springframework.beans.factory.annotation.Value;
  21 import javax.inject.Inject;
  22 import javax.annotation.Resource;
  23 import org.springframework.util.ResourceUtils;
  24 import org.springframework.core.env.Environment;
  25 
  26 //-- rabbit
  27 import org.springframework.amqp.core.Binding;
  28 import org.springframework.amqp.core.BindingBuilder;
  29 import org.springframework.amqp.core.Queue;
  30 import org.springframework.amqp.core.TopicExchange;
  31 import org.springframework.amqp.core.FanoutExchange;
  32 import org.springframework.amqp.core.AnonymousQueue;
  33 import org.springframework.amqp.rabbit.connection.ConnectionFactory;
  34 import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
  35 import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
  36 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
  37 import java.net.URI;
  38 //-- rabbit
  39 
  40 @ComponentScan
  41 @EnableAutoConfiguration
  42 @EntityScan(basePackages="hello")
  43 public class Application {
  44     @Resource
  45     Environment env;
  46 
  47     private static Logger logger;
  48 
  49     public static void main(String[] args) {
  50         logger = LoggerFactory.getLogger(Application.class);
  51         logger.info("Starting application");
  52         SpringApplication.run(Application.class, args);
  53     }
  54 
  55     @Bean(name="basicDataSource",destroyMethod="close") 
  56     public BasicDataSource createBasicDataSource(){
  57       logger.info("Creating basicDataSource");
  58       BasicDataSource bds = new BasicDataSource();
  59       // get config data from application.properties
  60       bds.setDriverClassName(env.getProperty("db.driverclass") );
  61       bds.setUrl(env.getProperty("db.jdbcurl") );
  62       bds.setUsername( env.getProperty("db.username") );
  63       bds.setPassword( env.getProperty("db.password") );
  64       bds.setInitialSize( Integer.parseInt( env.getProperty("db.initialsizeconnpool")) );
  65       return bds;
  66     }
  67 
  68     @Bean(name="jdbcTemplate")
  69     public JdbcTemplate createJdbcTemplate(@Autowired @Qualifier("basicDataSource") BasicDataSource bds  ){
  70       logger.info("Creating jdbcTemplate");
  71       return new JdbcTemplate( bds );
  72     }
  73 
  74 //---  
  75     public class TCC implements TomcatConnectorCustomizer{
  76         Environment env;
  77 
  78         public TCC(Environment env){ 
  79             this.env=env;  
  80         }  
  81 
  82         public void customize(Connector connector){
  83             String absoluteKeystoreFile = "";
  84             logger.info(String.format("Keystore file: %s" , env.getProperty("keystore.file")   )); 
  85 
  86             try{ 
  87                 absoluteKeystoreFile = ResourceUtils.getFile(env.getProperty("keystore.file")).getAbsolutePath(); 
  88                 logger.info(String.format("Absolute path keystore: %s" , absoluteKeystoreFile )  );
  89             }
  90             catch(Exception ex){
  91               logger.error( ex.getMessage() );
  92             }
  93 
  94             connector.setSecure(true);
  95             connector.setScheme("https");
  96             connector.setAttribute("keystoreFile", absoluteKeystoreFile);
  97             connector.setAttribute("keystorePass", env.getProperty("keystore.password"));
  98             connector.setAttribute("keystoreType", env.getProperty("keystore.type"));
  99             connector.setAttribute("keyAlias", env.getProperty("keystore.alias")  );
 100             connector.setAttribute("clientAuth", "false");
 101             connector.setAttribute("sslProtocol", "TLS");
 102             connector.setAttribute("SSLEnabled", true);
 103         } 
 104     }
 105 
 106     public class ESCC implements EmbeddedServletContainerCustomizer{
 107         Environment env;
 108 
 109         public ESCC(Environment env){ 
 110             this.env=env;  
 111         }
 112 
 113         public void customize(ConfigurableEmbeddedServletContainer container){
 114             TomcatEmbeddedServletContainerFactory containerFactory = (TomcatEmbeddedServletContainerFactory) container;            
 115             TomcatConnectorCustomizer tcc = new TCC(env);
 116             containerFactory.addConnectorCustomizers(tcc);
 117         }
 118     }
 119 
 120     @Bean(name="containerCustomizer")
 121     public EmbeddedServletContainerCustomizer containerCustomizer() 
 122     throws FileNotFoundException {
 123         logger.info("Creating containerCustomizer");
 124         EmbeddedServletContainerCustomizer escc = new ESCC(env);
 125         return escc;
 126     }
 127 //---
 128 
 129 //---- rabbit
 130 
 131 //import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
 132     @Bean(name="cachingConnectionFactory")
 133     CachingConnectionFactory createCachingConnectionFactory(){
 134         logger.info("Creating cachingConnectionFactory");
 135         String uri = env.getProperty("rabbitmq.uri");
 136         URI rabbitmqUri=null;
 137         
 138         try{
 139             rabbitmqUri = new URI(uri);
 140         }
 141         catch(Exception ex){
 142             ex.printStackTrace();
 143         }
 144         
 145         CachingConnectionFactory ret = new CachingConnectionFactory(rabbitmqUri);
 146         logger.info(String.format("Created cachingConnectionFactory with hashCode %d" , ret.hashCode() ) );
 147         return ret;
 148     }
 149     
 150     @Bean(name="myQueue")
 151     Queue createMyQueue() {
 152         logger.info("Creating myQueue");
 153         return new Queue("myQueue", false);
 154     }
 155 
 156     @Bean(name="topicExchange")
 157     TopicExchange createTopicExchange() {
 158         logger.info("Creating topicExchange");
 159         return new TopicExchange("topicExchange");
 160     }
 161 
 162     @Bean(name="bindingQueue")
 163     Binding binding(@Qualifier("myQueue")Queue queue, @Qualifier("topicExchange")TopicExchange exchange) {
 164         logger.info("Creating bindingQueue");
 165         return BindingBuilder.bind(queue).to(exchange).with(queue.getName());
 166     }
 167 
 168     @Bean(name="workQueueContainer")
 169     SimpleMessageListenerContainer createWorkQueueContainer(ConnectionFactory connectionFactory, @Autowired @Qualifier("listenerAdapter") MessageListenerAdapter listenerAdapter,@Qualifier("myQueue") Queue queue) {
 170         logger.info("Creating createWorkQueueContainer for work queue");
 171         logger.info(String.format("Using ConnectionFactory with hashCode %d" , connectionFactory.hashCode() ) );
 172         
 173         SimpleMessageListenerContainer smlc = new SimpleMessageListenerContainer();
 174         smlc.setConnectionFactory(connectionFactory);
 175         smlc.setQueueNames(queue.getName() );
 176         smlc.setMessageListener(listenerAdapter);
 177         return smlc;
 178     }
 179     
 180     @Bean(name="listenerAdapter")    
 181     MessageListenerAdapter listenerAdapter(@Autowired @Qualifier("messageHandler")MessageHandler messageHandler) {
 182         logger.info("Creating listenerAdapter");
 183         return new MessageListenerAdapter(messageHandler);
 184     }
 185 
 186     @Bean(name="messageHandler")
 187     MessageHandler createMessageHandler() {
 188         logger.info("Creating messageHandler");
 189         return new MessageHandler();
 190     }
 191     
 192     //--------    
 193     @Bean(name="fanoutExchange")
 194     FanoutExchange createFanoutExchange() {
 195         logger.info("Creating fanoutExchange");
 196         return new FanoutExchange("fanoutExchange");
 197     }
 198 
 199     @Bean(name="anonymousQueue1")
 200     AnonymousQueue createAnonymousQueue1() {
 201         logger.info("Creating anonQueue1");
 202         return new AnonymousQueue();
 203     }
 204 
 205     @Bean(name="bindingTopic")
 206     Binding bindingTopic(@Qualifier("anonymousQueue1")AnonymousQueue queue, @Qualifier("fanoutExchange")FanoutExchange exchange) {
 207         logger.info("Creating bindingTopic");
 208         return BindingBuilder.bind(queue).to(exchange);
 209     }
 210 
 211     @Bean(name="broadcastMessageHandler")
 212     BroadcastMessageHandler createBroadcastMessageHandler() {
 213         logger.info("Creating broadcastMessageHandlermessageHandler");
 214         return new BroadcastMessageHandler();
 215     }
 216     
 217     @Bean(name="broadcastListenerAdapter")    
 218     MessageListenerAdapter createBroadcastlistenerAdapter(@Autowired @Qualifier("broadcastMessageHandler")BroadcastMessageHandler broadcastMessageHandler) {
 219         logger.info("Creating broadcastListenerAdapter");
 220         return new MessageListenerAdapter(broadcastMessageHandler);
 221     }
 222 
 223     @Bean(name="topicContainer")
 224     SimpleMessageListenerContainer createTopicContainer(ConnectionFactory connectionFactory, @Autowired @Qualifier("broadcastListenerAdapter") MessageListenerAdapter listenerAdapter, @Qualifier("anonymousQueue1")  AnonymousQueue anonQueue) {
 225         logger.info("Creating container for topic");
 226         logger.info(String.format("Using ConnectionFactory with hashCode %d" , connectionFactory.hashCode() ) );
 227         
 228         SimpleMessageListenerContainer smlc = new SimpleMessageListenerContainer();
 229         smlc.setConnectionFactory(connectionFactory);
 230         smlc.setQueueNames( anonQueue.getName() );
 231         smlc.setMessageListener(listenerAdapter);
 232         return smlc;
 233     }
 234     
 235     //----
 236 //---- rabbit
 237 }

persistence.xml

   1 <persistence>
   2     <persistence-unit name="default" transaction-type="RESOURCE_LOCAL">
   3         <jta-data-source>basicDataSource</jta-data-source>
   4         <properties>
   5             <!-- <property name="hibernate.hbm2ddl.auto" value="create-drop" /> -->
   6             <property name="hibernate.hbm2ddl.auto" value="update" />
   7             <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
   8             <property name="hibernate.show_sql" value="false" />
   9         </properties>
  10     </persistence-unit>
  11 </persistence>

greeting.html

   1 <!DOCTYPE HTML>
   2 <html xmlns:th="http://www.thymeleaf.org">
   3 <head>
   4     <title>Getting Started: Serving Web Content</title>
   5     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
   6 </head>
   7 <body>
   8     <p th:text="'Hello, ' + ${name} + '!'" />
   9 </body>
  10 </html>

test.sql

   1 --JDBC URL: jdbc:mariadb://localhost:3306/springmvchtml
   2 --mysql -u root -p
   3 create database springmvchtml;
   4 create user 'usertest'@'%' identified by '????';
   5 create user 'usertest'@'localhost' identified by '????';
   6 grant all on springmvchtml.* to 'usertest'@'%';
   7 grant all on springmvchtml.* to 'usertest'@'localhost';
   8 show grants for 'usertest'@'%';
   9 show grants for 'usertest'@'localhost'; 
  10 create table springmvchtml.dummy (name varchar(255) ) ;
  11 insert into springmvchtml.dummy (name) values('aaaa');
  12 insert into springmvchtml.dummy (name) values('bbbb');
  13 commit;
  14 -- mysql -u usertest -p
  15

logback-spring.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <configuration>
   3 <!--
   4     <include resource="org/springframework/boot/logging/logback/defaults.xml" />
   5     <property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}spring.log}"/>
   6     <include resource="org/springframework/boot/logging/logback/file-appender.xml" />
   7 -->    
   8     <!-- override spring logback default behaviour -->
   9     <appender name="FILE" class="ch.qos.logback.core.FileAppender">
  10         <file>${filelog}</file>
  11         <encoder>
  12                 <pattern>%date{ISO8601} [%thread] %-5level %logger{35} - %msg%n</pattern>
  13         </encoder>
  14     </appender>
  15 
  16     <appender name="GREETFILE" class="ch.qos.logback.core.FileAppender">
  17         <file>/tmp/greet.log</file>
  18         <encoder>
  19                 <pattern>%date{ISO8601} [%thread] %-5level %logger{35} - %msg%n</pattern>
  20         </encoder>
  21     </appender>
  22 
  23     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  24         <layout class="ch.qos.logback.classic.PatternLayout">
  25                 <Pattern>%yellow(%date{ISO8601}) %green([%thread]) %highlight(%-5level) %cyan(%logger{35}) - %white(%msg%n) </Pattern>
  26         </layout>
  27     </appender>
  28 
  29     <root level="INFO">
  30         <appender-ref ref="FILE" />
  31         <appender-ref ref="CONSOLE"/>
  32     </root>
  33 
  34     <logger name="hello.GreetingController" level="debug" additivity="false">
  35         <appender-ref ref="GREETFILE"/>
  36         <appender-ref ref="CONSOLE" />
  37     </logger>
  38 
  39 </configuration>

application.properties

logging.file=/tmp/testout.log
server.port=8443
foo.bar=bohica
instance.name=node1
keystore.file=springboot.p12
keystore.password=????
keystore.type=PKCS12
keystore.alias=springboot

db.driverclass=org.mariadb.jdbc.Driver
db.jdbcurl=jdbc:mariadb://localhost:3306/springmvchtml
db.username=usertest
db.password=????
db.initialsizeconnpool=3
#rabbimq parameters
rabbitmq.uri=amqp://????:????@localhost:5672
#redis 
spring.redis.host=localhost
spring.redis.password=????????
spring.redis.port=6379

pom.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   3     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   4     <modelVersion>4.0.0</modelVersion>
   5     <groupId>hello</groupId>
   6     <artifactId>test-spring-boot</artifactId>
   7     <version>0.1.0</version>
   8     <parent>
   9         <groupId>org.springframework.boot</groupId>
  10         <artifactId>spring-boot-starter-parent</artifactId>
  11         <version>1.4.0.RELEASE</version>
  12     </parent>
  13     <dependencies>
  14         <dependency>
  15             <groupId>org.springframework.boot</groupId>
  16             <artifactId>spring-boot-starter-thymeleaf</artifactId>
  17         </dependency>
  18         <dependency>
  19             <groupId>org.mariadb.jdbc</groupId>
  20             <artifactId>mariadb-java-client</artifactId>
  21             <version>1.4.4</version>
  22         </dependency>
  23         <dependency>
  24             <groupId>commons-dbcp</groupId>
  25             <artifactId>commons-dbcp</artifactId>
  26             <version>1.4</version>
  27         </dependency>
  28          <dependency>
  29             <groupId>org.springframework</groupId>
  30             <artifactId>spring-jdbc</artifactId>
  31             <version>4.3.2.RELEASE</version>
  32         </dependency> 
  33        <dependency>
  34             <groupId>org.springframework.boot</groupId>
  35             <artifactId>spring-boot-starter-data-jpa</artifactId>
  36         </dependency>
  37         <dependency>
  38             <groupId>org.springframework.boot</groupId>
  39             <artifactId>spring-boot-starter-amqp</artifactId>
  40         </dependency>
  41         <dependency>
  42             <groupId>javax.inject</groupId>
  43             <artifactId>javax.inject</artifactId>
  44             <version>1</version>
  45         </dependency>
  46         <!-- http session redis -->
  47         <dependency>
  48             <groupId>org.springframework.session</groupId>
  49             <artifactId>spring-session</artifactId>
  50             <version>1.2.2.RELEASE</version>
  51         </dependency>
  52         <dependency>
  53             <groupId>org.springframework.boot</groupId>
  54             <artifactId>spring-boot-starter-data-redis</artifactId>
  55         </dependency>        
  56         <!-- http session redis -->
  57     </dependencies>
  58     <properties>
  59         <start-class>hello.Application</start-class>
  60     </properties>
  61     <build>
  62         <plugins>
  63             <plugin>
  64                 <groupId>org.springframework.boot</groupId>
  65                 <artifactId>spring-boot-maven-plugin</artifactId>
  66             </plugin>
  67         </plugins>
  68     </build>
  69     <repositories>
  70         <repository>
  71             <id>spring-milestone</id>
  72             <url>http://repo.spring.io/libs-release</url>
  73         </repository>
  74     </repositories>
  75     <pluginRepositories>
  76         <pluginRepository>
  77             <id>spring-milestone</id>
  78             <url>http://repo.spring.io/libs-release</url>
  79         </pluginRepository>
  80     </pluginRepositories>
  81 </project>

Libs

   1 -rw-r--r--  1 vitor  vitor    37M Sep 29 15:49 test-spring-boot-0.1.0.jar
   2 jar tf test-spring-boot-0.1.0.jar | grep BOOT | grep jar
   3 BOOT-INF/lib/spring-session-1.2.2.RELEASE.jar
   4 BOOT-INF/lib/spring-boot-starter-data-redis-1.4.0.RELEASE.jar
   5 BOOT-INF/lib/jackson-core-2.8.1.jar
   6 BOOT-INF/lib/javassist-3.20.0-GA.jar
   7 BOOT-INF/lib/jul-to-slf4j-1.7.21.jar
   8 BOOT-INF/lib/groovy-2.4.7.jar
   9 BOOT-INF/lib/spring-amqp-1.6.1.RELEASE.jar
  10 BOOT-INF/lib/hibernate-validator-5.2.4.Final.jar
  11 BOOT-INF/lib/classmate-1.3.1.jar
  12 BOOT-INF/lib/hibernate-commons-annotations-5.0.1.Final.jar
  13 BOOT-INF/lib/tomcat-embed-el-8.5.4.jar
  14 BOOT-INF/lib/jedis-2.8.2.jar
  15 BOOT-INF/lib/httpcore-4.4.5.jar
  16 BOOT-INF/lib/antlr-2.7.7.jar
  17 BOOT-INF/lib/xml-apis-1.4.01.jar
  18 BOOT-INF/lib/spring-boot-starter-tomcat-1.4.0.RELEASE.jar
  19 BOOT-INF/lib/thymeleaf-layout-dialect-1.4.0.jar
  20 BOOT-INF/lib/spring-boot-autoconfigure-1.4.0.RELEASE.jar
  21 BOOT-INF/lib/snakeyaml-1.17.jar
  22 BOOT-INF/lib/http-client-1.0.0.RELEASE.jar
  23 BOOT-INF/lib/httpclient-4.5.2.jar
  24 BOOT-INF/lib/spring-boot-starter-logging-1.4.0.RELEASE.jar
  25 BOOT-INF/lib/tomcat-jdbc-8.5.4.jar
  26 BOOT-INF/lib/spring-beans-4.3.2.RELEASE.jar
  27 BOOT-INF/lib/spring-jdbc-4.3.2.RELEASE.jar
  28 BOOT-INF/lib/spring-boot-starter-jdbc-1.4.0.RELEASE.jar
  29 BOOT-INF/lib/spring-boot-starter-amqp-1.4.0.RELEASE.jar
  30 BOOT-INF/lib/spring-aspects-4.3.2.RELEASE.jar
  31 BOOT-INF/lib/commons-dbcp-1.4.jar
  32 BOOT-INF/lib/spring-data-commons-1.12.2.RELEASE.jar
  33 BOOT-INF/lib/spring-context-support-4.3.2.RELEASE.jar
  34 BOOT-INF/lib/spring-data-keyvalue-1.1.2.RELEASE.jar
  35 BOOT-INF/lib/spring-boot-starter-1.4.0.RELEASE.jar
  36 BOOT-INF/lib/tomcat-embed-websocket-8.5.4.jar
  37 BOOT-INF/lib/commons-logging-1.2.jar
  38 BOOT-INF/lib/spring-tx-4.3.2.RELEASE.jar
  39 BOOT-INF/lib/validation-api-1.1.0.Final.jar
  40 BOOT-INF/lib/spring-core-4.3.2.RELEASE.jar
  41 BOOT-INF/lib/spring-boot-starter-aop-1.4.0.RELEASE.jar
  42 BOOT-INF/lib/spring-data-jpa-1.10.2.RELEASE.jar
  43 BOOT-INF/lib/commons-pool2-2.4.2.jar
  44 BOOT-INF/lib/dom4j-1.6.1.jar
  45 BOOT-INF/lib/tomcat-juli-8.5.4.jar
  46 BOOT-INF/lib/jcl-over-slf4j-1.7.21.jar
  47 BOOT-INF/lib/log4j-over-slf4j-1.7.21.jar
  48 BOOT-INF/lib/aspectjweaver-1.8.9.jar
  49 BOOT-INF/lib/spring-data-redis-1.7.2.RELEASE.jar
  50 BOOT-INF/lib/spring-web-4.3.2.RELEASE.jar
  51 BOOT-INF/lib/unbescape-1.1.0.RELEASE.jar
  52 BOOT-INF/lib/mariadb-java-client-1.4.4.jar
  53 BOOT-INF/lib/amqp-client-3.6.3.jar
  54 BOOT-INF/lib/spring-oxm-4.3.2.RELEASE.jar
  55 BOOT-INF/lib/tomcat-embed-core-8.5.4.jar
  56 BOOT-INF/lib/spring-orm-4.3.2.RELEASE.jar
  57 BOOT-INF/lib/hibernate-jpa-2.1-api-1.0.0.Final.jar
  58 BOOT-INF/lib/commons-pool-1.6.jar
  59 BOOT-INF/lib/thymeleaf-spring4-2.1.5.RELEASE.jar
  60 BOOT-INF/lib/hibernate-core-5.0.9.Final.jar
  61 BOOT-INF/lib/spring-context-4.3.2.RELEASE.jar
  62 BOOT-INF/lib/thymeleaf-2.1.5.RELEASE.jar
  63 BOOT-INF/lib/commons-codec-1.10.jar
  64 BOOT-INF/lib/spring-boot-starter-web-1.4.0.RELEASE.jar
  65 BOOT-INF/lib/spring-webmvc-4.3.2.RELEASE.jar
  66 BOOT-INF/lib/slf4j-api-1.7.21.jar
  67 BOOT-INF/lib/javax.inject-1.jar
  68 BOOT-INF/lib/jackson-annotations-2.8.1.jar
  69 BOOT-INF/lib/jandex-2.0.0.Final.jar
  70 BOOT-INF/lib/spring-messaging-4.3.2.RELEASE.jar
  71 BOOT-INF/lib/ognl-3.0.8.jar
  72 BOOT-INF/lib/hibernate-entitymanager-5.0.9.Final.jar
  73 BOOT-INF/lib/spring-boot-starter-thymeleaf-1.4.0.RELEASE.jar
  74 BOOT-INF/lib/spring-retry-1.1.3.RELEASE.jar
  75 BOOT-INF/lib/javax.transaction-api-1.2.jar
  76 BOOT-INF/lib/logback-classic-1.1.7.jar
  77 BOOT-INF/lib/spring-boot-starter-data-jpa-1.4.0.RELEASE.jar
  78 BOOT-INF/lib/spring-boot-1.4.0.RELEASE.jar
  79 BOOT-INF/lib/spring-expression-4.3.2.RELEASE.jar
  80 BOOT-INF/lib/logback-core-1.1.7.jar
  81 BOOT-INF/lib/jackson-databind-2.8.1.jar
  82 BOOT-INF/lib/spring-rabbit-1.6.1.RELEASE.jar
  83 BOOT-INF/lib/spring-aop-4.3.2.RELEASE.jar
  84 BOOT-INF/lib/jboss-logging-3.3.0.Final.jar

springTestApp

pom.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <project xmlns="http://maven.apache.org/POM/4.0.0" 
   3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   5 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   6   <modelVersion>4.0.0</modelVersion>
   7   <groupId>org.allowed.bitarus</groupId>
   8   <artifactId>springTestApp</artifactId>
   9   <version>0.1.0</version>
  10   <parent>
  11     <groupId>org.springframework.boot</groupId>
  12     <artifactId>spring-boot-starter-parent</artifactId>
  13     <version>1.4.2.RELEASE</version>
  14   </parent>
  15   <dependencies>
  16     <dependency>
  17       <groupId>org.springframework.boot</groupId>
  18       <artifactId>spring-boot-starter-web</artifactId>
  19     </dependency>
  20   </dependencies>
  21   <properties>
  22     <start-class>org.allowed.bitarus.springTestApp.Application</start-class>
  23   </properties>
  24   <build>
  25     <plugins>
  26       <plugin>
  27         <artifactId>maven-compiler-plugin</artifactId>
  28         <version>2.3.2</version>
  29       </plugin>
  30       <plugin>
  31         <groupId>org.springframework.boot</groupId>
  32         <artifactId>spring-boot-maven-plugin</artifactId>
  33       </plugin>
  34     </plugins>
  35   </build>
  36   <repositories>
  37     <repository>
  38       <id>spring-releases</id>
  39       <url>http://repo.spring.io/libs-release</url>
  40     </repository>
  41   </repositories>
  42   <pluginRepositories>
  43     <pluginRepository>
  44       <id>spring-releases</id>
  45       <url>http://repo.spring.io/libs-release</url>
  46     </pluginRepository>
  47   </pluginRepositories>
  48 </project>

Application.java

   1 // 
   2 packagesrc/main/java/org/allowed/bitarus/springTestApp/Application.java org.allowed.bitarus.springTestApp;
   3 
   4 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   5 import org.springframework.boot.SpringApplication;
   6 import org.springframework.context.annotation.ComponentScan;
   7 import org.springframework.boot.autoconfigure.SpringBootApplication;
   8 import org.springframework.context.annotation.Bean;
   9 import java.util.concurrent.Future;
  10 import java.util.ArrayList;
  11 import java.util.concurrent.ExecutorService;
  12 import java.util.concurrent.Executors;
  13 
  14 @ComponentScan
  15 @EnableAutoConfiguration
  16 @SpringBootApplication
  17 public class Application {
  18 
  19     public static void main(String[] args) {
  20         SpringApplication.run(Application.class, args);
  21     }
  22     
  23     @Bean(name="tasksFutures")
  24     public ArrayList<Future<Integer>> createTasksFutures(){
  25       System.out.println("Creating tasksFutures");
  26       return new ArrayList<Future<Integer>>();
  27     }
  28     
  29     @Bean(name="executors")
  30     public ExecutorService createExecutors(){
  31       return Executors.newFixedThreadPool(5);         
  32     }
  33 }

Tasker.java

   1 // src/main/java/org/allowed/bitarus/springTestApp/Tasker.java
   2 package org.allowed.bitarus.springTestApp;
   3 
   4 import org.springframework.stereotype.Component;
   5 import java.util.concurrent.ExecutorService;
   6 import java.util.concurrent.Future;
   7 import org.springframework.beans.factory.annotation.Autowired;
   8 import org.springframework.beans.factory.annotation.Qualifier;
   9 
  10 @Component("tasker")
  11 public class Tasker {
  12   private ExecutorService _es;
  13   
  14   public Tasker(@Qualifier("executors") ExecutorService es){
  15     System.out.println("Created Tasker !!!!");  
  16     _es = es;
  17   }
  18   
  19   public Future<Integer> addTask(TaskX taskx){
  20     Future<Integer> f = _es.submit( taskx );
  21     return f;
  22   }
  23 }

Receiver.java

   1 // src/main/java/org/allowed/bitarus/springTestApp/Receiver.java
   2 package org.allowed.bitarus.springTestApp;
   3 
   4 import org.springframework.stereotype.Component;
   5 import java.util.concurrent.Future;
   6 import java.util.ArrayList;
   7 import org.springframework.beans.factory.annotation.Qualifier;
   8 import javax.annotation.PostConstruct;
   9 
  10 @Component
  11 public class Receiver {
  12   private Tasker _t;
  13   private ArrayList<Future<Integer>> _tasks;
  14   
  15   public Receiver(@Qualifier("tasker")Tasker t, @Qualifier("tasksFutures") ArrayList<Future<Integer>> tasks ){
  16     System.out.println("Created receiver !!!!"); 
  17     _t = t;
  18     _tasks = tasks;
  19     // wait for all tasks ...
  20     /*
  21     boolean loop=true;
  22     while(loop){
  23       boolean allDone=true;
  24       for(Future<Integer> f : tasks){
  25         if(f.isDone()==false){
  26           allDone=false;            
  27         }
  28       }
  29       
  30       if(allDone){
  31         loop=false;        
  32       }
  33       
  34       try{ 
  35         Thread.sleep(1000);           
  36       }
  37       catch(Exception ex){          
  38       }
  39     }
  40     
  41     for(Future<Integer> f : tasks){
  42       try{  
  43         Integer res = f.get();
  44         System.out.println(res);
  45       }
  46       catch(Exception ex){            
  47       }
  48     }    */
  49   }    
  50   
  51   @PostConstruct
  52   public void init(){   
  53     System.out.println("Init post construct");   
  54     for(int i=0;i<10;i++){ 
  55         _tasks.add( _t.addTask( new TaskX(5,6) ) );        
  56     }      
  57   }
  58 }

TaskX.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import java.util.concurrent.Callable;
   4 
   5 public class TaskX implements Callable<Integer>{
   6   private int _x;  
   7   private int _y;
   8     
   9   public TaskX(int x,int y){
  10     _x=x;
  11     _y=y;
  12   }  
  13     
  14   public Integer call() {
  15     try { 
  16        Thread.sleep(5000); 
  17     }
  18     catch(Exception ex){           
  19     }
  20     int sum = _x+_y;
  21     System.out.println("TID:"+Thread.currentThread().getId() + " sumVal:" + sum );
  22     return sum;
  23   }      
  24 }

Example with MongoDB

Think about using spring.data.mongodb.uri.

pom.xml

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <project xmlns="http://maven.apache.org/POM/4.0.0" 
   3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   5 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   6   <modelVersion>4.0.0</modelVersion>
   7   <groupId>org.allowed.bitarus</groupId>
   8   <artifactId>springTestApp</artifactId>
   9   <version>0.1.0</version>
  10   <parent>
  11     <groupId>org.springframework.boot</groupId>
  12     <artifactId>spring-boot-starter-parent</artifactId>
  13     <version>1.4.2.RELEASE</version>
  14   </parent>
  15   <dependencies>
  16     <dependency>
  17       <groupId>org.springframework.boot</groupId>
  18       <artifactId>spring-boot-starter-web</artifactId>
  19     </dependency>
  20     <dependency>
  21       <groupId>org.springframework.data</groupId>
  22       <artifactId>spring-data-mongodb</artifactId>
  23       <version>1.9.6.RELEASE</version>
  24     </dependency>        
  25   </dependencies>
  26   <properties>
  27     <start-class>org.allowed.bitarus.springTestApp.Application</start-class>
  28   </properties>
  29   <build>
  30     <plugins>
  31       <plugin>
  32         <artifactId>maven-compiler-plugin</artifactId>
  33         <version>2.3.2</version>
  34       </plugin>
  35       <plugin>
  36         <groupId>org.springframework.boot</groupId>
  37         <artifactId>spring-boot-maven-plugin</artifactId>
  38       </plugin>
  39     </plugins>
  40   </build>
  41   <repositories>
  42     <repository>
  43       <id>spring-releases</id>
  44       <url>http://repo.spring.io/libs-release</url>
  45     </repository>
  46   </repositories>
  47   <pluginRepositories>
  48     <pluginRepository>
  49       <id>spring-releases</id>
  50       <url>http://repo.spring.io/libs-release</url>
  51     </pluginRepository>
  52   </pluginRepositories>
  53 </project>

application.properties

src/main/resources/application.properties

   1 # disable web container/server
   2 spring.main.web-environment=false
   3 threadpool.nrExecutors=5
   4 mongox.host=127.0.0.1
   5 mongox.port=27017
   6 mongox.database=mydatabase

Application.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
   4 import org.springframework.boot.SpringApplication;
   5 import org.springframework.context.annotation.ComponentScan;
   6 import org.springframework.boot.autoconfigure.SpringBootApplication;
   7 import org.springframework.context.annotation.Bean;
   8 import java.util.concurrent.Future;
   9 import java.util.ArrayList;
  10 import java.util.concurrent.ExecutorService;
  11 import java.util.concurrent.Executors;
  12 import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
  13 import org.springframework.data.mongodb.core.MongoTemplate;
  14 import com.mongodb.Mongo;
  15 import org.springframework.core.env.Environment;
  16 import javax.annotation.Resource;
  17 
  18 @ComponentScan
  19 @EnableAutoConfiguration
  20 @SpringBootApplication
  21 @EnableMongoRepositories // search for MongoDB reps
  22 public class Application {
  23     @Resource
  24     Environment _env;
  25     
  26     public static void main(String[] args) {
  27         SpringApplication.run(Application.class, args);
  28     }
  29     
  30     @Bean(name="tasksFutures")
  31     public ArrayList<Future<Integer>> createTasksFutures(){
  32       System.out.println("Creating tasksFutures");
  33       return new ArrayList<Future<Integer>>();
  34     }
  35     
  36     @Bean(name="executors")
  37     public ExecutorService createExecutors(){
  38       System.out.println("Creating executors");
  39       System.out.println(_env.getProperty("threadpool.nrExecutors"));
  40       return Executors.newFixedThreadPool(5);         
  41     }
  42     
  43     @Bean(name="mongoTemplate")     
  44     public MongoTemplate mongoTemplate() throws Exception {
  45         System.out.println("Creating mongoTemplate");
  46         System.out.println(_env.getProperty("mongox.host"));
  47         System.out.println(_env.getProperty("mongox.port"));
  48         System.out.println(_env.getProperty("mongox.database"));
  49         Mongo mongo = new Mongo( _env.getProperty("mongox.host"), Integer.parseInt(_env.getProperty("mongox.port") ) );        
  50         return new MongoTemplate(mongo, _env.getProperty("mongox.database") );
  51     }     
  52 }

Tasker.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import org.springframework.stereotype.Component;
   4 import java.util.concurrent.ExecutorService;
   5 import java.util.concurrent.Future;
   6 import org.springframework.beans.factory.annotation.Autowired;
   7 import org.springframework.beans.factory.annotation.Qualifier;
   8 
   9 @Component("tasker")
  10 public class Tasker {
  11   private ExecutorService _es;
  12   
  13   public Tasker(@Qualifier("executors") ExecutorService es){
  14     System.out.println("Created Tasker !!!!");  
  15     _es = es;
  16   }
  17   
  18   public Future<Integer> addTask(TaskX taskx){
  19     Future<Integer> f = _es.submit( taskx );
  20     return f;
  21   }
  22 }

Result.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import org.springframework.data.annotation.Id;
   4 
   5 public class Result {
   6     @Id
   7     private String id;
   8     private int sumResult;
   9 
  10     public Result(){}    
  11     public int getSumResult(){return this.sumResult;}
  12     public void setSumResult(int sumResult){this.sumResult=sumResult;}
  13     public String getId(){return this.id;}
  14     public void setId(String id){this.id=id;}   
  15 }

Receiver.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import org.springframework.stereotype.Component;
   4 import java.util.concurrent.Future;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7 import org.springframework.beans.factory.annotation.Qualifier;
   8 import javax.annotation.PostConstruct;
   9 import org.springframework.beans.factory.annotation.Autowired;
  10 import org.springframework.data.mongodb.core.query.Query;
  11 import org.springframework.data.mongodb.core.MongoTemplate;
  12 
  13 @Component
  14 public class Receiver {
  15   private Tasker _t;
  16   private ArrayList<Future<Integer>> _tasks;
  17   private ResultRepository _repository;
  18   
  19   public Receiver(@Qualifier("tasker")Tasker t, @Qualifier("tasksFutures") ArrayList<Future<Integer>> tasks, ResultRepository repository ){
  20     System.out.println("Created receiver !!!!"); 
  21     _t = t;
  22     _tasks = tasks;
  23     _repository = repository;
  24   }    
  25   @Autowired
  26   private MongoTemplate mongoTemplate;
  27   
  28   @PostConstruct
  29   public void init(){   
  30     System.out.println("Init post construct");   
  31     for(int i=0;i<10;i++){ 
  32         _tasks.add( _t.addTask( new TaskX(5,6) ) );        
  33     }      
  34     
  35     // wait for all tasks ...
  36     boolean loop=true;
  37     while(loop){
  38       boolean allDone=true;
  39       for(Future<Integer> f : _tasks){
  40         if(f.isDone()==false){
  41           allDone=false;            
  42         }
  43       }
  44       
  45       if(allDone){
  46         loop=false;        
  47       }
  48       
  49       try{ 
  50         Thread.sleep(1000);           
  51       }
  52       catch(Exception ex){          
  53       }
  54     }
  55     
  56     for(Future<Integer> f : _tasks){
  57       try{  
  58         Integer res = f.get();
  59         System.out.println(res);
  60         Result r = new Result();
  61         r.setSumResult(res);
  62         _repository.save(r);
  63       }
  64       catch(Exception ex){            
  65       }
  66     }    
  67     
  68     System.out.println( _repository.count() );
  69     List<Result> res = _repository.findBySumResult(11);
  70     for(Result r : res){
  71         r.setSumResult((int)System.currentTimeMillis());
  72         _repository.save(r);
  73     }   
  74     
  75     System.out.println("mongoTemplateCount " + mongoTemplate.count(new Query() ,Result.class) );
  76   }
  77 }

ResultRepository.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import java.util.List;
   4 import org.springframework.data.mongodb.repository.MongoRepository;
   5 /*
   6  Result -> class to store
   7  String -> id in collection type
   8  Collection result in database mydatabase
   9  { "_id" : ObjectId("58828e2822e1a609d96a5e52"), "_class" : "org.allowed.bitarus.springTestApp.Result", "sumResult" : 11 }
  10  */
  11 public interface ResultRepository extends MongoRepository<Result, String> {
  12     public List<Result> findBySumResult(int sumResult);
  13 }

TaskX.java

   1 package org.allowed.bitarus.springTestApp;
   2 
   3 import java.util.concurrent.Callable;
   4 
   5 public class TaskX implements Callable<Integer>{
   6   private int _x;  
   7   private int _y;
   8     
   9   public TaskX(int x,int y){
  10     _x=x;
  11     _y=y;
  12   }  
  13     
  14   public Integer call() {
  15     try { 
  16        Thread.sleep(5000); 
  17     }
  18     catch(Exception ex){           
  19     }
  20     int sum = _x+_y;
  21     System.out.println("TID:"+Thread.currentThread().getId() + " sumVal:" + sum );
  22     
  23     return sum;
  24   }      
  25 }

Integration tests

Integration tests setup and start Spring context before running the tests.

A class can be overrided using its FQN (Fully Qualified Name) in src/test/java. The class loader will load it and override the real class available in src/main/java or in the used libraries.

Example

class SecurityExpressionRoot 
package org.springframework.security.access.expression 
JAR file spring-security-core.jar

   1 // <groupId>org.springframework.boot</groupId>
   2 // <artifactId>spring-boot-starter-test</artifactId>
   3 @Test // test case
   4 @RunWith(SpringRunner.class)
   5 @MockBean // inject mocked beans
   6 @MockitoBean
   7 // Mockito, given , willReturn Mocks simulates real objects 
   8 @SpyBean
   9 @MockitoSpyBean
  10 // create proxy for a real object
  11 @SpringBootTest // test application context
  12 @ActiveProfiles("test") // use application properties for test profile 
  13 @WebFluxTest  // web flux controllers tests
  14 @WebMvcTest   // web tests
  15 
  16 //Mockito mocks
  17 doNothing().when(objx).objMethod()
  18 doReturn(response).when(objx).objMethod()
  19 doThrow(Exception.class).when(objx).objMethod()
  20 doCallRealMethod().when(objx).objMethod()
  21 
  22 // application-<profile>.properties
  23 // application-<profile>.yml 
  24 application-test.properties
  25 application-test.yml 
  26 
  27 // org.springframework.test.util.ReflectionTestUtils
  28 // ReflectionTestUtils is a collection of reflection-based utility methods for use in unit and integration testing scenarios. 
  29 
  30 ReflectionTestUtils.setField(obj,"fieldname",value)
  31 ReflectionTestUtils.invokeMethod(obj,"methodName",args)
  32 
  33 // Class Mono<T> A Reactive Streams Publisher with basic rx operators 
  34 // that completes successfully by emitting an element, or with an error. 
  35 var objx = mock(Obj.class);
  36 doReturn( Mono.just(objx) ).when(o).methodXYZ();
  37 Optional.of() 
  38 Optional.ofNullable() 
  39 
  40 // Verify if it was called 3 times
  41 verify(mockObject, times(3)).someMethod("argument");
  42 
  43 // in application-tests.properties, random port
  44 server.port=0
  45 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  46 @LocalServerPort
  47 private int port;
  48 
  49 // transactional context in test
  50 @Transactional 
  51 @Test

JPARepository

JpaRepository

Captures the domain type to manage as well as the domain type's id type.

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/stereotype/Repository.html

Mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects. Specialization of @Component.

   1 import org.springframework.data.jpa.repository.JpaRepository;
   2 import org.springframework.stereotype.Repository;
   3 
   4 @Repository
   5 public Repo implements  JpaRepository<EntityX,Long>{
   6 }

ConfigurationProperties

ConfigurationProperties
EnableConfigurationProperties
Annotation for externalized configuration.
@EnableConfigurationProperties
@ConfigurationProperties

   1 @ConfigurationProperties(prefix = "server")
   2 public class ServerProperties {
   3     private Map<String, String> app;
   4     private Map<String, List<String>> config;

Transactional query methods

https://docs.spring.io/spring-data/jpa/reference/jpa/transactions.html#transactional-query-methods

Declared query methods (including default methods) do not get any transaction configuration applied by default. To run those methods transactionally, use @Transactional with readonly equal to true.

   1 @Transactional(readOnly = true)
   2 
   3 // send events
   4 ApplicationEventPublisher( pojoEventObject );
   5 // annotations
   6 @Component
   7 @EventListener
   8 @TransactionalEventListener