當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

springboot文档笔记

發布時間：2025/3/19 编程问答 24 豆豆

生活随笔收集整理的這篇文章主要介紹了 springboot文档笔记小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

1.Spring Boot 入門

1.1什么是 Spring Boot

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 生態系統提供了一種固定的、約定優于配置風格的框架。

Spring Boot 具有如下特性：
（1）為基于 Spring 的開發提供更快的入門體驗
（2）開箱即用，沒有代碼生成，也無需 XML 配置。同時也可以修改默認值來滿足特定的需求。
（3）提供了一些大型項目中常見的非功能性特性，如嵌入式服務器、安全、指標，健康檢測、外部配置等。
（4）Spring Boot 并不是不對 Spring 功能上的增強，而是提供了一種快速使用 Spring 的方式。

1.2Spring Boot 入門小Demo

1.3起步依賴

創建 Maven 工程 springboot_demo（打包方式 jar）
在 pom.xml 中添加如下依賴
在這里面我繼續父依賴，這那相關的依賴jar包都會傳遞進來，版本也做了統一

<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.4.1.RELEASE</version><relativePath /></parent> <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency> </dependencies>

而這些 jar 包正式我們做開發時需要導入的 jar 包。因為這些 jar 包被我們剛才引入的 spring-boot-starter-web 所引用了，所以我們引用 spring-boot-starter-web 后會自動把依賴傳遞過來。
其中就是因為這個jar包幫我們來集成了很多配置

1.4變更 JDK 版本

我們發現默認情況下工程的 JDK 版本是 1.6 ,而我們通常用使用 1.7 的版本，所以我們需要在 pom.xml 中添加以下配置

添加后更新工程，會發現版本已經變更為 1.7

1.5引導類

只需要創建一個引導類 .其實也叫啟動類

簡單解釋一下：
@SpringBootApplication 其實就是以下三個注解的總和
@Configuration：用于定義一個配置類
@EnableAutoConfiguration ：Spring Boot 會自動根據你 jar 包的依賴來自動配置項目。
@ComponentScan：告訴 Spring 哪個 packages 的用注解標識的類會被 spring 自動掃描并且裝入 bean 容器。

1.6啟動

在Spring Boot項目中，啟動的方式有兩種，一種是直接run Java Application另外一種是通過Spring Boot的Maven插件運行。

第一種：

第二種：
添加Spring boot的插件

<plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin>

我們直接執行這個引導類，會發現控制臺出現的這個標識

1.7熱部署

我們在開發中反復修改類、頁面等資源，每次修改后都是需要重新啟動才生效，這樣每
次啟動都很麻煩，浪費了大量的時間，能不能在我修改代碼后不重啟就能生效呢？可以，在 pom.xml 中添加如下配置就可以實現這樣的功能，我們稱之為熱部署。

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

也可以指定加載的位置：

spring.devtools.restart.enabled=true spring.devtools.restart.additional-paths=src/main/resources spring.devtools.restart.exclude=src/main/java

2.Spring MVC

2.1Spring MVC 實現 Hello World 輸出

我們現在開始使用 spring MVC 框架，實現 json 數據的輸出。如果按照我們原來的做法，需要在 web.xml 中添加一個 DispatcherServlet 的配置，再添加一個 spring 的配置文件，配置文件中需要添加如下配置
但是我們用 SpringBoot，這一切都省了。我們直接寫 Controller 類
@RestController是一個組合注解
@Controller
@ResponseBody 用與返回字符串或json數據

我們運行啟動類來運行程序
在瀏覽器地址欄輸入 http://localhost:8080/hello 即可看到運行結果

2.2application.properties配置文件

在 src/main/resources 下創建 application.properties 或者更加簡潔的application.yml文件

#修改 tomcat 啟動端口

重新運行引導類。地址欄輸入http://localhost:8088/hello

補充：
默認的加載路徑是根路徑，可以修改成自己的項目路徑

2.3application.yml文件

yaml是一種直觀的能夠被計算機識別的數據序列化格式，容易被人類閱讀，yaml類似于xml，但語法更簡潔；
它是一種冒號，空格，換行的數據格式，后綴可以是yml,也可以是yaml
如果兩個application.properties和application.yml同時存在，優先加載application.properties

2.4讀取自定義配置文件信息

在 src/main/resources 下的 application.properties 增加配置

我要在類中讀取這個配置信息，修改 HelloWorldController
方式一：

方式二：

2.5多環境配置文件

今后我們在開發過程中有很多種開發環境那么可能就有很多個環境的配置文件。那么如何進行配置呢？

這里springboot默認加載application.properties文件，需要在默認文件中把其他的配置文件進行激活

測試

注意細節：

2.6自定義banner

啟動Spring Boot項目后會看到這樣的圖案：

這個圖片其實是可以自定義的：

打開網站：http://patorjk.com/software/taag/#p=display&h=3&v=3&f=Doom&t=yanqi%20-%20%3E%3E%3E

拷貝生成的字符到一個文本文件中，并且將該文件命名為banner.txt

將banner.txt拷貝到項目的resources目錄中：

控制臺看運行結果

好像沒有默認的好看啊！

2.7使用springboot訪問jsp

2.7.1添加 jsp相關依賴

<dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId></dependency><dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></dependency><dependency><groupId>org.apache.tomcat.embed</groupId><artifactId>tomcat-embed-jasper</artifactId><scope>provided</scope></dependency>

2.7.2配置視圖解析器

#views spring.mvc.view.prefix= /WEB-INF/views/ spring.mvc.view.suffix= .jsp

在main下面創建webapp/WEB-INF/views/

Controller實現

@Controller public class JspController {@RequestMapping("/index")public String index(HttpServletResponse response,HttpServletRequest request ){request.setAttribute("msg", "這是springboot集成jsp");return "index";//訪問的是視圖解析器的jsp // return "forward:/index.jsp";//訪問的是外部的jsp} }

注意：如果是ide的話是編譯不了jsp的，解決方案如下

<resource><directory>src/main/webapp</directory><targetPath>META-INF/resources</targetPath><includes><include>**/*.*</include></includes></resource></resources> </build>

3.Mybatis整合springboot

3.1添加mybatis整合springboot的依賴包

<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.0</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency>

3.2配置數據源

#配置tomcat端口 server.port=8080 #訪問路徑 server.context-path=/#DB config spring.datasource.driverClassName=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false spring.datasource.username=root spring.datasource.password=root#配置加載xml文件，pojo mybatis.type-aliases-package=cn.yanqi.pojo mybatis.mapperLocations=classpath:mapper/*.xml

在這里插入圖片描述

3.3配置掃描包

/*** 指定所掃的包，會自動掃描指定包下的全部標有@Component的類，并注冊成bean，* 當然包括@Component下的子注解@Service,@Repository,@Controller。* @author yanqi**/ @SpringBootApplication(scanBasePackages={"cn.yanqi.*"}) @MapperScan("cn.yanqi.mapper")//掃描mapper接口 public class DemoApplication {public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args); } }

3.4代碼實現

3.4.1Pojo類

public class User implements Serializable{private static final long serialVersionUID = -5846970261372764303L;private Long id;// 用戶名private String userName;// 密碼private String password;// 姓名private String name;// 年齡private Integer age;// 性別，1男性，2女性private Integer sex;// 出生日期private Date birthday;// 創建時間private Date created;// 更新時間private Date updated;public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public Integer getSex() {return sex;}public void setSex(Integer sex) {this.sex = sex;}public Date getBirthday() {return birthday;}public void setBirthday(Date birthday) {this.birthday = birthday;}public Date getCreated() {return created;}public void setCreated(Date created) {this.created = created;}public Date getUpdated() {return updated;}public void setUpdated(Date updated) {this.updated = updated;}@Overridepublic String toString() {return "User [id=" + id + ", userName=" + userName + ", password=" + password + ", name=" + name+ ", age=" + age + ", sex=" + sex + ", birthday=" + birthday + ", created=" + created+ ", updated=" + updated + "]";}}

3.4.2Controller層

@RestController public class UserController {//注入service@Autowiredprivate UserService userService;/** 查詢所有* @GetMapping 里面包含了 @RequestMapping + method=RequestMethod.GET)*/@GetMapping("/queryall")//@RequestMapping(value="/queryall" ,method=RequestMethod.GET)public List<User> queryUserAll(){return this.userService.queryUserAll();}/** 根據id進行查詢*/@GetMapping("/queryId")public User queryById(Long id ) {return this.userService.queryById(id);} }

3.4.3.Service層

@Service public class UserService {@Autowiredprivate UserMapper userMapper;public User queryById(Long id){return this.userMapper.queryById(id);}public List<User> queryUserAll() {return this.userMapper.ueryUserAll();} }

3.4.4Mapper接口

@Mapper public interface UserMapper {User queryById(Long id);public List<User> ueryUserAll();public int add(User user);public int update(@Param("id") Integer id, @Param("user") User user);public int delete(Integer id); }

3.4.5 SqlMapper.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="cn.yanqi.mapper.UserMapper"><select id="queryById" resultType="User">select * from tb_user where id = #{id} </select><select id="ueryUserAll" resultType="User">select * from tb_user</select></mapper>

3.4.6頁面

3.4.7測試

http://localhost:8080/index.jsp

3.5日志

Spring Boot對各種日志框架都做了支持，我們可以通過配置來修改默認的日志的配置：

#設置日志級別 #print sql logging.level.cn.yanqi=DEBUG #print logging logging.level.org.springframework=DEBUG

4.補充

4.1附件A

Spring Boot 應用啟動器
spring Boot應用啟動器具體如下：
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）。

附錄 B

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

總結

以上是生活随笔為你收集整理的springboot文档笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： springmvc代码详细(五种映射，绑
下一篇： mybatis文档笔记