Spring Boot Deployment and service configuration

Spring Boot is an integrated Web container by default and starts in the same way as a normal Java program, starting with the main function entry. Its built-in tomcat container or jetty container, which is determined by the configuration (default tomcat). Of course you can also package the project into a war package, put it into a separate web container (Tomcat, WebLogic, and so on), of course, before you make a simple adjustment to the program portal.

Project Building we use MAVEN or Gradle, which makes project dependencies, jar package management, and package deployment very convenient.

One, embedded Server configuration

Spring boot uses the configuration file to modify the relevant server configuration after it is built into the container.
Let's take a look at the following diagram for a configuration column entry for the server:

Only a few of the commonly used configurations have been marked with purple. Red-framed parts, look at the name classification can understand its role.
Make a brief description of several commonly used configurations of the server:

1. # project ContextPath, generally in the official release version, we do not configure
2. Server.context-path=/myspringboot
3. # error page, specifying the URL of the jump when an error occurs. Please check the Basicerrorcontroller source code to know
4. Server.error.path=/error
5. # Service Port
6. server.port=9090
7. # Session maximum timeout (minutes), default is
8. server.session-timeout=
9. # The service binds the IP address, and when the server is started, if the IP address is not the same as this, then the exception is thrown, and only the special requirements are configured
10. # server.address=192.168. 16.11

Tomcat
Tomcat is the default container for spring boot, and here are a few common configurations:

2. # Tomcat maximum number of threads, default is
4. server.tomcat.max-threads=
6. # tomcat URI encoding
8. server.tomcat.uri-encoding=utf-8
10. # A temporary folder for files such as Tomcat logs, dumps, and so on, default to the system's TMP folder (for example: C:\Users\Shanhy\AppData\Local\Temp)
12. Server.tomcat.basedir=h:/springboot-tomcat-tmp
14. # Open the Tomcat access log, and you can set the method for the log format:
16. #server. tomcat.access-log-enabled=True
18. #server. tomcat.access-log-pattern=
20. # Accesslog directory, default in Basedir/logs
22. #server. tomcat.accesslog.directory=
24. # log file directory
26. Logging.path=h:/springboot-tomcat-tmp
28. # log file name, default is Spring.log
30. Logging.file=myapp.log

Jetty
If you are going to choose jetty, it is also very simple to exclude the Tomcat dependency in Pom and add the dependency of the jetty container as follows:

2. <dependencies>
4. <dependency>
6. <groupId>org.springframework.boot</groupId>
8. <artifactId>spring-boot-starter-web</artifactId>
10. <exclusions>
12. <exclusion>
14. <groupId>org.springframework.boot</groupId>
16. <artifactId>spring-boot-starter-tomcat</artifactId>
18. </exclusion>
20. </exclusions>
22. </dependency>
24. <dependency>
26. <groupId>org.springframework.boot</groupId>
28. <artifactId>spring-boot-starter-jetty</artifactId>
30. </dependency>
32. <dependencies>

Packaged
Packaging method:
CMD into the project directory, using the MVN Clean Packages command to package, take my project projects as an example:

1. E:\SPRING-BOOT-SAMPLE>MVN Clean Package

You can append the parameter-dmaven.test.skip=true to skip the test.
The packaged files are stored in the target directory under the project, such as: Spring-boot-sample-0.0.1-snapshot.jar
Spring-boot-sample-0.0.1-snapshot.war If the POM is configured with a war package

Ii. deploy to a Java EE container

1. Modify the startup class, Inherit Springbootservletinitializer, and override the Configure method

2. Public class Springbootsampleapplication extends springbootservletinitializer{
6. private static final Logger Logger = Loggerfactory.getlogger (springbootsampleapplication.   Class);
10. @Override
12. protected Springapplicationbuilder Configure (Springapplicationbuilder builder) {
14. return Builder.sources (this.getclass ());
16. }
20. }

1. Modify the jar in the Pom file as war

1. <!--<packaging>jar</packaging>--
2. <packaging>war</packaging>

1. Modify Pom to exclude Tomcat plugins

2. <dependency>
4. <groupId>org.springframework.boot</groupId>
6. <artifactId>spring-boot-starter-web</artifactId>
8. <exclusions>
10. <exclusion>
12. <groupId>org.springframework.boot</groupId>
14. <artifactId>spring-boot-starter-tomcat</artifactId>
16. </exclusion>
18. </exclusions>
20. </dependency>

1. Package deployment to a container
   Use the command MVN clean package to deploy to a web container just like a generic Java EE project.

Iii. using profile to differentiate the environment

Spring boot can configure profiles to differentiate between different environments and perform different results in "Configuration Files", "Java Code Classes", "Log Configuration"

1. Configuration files
Using configuration files Application.yml and application.properties differ
Take Application.properties as an example to differentiate the environment by file name Application-{profile}.properties
Application.properties

1. App.name=myapp
2. server.port=8080
3. Spring.profiles.active=dev

Application-dev.properties

1. server.port=8081

Application-stg.properties

1. server.port=8082

Specify the specific configuration to use when starting the program by adding –spring.profiles.active={profile}
For example, if we execute Java-jar demo.jar–spring.profiles.active=dev, then how will the contents of the above 3 files be applied?
Spring Boot Loads the default configuration file first, and then overwrites the default configuration with the configuration in the specified profile.

1. App.name exists only in the default profile application.properties because the same configuration does not exist in the specified environment, so the value is not overwritten
2. Server.port defaults to 8080, but when we specify an environment, it will be overwritten. If you specify a STG environment, Server.port is 8082
3. spring.profiles.active Specifies the dev environment by default, and if we specify –SPRING.PROFILES.ACTIVE=STG at runtime then the STG environment will be applied and the final Server.port value is 8082

2. @profile annotations in Java class
The following 2 different classes implement the same interface, @Profile annotations specify the specific environment

2. Interface definition
4. Public interface SendMessage {
8. //Send SMS Method definition
10. public Void Send ();
14. }
18. Dev Environment Implementation Class
20. @Component
22. @Profile ("Dev")
24. Public class Devsendmessage implements SendMessage {
28. @Override
30. public Void Send () {
32. System.out.println (">>>>>>>>dev Send () <<<<<<<<");
34. }
38. }
42. STG Environment Implementation Class
44. @Component
46. @Profile ("STG")
48. Public class Stgsendmessage implements SendMessage {
52. @Override
54. public Void Send () {
56. System.out.println (">>>>>>>>stg Send () <<<<<<<<");
58. }
62. }
66. Start class
68. @SpringBootApplication
70. Public class Profiledemoapplication {
74. @Value ("${app.name}")
76. private String name;
80. @Autowired
82. private SendMessage SendMessage;
86. @PostConstruct
88. public void init () {
90. Sendmessage.send (); //The corresponding class will be instantiated according to the environment specified by profile
92. }
96. }

3, Logback-spring.xml also support the node to support the distinction

2. <?xml version="1.0" encoding="UTF-8"?>
4. <configuration>
6. <include resource="Org/springframework/boot/logging/logback/base.xml"/>
8. <logger name="Org.springframework.web" level="INFO"/>
12. <springprofile name="Default" >
14. <logger name="org.springboot.sample" level="TRACE"/>
16. </springProfile>
20. <springprofile name="Dev" >
22. <logger name="org.springboot.sample" level="DEBUG"/>
24. </springProfile>
28. <springprofile name="Staging" >
30. <logger name="org.springboot.sample" level="INFO"/>
32. </springProfile>
36. </configuration>

Again, do not use the Logback.xml file name. Use Logback-spring.xml

Iv. specifying the external configuration file

Some systems, such as information about databases or other third-party accounts, are not configured to be exposed to developers in the project because of security issues.
In this case, when we run the program, we can specify an external configuration file through the parameters.
Taking Demo.jar as an example, the method is as follows:

1. Java-jar Demo.jar--spring.config.location=/opt/config/application.properties

Where the file name is arbitrarily defined, no fixed requirements.

V. Create an SH script for a Linux application

The following scripts are for reference only, please make adjustments according to your needs
start.sh

1. #!/bin/sh
3. Rm-f Tpid
5. Nohup Java-jar/data/app/myapp.jar--SPRING.PROFILES.ACTIVE=STG >/dev/null 2>&1 &
7. Echo $! > Tpid

stop.sh

1. Tpid= ' Cat Tpid | awk ' {print '} '
2. Tpid= ' Ps-aef | grep $tpid | awk ' {print $} ' |grep $tpid '
3. If [${tpid}]; Then
4. Kill-9 $tpid
5. Fi

check.sh

1. #!/bin/sh
3. Tpid= ' Cat Tpid | awk ' {print '} '
4. Tpid= ' Ps-aef | grep $tpid | awk ' {print $} ' |grep $tpid '
5. If [${tpid}]; Then
6. Echo App is running.
7. Else
8. Echo App is not running.
9. Fi

kill.sh

1. #!/bin/sh
2. # Kill-9 ' ps-ef|grep project name |awk ' {print $} '
3. Kill-9 ' ps-ef|grep Demo|awk ' {print $} '

Spring Boot Deployment and service configuration