SpringBoot

   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 }

   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 }

   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 }

   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 }

   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 }

   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 }

   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 }

   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 

   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 }

   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 }

   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 }

   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 }

   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 }

   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 }