SpringBoot入门

SpringBoot

1. 什么是SpringBoot

• Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。
• 虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring 用 XML 配置，而且是很多 XML 配置。Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML 配置。Spring 3.0 引入了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML。所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。
• 除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。
• Spring Boot 让这一切成为了过去。

Spring Boot 是 Spring 社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于 Spring 的应用程序和服务，让更多人的人更快的对 Spring 进行入门体验，为 Spring 生态系统提供了一种固定的、约定优于配置风格的框架。

SpringBoot的特性

1. 为基于 Spring 的开发提供更快的入门体验
2. 开箱即用，没有代码生成，也无需 XML 配置。同时也可以修改默认值来满足特定的需求。
3. 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
4. Spring Boot 并不是不对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

2. SpringBoot入门案例

1. 环境搭建

1. 创建一个maven的jar工程（使用springboot创建web工程，使用jar的打包方式就可以完成）
2. 在pom.xml中引入依赖（首先继承SpringBoot的一个工程，因为要创建web工程，要引入web工程的启动器）

 <!-- 通常继承这个工程 -->
   <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.0.RELEASE</version>
  </parent>  
  <!-- 引入启动器：这是一个web的启动器，里面包含了tomcat等等等等，配置好了启动器，就可以用SpringBoot内置的tomcat来运行 -->
  <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

在引入启动器这个依赖后，我们发现他自动引入了好多关联jar包

3. 变更jdk的版本（保存后将maven工程update一下，jdk版本就会变成1.7）

<!-- 配置jdk版本 -->
   <properties>   
    <java.version>1.7</java.version>
  </properties>

4. 创建引导类（引导类是该程序的入口，只要执行该引导类，这个程序就会自动启动）

package com.lld.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

5. 直接执行该引导类（会在控制台打印以下内容，只要没有报错就说明环境搭建成功）

2. SpringMVC实现HelloWorld输出

• 之前使用SpringMVC实现helloworld输出需要以下几步

    1. 在web.xml里面配置值读取SpringMVC的配置文件，以及post乱码解决等等
    2. 创建springMVC.xml，在里面配置包扫描或者bean，配置注解驱动（相当于同时使用最新处理器映射跟处理器适配器,对json数据响应提供支持），视图解析器，以及文件上传用的多媒体解析器等等
    3. 开始编码
  

• 现在在SpringBoot中，我们直接编写Controller类即可（与普通的写法相同）

package com.lld.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWordController {
	
	@RequestMapping("/info")
	public String info(){
		return "HelloWorld";
	}
}

• 右击引导类启动（默认使用的8080端口），在浏览器输入localhost:8080/info即可看到结果
  

3. 修改tomcat启动的端口

• 在src/main/resources下创建application.properties文件在里面输入以下内容，即可将该web工程的端口改为8888
  
• 重新启动引导类，在页面输入http://localhost:8888/info6

4. 读取配置文件的信息

• 在application.properties里面添加一个配置（我们要在controller中读取到这句话）
  
  
  

5. 配置热部署

• 就是配置了热部署后，修改页面不需要重启服务器，直接在页面测试即可
• 在pom.xml中添加以下配置

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

• 配置好热部署后，重启服务器即可（在配置好热部署以后，修改完页面，保存后，SpringBoot会自动进行部署）

3. Spring Boot与ActiveMQ整合

1. 使用内嵌服务

Spring Boot内置了ActiveMQ的服务，所以我们不用单独启动也可以执行应用程序。

• 在pom.xml中引入依赖

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

• 创建消息发送者

package com.lld.demo.activeMQ;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class QueueController {
	
	@Autowired
	private JmsMessagingTemplate jmsMessagingTemplate;
	
	@RequestMapping("/send")
	public String send(String text){
		
		jmsMessagingTemplate.convertAndSend("LLD", text);
		
		return "来了";
	}
}

• 创建消息接受者

package com.lld.demo.activeMQ;

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class Consumer {
	@JmsListener(destination="LLD")
	public void readMessage(String text){
		System.out.println("接收到消息："+text);
	}	
}

• 测试
  
  

2. 使用外部服务

• 在application.properties里面添加这么一句话：即指定使用的ActiveMQ的地址

spring.activemq.broker-url=tcp://192.168.25.128:61616

3. 发送map信息

4. SpringBoot的启动器

Spring Boot应用启动器
spring Boot应用启动器基本的一共有44种，具体如下：
1）spring-boot-starter 
这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。
2）spring-boot-starter-actuator 
帮助监控和管理应用。
3）spring-boot-starter-amqp 
通过spring-rabbit来支持AMQP协议（Advanced Message Queuing Protocol）。
4）spring-boot-starter-aop 
支持面向方面的编程即AOP，包括spring-aop和AspectJ。
5）spring-boot-starter-artemis 
通过Apache Artemis支持JMS的API（Java Message Service API）。
6）spring-boot-starter-batch 
支持Spring Batch，包括HSQLDB数据库。
7）spring-boot-starter-cache 
支持Spring的Cache抽象。
8）spring-boot-starter-cloud-connectors 
支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。
9）spring-boot-starter-data-elasticsearch 
支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。
10）spring-boot-starter-data-gemfire 
支持GemFire分布式数据存储，包括spring-data-gemfire。
11）spring-boot-starter-data-jpa 
支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、hibernate。
12）spring-boot-starter-data-MongoDB 
支持MongoDB数据，包括spring-data-mongodb。
13）spring-boot-starter-data-rest 
通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。
14）spring-boot-starter-data-solr 
支持Apache Solr搜索平台，包括spring-data-solr。
15）spring-boot-starter-freemarker 
支持FreeMarker模板引擎。
16）spring-boot-starter-groovy-templates 
支持Groovy模板引擎。
17）spring-boot-starter-hateoas 
通过spring-hateoas支持基于HATEOAS的RESTful Web服务。
18）spring-boot-starter-hornetq 
通过HornetQ支持JMS。
19）spring-boot-starter-integration 
支持通用的spring-integration模块。
20）spring-boot-starter-jdbc 
支持JDBC数据库。
21）spring-boot-starter-jersey 
支持Jersey RESTful Web服务框架。
22）spring-boot-starter-jta-atomikos 
通过Atomikos支持JTA分布式事务处理。
23）spring-boot-starter-jta-bitronix 
通过Bitronix支持JTA分布式事务处理。
24）spring-boot-starter-mail 
支持javax.mail模块。
25）spring-boot-starter-mobile 
支持spring-mobile。
26）spring-boot-starter-mustache 
支持Mustache模板引擎。
27）spring-boot-starter-Redis 
支持Redis键值存储数据库，包括spring-redis。
28）spring-boot-starter-security 
支持spring-security。
29）spring-boot-starter-social-facebook 
支持spring-social-facebook
30）spring-boot-starter-social-linkedin 
支持pring-social-linkedin
31）spring-boot-starter-social-twitter 
支持pring-social-twitter
32）spring-boot-starter-test 
支持常规的测试依赖，包括JUnit、Hamcrest、Mockito以及spring-test模块。
33）spring-boot-starter-thymeleaf 
支持Thymeleaf模板引擎，包括与Spring的集成。
34）spring-boot-starter-velocity 
支持Velocity模板引擎。
35）spring-boot-starter-web 
S支持全栈式Web开发，包括Tomcat和spring-webmvc。
36）spring-boot-starter-websocket 
支持WebSocket开发。
37）spring-boot-starter-ws 
支持Spring Web Services。
Spring Boot应用启动器面向生产环境的还有2种，具体如下：
1）spring-boot-starter-actuator 
增加了面向产品上线相关的功能，比如测量和监控。
2）spring-boot-starter-remote-shell 
增加了远程ssh shell的支持。
最后，Spring Boot应用启动器还有一些替换技术的启动器，具体如下：
1）spring-boot-starter-jetty 
引入了Jetty HTTP引擎（用于替换Tomcat）。
2）spring-boot-starter-log4j 
支持Log4J日志框架。
3）spring-boot-starter-logging 
引入了Spring Boot默认的日志框架Logback。
4）spring-boot-starter-tomcat 
引入了Spring Boot默认的HTTP引擎Tomcat。
5）spring-boot-starter-undertow 
引入了Undertow HTTP引擎（用于替换Tomcat）。

5. Spring Boot 配置文件application.properties

#########COMMON SPRING BOOT PROPERTIES
######========CORE PROPERTIES===========
#SPRING CONFIG (ConfigFileApplicationListener)

spring.config.name= # config file name (default to 'application')
spring.config.location= # location of config file

#PROFILES
spring.profiles= # comma list of active profiles

#APPLICATION SETTINGS (SpringApplication)
spring.main.sources=
spring.main.web-environment= # detect by default
spring.main.show-banner=true
spring.main....= # see class for all properties

#LOGGING
logging.path=/var/logs
logging.file=myapp.log
logging.config=

#IDENTITY (ContextIdApplicationContextInitializer)
spring.application.name=
spring.application.index=

#EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080
server.address= # bind to a specific NIC
server.session-timeout= # session timeout in seconds
server.context-path= # the context path, defaults to '/'
server.servlet-path= # the servlet path, defaults to '/'
server.tomcat.access-log-pattern= # log pattern of the access log
server.tomcat.access-log-enabled=false # is access logging enabled
server.tomcat.protocol-header=x-forwarded-proto # ssl forward headers
server.tomcat.remote-ip-header=x-forwarded-for
server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp)
server.tomcat.background-processor-delay=30; # in seconds
server.tomcat.max-threads = 0 # number of threads in protocol handler
server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding

#SPRING MVC (HttpMapperProperties)
http.mappers.json-pretty-print=false # pretty print JSON
http.mappers.json-sort-keys=false # sort keys
spring.mvc.locale= # set fixed locale, e.g. enUK
spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy
spring.mvc.message-codes-resolver-format= # PREFIXERRORCODE / POSTFIXERROR_CODE
spring.view.prefix= # MVC view prefix
spring.view.suffix= # ... and suffix
spring.resources.cache-period= # cache timeouts in headers sent to browser
spring.resources.add-mappings=true # if default mappings should be added

#THYMELEAF (ThymeleafAutoConfiguration)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html # ;charset=<encoding> is added
spring.thymeleaf.cache=true # set to false for hot refresh

#FREEMARKER (FreeMarkerAutoConfiguration)
spring.freemarker.allowRequestOverride=false
spring.freemarker.allowSessionOverride=false
spring.freemarker.cache=true
spring.freemarker.checkTemplateLocation=true
spring.freemarker.contentType=text/html
spring.freemarker.exposeRequestAttributes=false
spring.freemarker.exposeSessionAttributes=false
spring.freemarker.exposeSpringMacroHelpers=false
spring.freemarker.prefix=
spring.freemarker.requestContextAttribute=
spring.freemarker.settings.*=
spring.freemarker.suffix=.ftl
spring.freemarker.templateEncoding=UTF-8
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.viewNames= # whitelist of view names that can be resolved

#GROOVY TEMPLATES (GroovyTemplateAutoConfiguration)
spring.groovy.template.allowRequestOverride=false
spring.groovy.template.allowSessionOverride=false
spring.groovy.template.cache=true
spring.groovy.template.configuration.*= # See Groovy's TemplateConfiguration
spring.groovy.template.contentType=text/html
spring.groovy.template.prefix=classpath:/templates/
spring.groovy.template.suffix=.tpl
spring.groovy.template.templateEncoding=UTF-8
spring.groovy.template.viewNames= # whitelist of view names that can be resolved

#VELOCITY TEMPLATES (VelocityAutoConfiguration)
spring.velocity.allowRequestOverride=false
spring.velocity.allowSessionOverride=false
spring.velocity.cache=true
spring.velocity.checkTemplateLocation=true
spring.velocity.contentType=text/html
spring.velocity.dateToolAttribute=
spring.velocity.exposeRequestAttributes=false
spring.velocity.exposeSessionAttributes=false
spring.velocity.exposeSpringMacroHelpers=false
spring.velocity.numberToolAttribute=
spring.velocity.prefix=
spring.velocity.properties.*=
spring.velocity.requestContextAttribute=
spring.velocity.resourceLoaderPath=classpath:/templates/
spring.velocity.suffix=.vm
spring.velocity.templateEncoding=UTF-8
spring.velocity.viewNames= # whitelist of view names that can be resolved

#INTERNATIONALIZATION (MessageSourceAutoConfiguration)
spring.messages.basename=messages
spring.messages.cacheSeconds=-1
spring.messages.encoding=UTF-8

#SECURITY (SecurityProperties)
security.user.name=user # login username
security.user.password= # login password
security.user.role=USER # role assigned to the user
security.require-ssl=false # advanced settings ...
security.enable-csrf=false
security.basic.enabled=true
security.basic.realm=Spring
security.basic.path= # /**
security.headers.xss=false
security.headers.cache=false
security.headers.frame=false
security.headers.contentType=false
security.headers.hsts=all # none / domain / all
security.sessions=stateless # always / never / if_required / stateless
security.ignored=false

#DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.name= # name of the data source
spring.datasource.initialize=true # populate using data.sql
spring.datasource.schema= # a schema (DDL) script resource reference
spring.datasource.data= # a data (DML) script resource reference
spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql)
spring.datasource.continueOnError=false # continue even if can't be initialized
spring.datasource.separator=; # statement separator in SQL initialization scripts
spring.datasource.driverClassName= # JDBC Settings...
spring.datasource.url=
spring.datasource.username=
spring.datasource.password=
spring.datasource.max-active=100 # Advanced configuration...
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10
spring.datasource.validation-query=
spring.datasource.test-on-borrow=false
spring.datasource.test-on-return=false
spring.datasource.test-while-idle=
spring.datasource.time-between-eviction-runs-millis=
spring.datasource.min-evictable-idle-time-millis=
spring.datasource.max-wait-millis=

#MONGODB (MongoProperties)
spring.data.mongodb.host= # the db host
spring.data.mongodb.port=27017 # the connection port (defaults to 27107)
spring.data.mongodb.uri=mongodb://localhost/test # connection URL
spring.data.mongo.repositories.enabled=true # if spring data repository support is enabled

#JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.properties.*= # properties to set on the JPA connection
spring.jpa.openInView=true
spring.jpa.show-sql=true
spring.jpa.database-platform=
spring.jpa.database=
spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors
spring.jpa.hibernate.naming-strategy= # naming classname
spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs
spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled

#SOLR (SolrProperties})
spring.data.solr.host=http://127.0.0.1:8983/solr
spring.data.solr.zkHost=
spring.data.solr.repositories.enabled=true # if spring data repository support is enabled

#ELASTICSEARCH (ElasticsearchProperties})
spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch)
spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated; if not specified starts a client node)
spring.data.elasticsearch.local=true # if local mode should be used with client nodes
spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is enabled

#FLYWAY (FlywayProperties)
flyway.locations=classpath:db/migrations # locations of migrations scripts
flyway.schemas= # schemas to update
flyway.initVersion= 1 # version to start migration
flyway.prefix=V
flyway.suffix=.sql
flyway.enabled=true
flyway.url= # JDBC url if you want Flyway to create its own DataSource
flyway.user= # JDBC username if you want Flyway to create its own DataSource
flyway.password= # JDBC password if you want Flyway to create its own DataSource

#LIQUIBASE (LiquibaseProperties)
liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml
liquibase.contexts= # runtime contexts to use
liquibase.default-schema= # default database schema to use
liquibase.drop-first=false
liquibase.enabled=true

#JMX
spring.jmx.enabled=true # Expose MBeans from Spring

#ABBIT (RabbitProperties)
spring.rabbitmq.host= # connection host
spring.rabbitmq.port= # connection port
spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
spring.rabbitmq.username= # login user
spring.rabbitmq.password= # login password
spring.rabbitmq.virtualhost=
spring.rabbitmq.dynamic=

#REDIS (RedisProperties)
spring.redis.host=localhost # server host
spring.redis.password= # server password
spring.redis.port=6379 # connection port
spring.redis.pool.max-idle=8 # pool settings ...
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1

#ACTIVEMQ (ActiveMQProperties)
spring.activemq.broker-url=tcp://localhost:61616 # connection URL
spring.activemq.user=
spring.activemq.password=
spring.activemq.in-memory=true # broker kind to create if no broker-url is specified
spring.activemq.pooled=false

#HornetQ (HornetQProperties)
spring.hornetq.mode= # connection mode (native, embedded)
spring.hornetq.host=localhost # hornetQ host (native mode)
spring.hornetq.port=5445 # hornetQ port (native mode)
spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
spring.hornetq.embedded.serverId= # auto-generated id of the embedded server (integer)
spring.hornetq.embedded.persistent=false # message persistence
spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled)
spring.hornetq.embedded.queues= # comma separate queues to create on startup
spring.hornetq.embedded.topics= # comma separate topics to create on startup
spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)

#JMS (JmsProperties)
spring.jms.pub-sub-domain= # false for queue (default), true for topic

#SPRING BATCH (BatchDatabaseInitializer)
spring.batch.job.names=job1,job2
spring.batch.job.enabled=true
spring.batch.initializer.enabled=true
spring.batch.schema= # batch schema to load

#AOP
spring.aop.auto=
spring.aop.proxy-target-class=

#FILE ENCODING (FileEncodingApplicationListener)
spring.mandatory-file-encoding=false

#SPRING SOCIAL (SocialWebAutoConfiguration)
spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own

#SPRING SOCIAL FACEBOOK (FacebookAutoConfiguration)
spring.social.facebook.app-id= # your application's Facebook App ID
spring.social.facebook.app-secret= # your application's Facebook App Secret

#SPRING SOCIAL LINKEDIN (LinkedInAutoConfiguration)
spring.social.linkedin.app-id= # your application's LinkedIn App ID
spring.social.linkedin.app-secret= # your application's LinkedIn App Secret

#SPRING SOCIAL TWITTER (TwitterAutoConfiguration)
spring.social.twitter.app-id= # your application's Twitter App ID
spring.social.twitter.app-secret= # your application's Twitter App Secret

#SPRING MOBILE SITE PREFERENCE (SitePreferenceAutoConfiguration)
spring.mobile.sitepreference.enabled=true # enabled by default

#SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration)
spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
spring.mobile.devicedelegatingviewresolver.normalPrefix=
spring.mobile.devicedelegatingviewresolver.normalSuffix=
spring.mobile.devicedelegatingviewresolver.mobilePrefix=mobile/
spring.mobile.devicedelegatingviewresolver.mobileSuffix=
spring.mobile.devicedelegatingviewresolver.tabletPrefix=tablet/
spring.mobile.devicedelegatingviewresolver.tabletSuffix=

######========ACTUATOR PROPERTIES===========

#MANAGEMENT HTTP SERVER (ManagementServerProperties)
management.port= # defaults to 'server.port'
management.address= # bind to a specific NIC
management.contextPath= # default to '/'

#ENDPOINTS (AbstractEndpoint subclasses)
endpoints.autoconfig.id=autoconfig
endpoints.autoconfig.sensitive=true
endpoints.autoconfig.enabled=true
endpoints.beans.id=beans
endpoints.beans.sensitive=true
endpoints.beans.enabled=true
endpoints.configprops.id=configprops
endpoints.configprops.sensitive=true
endpoints.configprops.enabled=true
endpoints.configprops.keys-to-sanitize=password,secret
endpoints.dump.id=dump
endpoints.dump.sensitive=true
endpoints.dump.enabled=true
endpoints.env.id=env
endpoints.env.sensitive=true
endpoints.env.enabled=true
endpoints.health.id=health
endpoints.health.sensitive=false
endpoints.health.enabled=true
endpoints.info.id=info
endpoints.info.sensitive=false
endpoints.info.enabled=true
endpoints.metrics.id=metrics
endpoints.metrics.sensitive=true
endpoints.metrics.enabled=true
endpoints.shutdown.id=shutdown
endpoints.shutdown.sensitive=true
endpoints.shutdown.enabled=false
endpoints.trace.id=trace
endpoints.trace.sensitive=true
endpoints.trace.enabled=true

#MVC ONLY ENDPOINTS
endpoints.jolokia.path=jolokia
endpoints.jolokia.sensitive=true
endpoints.jolokia.enabled=true # when using Jolokia
endpoints.error.path=/error

#JMX ENDPOINT (EndpointMBeanExportProperties)
endpoints.jmx.enabled=true
endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot'
endpoints.jmx.unique-names=false
endpoints.jmx.enabled=true
endpoints.jmx.staticNames=

#JOLOKIA (JolokiaProperties)
jolokia.config.*= # See Jolokia manual

#REMOTE SHELL
shell.auth=simple # jaas, key, simple, spring
shell.command-refresh-interval=-1
shell.command-path-pattern= # classpath:/commands/, classpath:/crash/commands/
shell.config-path-patterns= # classpath:/crash/
shell.disabled-plugins=false # don't expose plugins
shell.ssh.enabled= # ssh settings ...
shell.ssh.keyPath=
shell.ssh.port=
shell.telnet.enabled= # telnet settings ...
shell.telnet.port=
shell.auth.jaas.domain= # authentication settings ...
shell.auth.key.path=
shell.auth.simple.user.name=
shell.auth.simple.user.password=
shell.auth.spring.roles=

#GIT INFO
spring.git.properties= # resource ref to generated git info properties file