添加链接
link管理
链接快照平台
  • 输入网页链接,自动生成快照
  • 标签化管理网页链接
  • 11.3.1. @RestController 和@RequestMapping 注解
  • 11.3.2. @EnableAutoConfiguration 注解
  • 11.3.3. "main"方法
  • 11.4. 运行示例
  • 11.5. 创建一个可执行的 Jar
  • 12. 接下来要读什么
  • III. 使用 Spring Boot
  • 13. Build Systems
  • 13.1. 依赖性 Management
  • 13.2. Maven
  • 13.2.1. 继承 Starter Parent
  • 13.2.2. 在没有父 POM 的情况下使用 Spring Boot
  • 13.2.3. 使用 Spring Boot Maven 插件
  • 13.3. Gradle
  • 13.4. Ant
  • 13.5. Starters
  • 14. 结构化代码
  • 14.1. 使用"default"包
  • 14.2. 查找主应用程序类
  • 15. Configuration Classes
  • 15.1. 导入其他配置类
  • 15.2. 导入 XML 配置
  • 16. Auto-configuration
  • 16.1. 逐步取代自动配置
  • 16.2. 禁用特定的自动配置类
  • 17. Springbean 和依赖注入
  • 18. 使用@SpringBootApplication Comments
  • 19. 运行您的应用程序
  • 19.1. 从 IDE 运行
  • 19.2. 作为打包的应用程序运行
  • 19.3. 使用 Maven 插件
  • 19.4. 使用 Gradle 插件
  • 19.5. 热插拔
  • 20. Developer Tools
  • 20.1. 属性默认值
  • 20.2. 自动重启
  • 20.2.1. 记录条件评估的更改
  • 20.2.2. 排除资源
  • 20.2.3. 观看其他路径
  • 20.2.4. 禁用重新启动
  • 20.2.5. 使用触发文件
  • 20.2.6. 自定义重启类加载器
  • 20.2.7. 已知限制
  • 20.3. LiveReload
  • 20.4. 全局设置
  • 20.5. 远程应用程序
  • 20.5.1. 运行远程 Client 端应用程序
  • 20.5.2. 远程更新
  • 21. 包装您的生产申请
  • 22. 接下来要读什么
  • IV. Spring Boot 功能
  • 23. SpringApplication
  • 23.1. 启动失败
  • 23.2. 自定义 banner
  • 23.3. 自定义 SpringApplication
  • 23.4. Fluent Builder API
  • 23.5. 应用程序事件和侦听器
  • 23.6. Web 环境
  • 23.7. 访问应用程序参数
  • 23.8. 使用 ApplicationRunner 或 CommandLineRunner
  • 23.9. 申请退出
  • 23.10. Management 员功能
  • 24. Externalized Configuration
  • 24.1. 配置随机值
  • 24.2. 访问命令行属性
  • 24.3. 应用程序属性文件
  • 24.4. Profile 特定的属性
  • 24.5. 属性中的占位符
  • 24.6. 加密属性
  • 24.7. 使用 YAML 代替属性
  • 24.7.1. 正在加载 YAML
  • 24.7.2. 在 Spring 环境中将 YAML 公开为属性
  • 24.7.3. 多配置文件 YAML 文档
  • 24.7.4. YAML 的缺点
  • 24.8. 类型安全的配置属性
  • 24.8.1. 第三方配置
  • 24.8.2. 轻松绑定
  • 24.8.3. 合并复杂类型
  • 24.8.4. 属性转换
  • Converting durations
  • 转换数据大小
  • 24.8.5. @ConfigurationProperties 验证
  • 24.8.6. @ConfigurationProperties 与@Value
  • 25. Profiles
  • 25.1. 添加 Active 配置文件
  • 25.2. 以编程方式设置配置文件
  • 25.3. 特定于配置文件的配置文件
  • 26. Logging
  • 26.1. 日志格式
  • 26.2. 控制台输出
  • 26.2.1. 颜色编码的输出
  • 26.3. 文件输出
  • 26.4. 日志级别
  • 26.5. 日志组
  • 26.6. 自定义日志配置
  • 26.7. Logback 扩展
  • 26.7.1. 特定于配置文件的配置
  • 26.7.2. 环境属性
  • 27. JSON
  • 27.1. Jackson
  • 27.2. Gson
  • 27.3. JSON-B
  • 28. 开发 Web 应用程序
  • 28.1. “ Spring Web MVC 框架”
  • 28.1.1. Spring MVC 自动配置
  • 28.1.2. HttpMessageConverters
  • 28.1.3. 自定义 JSON 序列化器和反序列化器
  • 28.1.4. MessageCodesResolver
  • 28.1.5. 静态内容
  • 28.1.6. 欢迎页面
  • 28.1.7. 自定义图标
  • 28.1.8. 路径匹配和内容协商
  • 28.1.9. ConfigurableWebBindingInitializer
  • 28.1.10. 模板引擎
  • 28.1.11. 错误处理
  • 自定义错误页面
  • 在 Spring MVC 外部 Map 错误页面
  • 28.1.12. Spring HATEOAS
  • 28.1.13. CORS 支持
  • 28.2. “ Spring WebFlux 框架”
  • 28.2.1. Spring WebFlux 自动配置
  • 带有 HttpMessageReaders 和 HttpMessageWriters 的 28.2.2. HTTP 编解码器
  • 28.2.3. 静态内容
  • 28.2.4. 模板引擎
  • 28.2.5. 错误处理
  • 自定义错误页面
  • 28.2.6. 网页过滤器
  • 28.3. JAX-RS 和 Jersey
  • 28.4. 嵌入式 Servlet 容器支持
  • 28.4.1. Servlet,过滤器和侦听器
  • 将 Servlet,过滤器和侦听器注册为 Spring Bean
  • 28.4.2. Servlet 上下文初始化
  • 扫描 Servlet,过滤器和侦听器
  • 28.4.3. ServletWebServerApplicationContext
  • 28.4.4. 自定义嵌入式 Servlet 容器
  • Programmatic Customization
  • 直接自定义 ConfigurableServletWebServerFactory
  • 28.4.5. JSP 限制
  • 28.5. 嵌入式反应式服务器支持
  • 28.6. Reactive 服务器资源配置
  • 29. Security
  • 29.1. MVC 安全性
  • 29.2. WebFlux 安全性
  • 29.3. OAuth2
  • 29.3.1. Client
  • 普通提供商的 OAuth2 Client 端注册
  • 29.3.2. 资源服务器
  • 29.3.3. 授权服务器
  • 29.4. Actuator 安全
  • 29.4.1. 跨站点请求伪造保护
  • 30. 使用 SQL 数据库
  • 30.1. 配置数据源
  • 30.1.1. 嵌入式数据库支持
  • 30.1.2. 连接到生产数据库
  • 30.1.3. 连接到 JNDI 数据源
  • 30.2. 使用 JdbcTemplate
  • 30.3. JPA 和 Spring Data JPA
  • 30.3.1. 实体类别
  • 30.3.2. Spring Data JPA 存储库
  • 30.3.3. 创建和删除 JPA 数据库
  • 30.3.4. 在视图中打开 EntityManager
  • 30.4. Spring Data JDBC
  • 30.5. 使用 H2 的 Web 控制台
  • 30.5.1. 更改 H2 控制台的路径
  • 30.6. 使用 jOOQ
  • 30.6.1. 代码生成
  • 30.6.2. 使用 DSLContext
  • 30.6.3. jOOQ SQL 方言
  • 30.6.4. 自定义 jOOQ
  • 31. 使用 NoSQL 技术
  • 31.1. Redis
  • 31.1.1. 连接到 Redis
  • 31.2. MongoDB
  • 31.2.1. 连接到 MongoDB 数据库
  • 31.2.2. MongoTemplate
  • 31.2.3. Spring Data MongoDB 存储库
  • 31.2.4. 嵌入式 Mongo
  • 31.3. Neo4j
  • 31.3.1. 连接到 Neo4j 数据库
  • 31.3.2. 使用嵌入式模式
  • 31.3.3. Neo4jSession
  • 31.3.4. Spring Data Neo4j 存储库
  • 31.4. Gemfire
  • 31.5. Solr
  • 31.5.1. 连接到 Solr
  • 31.5.2. Spring Data Solr 存储库
  • 31.6. Elasticsearch
  • 31.6.1. 通过 REST Client 端连接到 Elasticsearch
  • 31.6.2. 使用 Jest 连接到 Elasticsearch
  • 31.6.3. 使用 Spring 数据连接到 Elasticsearch
  • 31.6.4. Spring Data Elasticsearch 存储库
  • 31.7. Cassandra
  • 31.7.1. 连接到 Cassandra
  • 31.7.2. Spring Data Cassandra 存储库
  • 31.8. Couchbase
  • 31.8.1. 连接到 Couchbase
  • 31.8.2. Spring Data Couchbase 存储库
  • 31.9. LDAP
  • 31.9.1. 连接到 LDAP 服务器
  • 31.9.2. Spring Data LDAP 存储库
  • 31.9.3. 嵌入式内存 LDAP 服务器
  • 31.10. InfluxDB
  • 31.10.1. 连接到 InfluxDB
  • 32. Caching
  • 32.1. 受支持的缓存提供程序
  • 32.1.1. Generic
  • 32.1.2. JCache(JSR-107)
  • 32.1.3. EhCache 2.x
  • 32.1.4. Hazelcast
  • 32.1.5. Infinispan
  • 32.1.6. Couchbase
  • 32.1.7. Redis
  • 32.1.8. Caffeine
  • 32.1.9. Simple
  • 32.1.10. None
  • 33. Messaging
  • 33.1. JMS
  • 33.1.1. ActiveMQ 支持
  • 33.1.2. Artemis 支持
  • 33.1.3. 使用 JNDI ConnectionFactory
  • 33.1.4. 发送信息
  • 33.1.5. 接收消息
  • 33.2. AMQP
  • 33.2.1. RabbitMQ 支持
  • 33.2.2. 发送信息
  • 33.2.3. 接收消息
  • 33.3. Apache Kafka 支持
  • 33.3.1. 发送信息
  • 33.3.2. 接收消息
  • 33.3.3. Kafka 流
  • 33.3.4. Kafka 的其他属性
  • 34. 使用 RestTemplate 调用 REST 服务
  • 34.1. RestTemplate 自定义
  • 35. 使用 WebClient 调用 REST 服务
  • 35.1. WebClient 运行时
  • 35.2. WebClient 自定义
  • 36. Validation
  • 37. Sending Email
  • 38. JTA 的分布式事务
  • 38.1. 使用 Atomikos Transaction manager
  • 38.2. 使用 Bitronix Transaction manager
  • 38.3. 使用 Java EE 托管事务 Management 器
  • 38.4. 混合 XA 和非 XA JMS 连接
  • 38.5. 支持备用嵌入式事务 Management 器
  • 39. Hazelcast
  • 40. Quartz Scheduler
  • 41. 任务执行和计划
  • 42. Spring Integration
  • 43. Spring Session
  • 44. 通过 JMX 进行监视和 Management
  • 45. Testing
  • 45.1. 测试范围依赖性
  • 45.2. 测试 Spring 应用程序
  • 45.3. 测试 Spring Boot 应用程序
  • 45.3.1. 检测 Web 应用程序类型
  • 45.3.2. 检测测试配置
  • 45.3.3. 不包括测试配置
  • 45.3.4. 在模拟环境中进行测试
  • 45.3.5. 使用正在运行的服务器进行测试
  • 45.3.6. 使用 JMX
  • 45.3.7. 模拟 bean 和 Spybean
  • 45.3.8. 自动配置的测试
  • 45.3.9. 自动配置的 JSON 测试
  • 45.3.10. 自动配置的 Spring MVC 测试
  • 45.3.11. 自动配置的 Spring WebFlux 测试
  • 45.3.12. 自动配置的数据 JPA 测试
  • 45.3.13. 自动配置的 JDBC 测试
  • 45.3.14. 自动配置的数据 JDBC 测试
  • 45.3.15. 自动配置的 jOOQ 测试
  • 45.3.16. 自动配置的 Data MongoDB 测试
  • 45.3.17. 自动配置的数据 Neo4j 测试
  • 45.3.18. 自动配置的数据 Redis 测试
  • 45.3.19. 自动配置的数据 LDAP 测试
  • 45.3.20. 自动配置的 REST Client 端
  • 45.3.21. 自动配置的 Spring REST 文档测试
  • 使用 Mock MVC 自动配置的 Spring REST Docs 测试
  • 具有 REST 保证的自动配置的 Spring REST Docs 测试
  • 45.3.22. 其他自动配置和切片
  • 45.3.23. 用户配置和切片
  • 45.3.24. 使用 Spock 测试 Spring Boot 应用程序
  • 45.4. 测试 Util
  • 45.4.1. ConfigFileApplicationContextInitializer
  • 45.4.2. TestPropertyValues
  • 45.4.3. OutputCapture
  • 45.4.4. TestRestTemplate
  • 46. WebSockets
  • 47. Web Services
  • 48. 使用 WebServiceTemplate 调用 Web 服务
  • 49. 创建自己的自动配置
  • 49.1. 了解自动配置的 Bean
  • 49.2. 查找自动配置的候选人
  • 49.3. 条件 Comments
  • 49.3.1. Class 条件
  • 49.3.2. Bean 条件
  • 49.3.3. Property 条件
  • 49.3.4. 资源条件
  • 49.3.5. Web 应用程序条件
  • 49.3.6. SpEL 表达条件
  • 49.4. 测试您的自动配置
  • 49.4.1. 模拟 Web 上下文
  • 49.4.2. 覆盖 Classpath
  • 49.5. 创建自己的 Starter
  • 49.5.1. Naming
  • 49.5.2. 自动配置模块
  • 49.5.3. Starter 模块
  • 50. Kotlin support
  • 50.1. Requirements
  • 50.2. Null-safety
  • 50.3. Kotlin API
  • 50.3.1. runApplication
  • 50.3.2. Extensions
  • 50.4. 依赖性 Management
  • 50.5. @ConfigurationProperties
  • 50.6. Testing
  • 50.7. Resources
  • 50.7.1. 进一步阅读
  • 50.7.2. Examples
  • 51. 接下来要读什么
  • V. Spring Boot Actuator:可用于生产的功能
  • 52. 启用生产就绪功能
  • 53. Endpoints
  • 53.1. 启用端点
  • 53.2. 公开端点
  • 53.3. 保护 HTTP 端点
  • 53.4. 配置端点
  • 53.5. Actuator Web 端点的超媒体
  • 53.6. CORS 支持
  • 53.7. 实现自定义端点
  • 53.7.1. 接收 Importing
  • Importing 类型转换
  • 53.7.2. 自定义 Web 端点
  • Web 端点请求谓词
  • HTTP method
  • Consumes
  • Produces
  • Web 端点响应状态
  • Web 端点范围请求
  • Web 端点安全
  • 53.7.3. Servlet 端点
  • 53.7.4. 控制器端点
  • 53.8. 健康信息
  • 53.8.1. 自动配置的健康 Metrics
  • 53.8.2. 编写自定义健康 Metrics
  • 53.8.3. Reactive 健康 Metrics
  • 53.8.4. 自动配置的 ReactiveHealth Indicators
  • 53.9. 申请信息
  • 53.9.1. 自动配置的信息贡献者
  • 53.9.2. 自定义应用程序信息
  • 53.9.3. Git 提交信息
  • 53.9.4. 构建信息
  • 53.9.5. 编写自定义信息贡献者
  • 54. 通过 HTTP 进行监视和 Management
  • 54.1. 自定义 Management 端点路径
  • 54.2. 自定义 Management 服务器端口
  • 54.3. 配置 Management 特定的 SSL
  • 54.4. 自定义 Management 服务器地址
  • 54.5. 禁用 HTTP 端点
  • 55. 通过 JMX 进行监视和 Management
  • 55.1. 自定义 MBean 名称
  • 55.2. 禁用 JMX 端点
  • 55.3. 通过 HTTP 将 Jolokia 用于 JMX
  • 55.3.1. 自定义 Jolokia
  • 55.3.2. 禁用 Jolokia
  • 56. Loggers
  • 56.1. 配置 Logger
  • 57. Metrics
  • 57.1. 使用 Starter
  • 57.2. 支持的监控系统
  • 57.2.1. AppOptics
  • 57.2.2. Atlas
  • 57.2.3. Datadog
  • 57.2.4. Dynatrace
  • 57.2.5. Elastic
  • 57.2.6. Ganglia
  • 57.2.7. Graphite
  • 57.2.8. Humio
  • 57.2.9. Influx
  • 57.2.10. JMX
  • 57.2.11. KairosDB
  • 57.2.12. New Relic
  • 57.2.13. Prometheus
  • 57.2.14. SignalFx
  • 57.2.15. Simple
  • 57.2.16. StatsD
  • 57.2.17. Wavefront
  • 57.3. 支持的 Metrics
  • 57.3.1. Spring MVC Metrics
  • 57.3.2. Spring WebFlux Metrics
  • 57.3.3. Jersey 服务器 Metrics
  • 57.3.4. HTTP Client 端 Metrics
  • 57.3.5. 缓存 Metrics
  • 57.3.6. 数据源 Metrics
  • 57.3.7. HibernateMetrics
  • 57.3.8. RabbitMQ Metrics
  • 57.4. 注册自定义 Metrics
  • 57.5. 自定义单个 Metrics
  • 57.5.1. 常用标签
  • 57.5.2. 每米属性
  • 57.6. Metrics 终结点
  • 58. Auditing
  • 59. HTTP Tracing
  • 59.1. 自定义 HTTP 跟踪
  • 60. Process Monitoring
  • 60.1. 扩展配置
  • 60.2. Programmatically
  • 61. Cloud Foundry 支持
  • 61.1. 禁用扩展的 Cloud Foundry Actuator 支持
  • 61.2. Cloud Foundry 自签名证书
  • 61.3. 自定义上下文路径
  • 62. 接下来要读什么
  • VI. 部署 Spring Boot 应用程序
  • 63. 部署到云端
  • 63.1. Cloud Foundry
  • 63.1.1. 绑定到服务
  • 63.2. Heroku
  • 63.3. OpenShift
  • 63.4. Amazon Web Services(AWS)
  • 63.4.1. AWS Elastic Beanstalk
  • 使用 Tomcat 平台
  • 使用 Java SE 平台
  • 63.4.2. Summary
  • 63.5. Boxfuse 和 Amazon Web Services
  • 63.6. Google Cloud
  • 64. 安装 Spring Boot 应用程序
  • 64.1. 支持的 os
  • 64.2. Unix/Linux 服务
  • 64.2.1. 作为 init.d 服务安装(系统 V)
  • 保护 init.d 服务
  • 64.2.2. 作为系统服务安装
  • 64.2.3. 自定义启动脚本
  • 编写后自定义启动脚本
  • 运行时自定义脚本
  • 64.3. Microsoft Windows 服务
  • 65. 接下来要读什么
  • VII. Spring Boot CLI
  • 66. 安装 CLI
  • 67. 使用 CLI
  • 67.1. 使用 CLI 运行应用程序
  • 67.1.1. 推断"grab"依赖性
  • 67.1.2. 推导"grab"坐标
  • 67.1.3. 默认导入语句
  • 67.1.4. 自动 Main 方法
  • 67.1.5. 自定义依赖项 Management
  • 67.2. 具有多个源文件的应用程序
  • 67.3. 打包您的应用程序
  • 67.4. 初始化新项目
  • 67.5. 使用嵌入式 Shell
  • 67.6. 将扩展添加到 CLI
  • 68. 使用 Groovy Beans DSL 开发应用程序
  • 69. 使用 settings.xml 配置 CLI
  • 70. 接下来要读什么
  • VIII. 构建工具插件
  • 71. Spring Boot Maven 插件
  • 71.1. 引入插件
  • 71.2. 包装可执行的 Jar 和 War 文件
  • 72. Spring Boot Gradle 插件
  • 73. Spring Boot AntLib 模块
  • 73.1. Spring Boot Ant 任务
  • 73.1.1. spring-boot:exejar
  • 73.1.2. Examples
  • 73.2. spring-boot:findmainclass
  • 73.2.1. Examples
  • 74. 支持其他构建系统
  • 74.1. 重新打包 Files
  • 74.2. 嵌套库
  • 74.3. 寻找 Main 方法
  • 74.4. 重新打包实施示例
  • 75. 接下来要读什么
  • IX. “使用方法”指南
  • 76. Spring Boot 应用程序
  • 76.1. 创建您自己的 FailureAnalyzer
  • 76.2. 自动配置问题排查
  • 76.3. 在启动环境或 ApplicationContext 之前对其进行自定义
  • 76.4. 构建 ApplicationContext 层次结构(添加父上下文或根上下文)
  • 76.5. 创建非 Web 应用程序
  • 77. 属性和配置
  • 77.1. 在构建时自动扩展属性
  • 77.1.1. 使用 Maven 自动扩展属性
  • 77.1.2. 使用 Gradle 自动扩展属性
  • 77.2. 外部化 SpringApplication 的配置
  • 77.3. 更改应用程序外部属性的位置
  • 77.4. 使用“简短”命令行参数
  • 77.5. 将 YAML 用于外部属性
  • 77.6. 设置 ActiveSpring 轮廓
  • 77.7. 根据环境更改配置
  • 77.8. 发现外部属性的内置选项
  • 78. 嵌入式 Web 服务器
  • 78.1. 使用其他 Web 服务器
  • 78.2. 禁用 Web 服务器
  • 78.3. 更改 HTTP 端口
  • 78.4. 使用随机未分配的 HTTP 端口
  • 78.5. 在运行时发现 HTTP 端口
  • 78.6. 启用 HTTP 响应压缩
  • 78.7. 配置 SSL
  • 78.8. 配置 HTTP/2
  • 78.8.1. HTTP/2 和 Undertow
  • 78.8.2. HTTP/2 与 Jetty
  • Tomcat 78.8.3. HTTP/2
  • 具有 Reactor Netty 的 78.8.4. HTTP/2
  • 78.9. 配置 Web 服务器
  • 78.10. 向应用程序添加 Servlet,过滤器或侦听器
  • 78.10.1. 使用 Spring Bean 添加 Servlet,过滤器或侦听器
  • 禁用 Servlet 或过滤器的注册
  • 78.10.2. 使用 Classpath 扫描添加 Servlet,过滤器和侦听器
  • 78.11. 配置访问日志
  • 78.12. 在前端代理服务器后面运行
  • 78.12.1. 自定义 Tomcat 的代理配置
  • 78.13. 使用 Tomcat 启用多个连接器
  • 78.14. 使用 Tomcat 的 LegacyCookieProcessor
  • 78.15. 使用 Undertow 启用多个侦听器
  • 78.16. 使用@ServerEndpoint 创建 WebSocket 端点
  • 79. Spring MVC
  • 79.1. 编写 JSON REST 服务
  • 79.2. 编写 XML REST 服务
  • 79.3. 自定义 Jackson ObjectMapper
  • 79.4. 自定义@ResponseBody 渲染
  • 79.5. 处理分段文件上传
  • 79.6. 关闭 Spring MVC DispatcherServlet
  • 79.7. 关闭默认的 MVC 配置
  • 79.8. 自定义 ViewResolvers
  • 80. 使用 Spring Security 进行测试
  • 81. Jersey
  • 81.1. 使用 Spring Security 保护 Jersey 端点
  • 82. HTTP Clients
  • 82.1. 配置 RestTemplate 以使用代理
  • 83. Logging
  • 83.1. 配置登录以进行日志记录
  • 83.1.1. 为仅文件输出配置登录
  • 83.2. 配置 Log4j 进行日志记录
  • 83.2.1. 使用 YAML 或 JSON 配置 Log4j 2
  • 84. Data Access
  • 84.1. 配置自定义数据源
  • 84.2. 配置两个数据源
  • 84.3. 使用 Spring 数据存储库
  • 84.4. 将@Entity 定义与 Spring 配置分开
  • 84.5. 配置 JPA 属性
  • 84.6. 配置 Hibernate 命名策略
  • 84.7. 配置 Hibernate 二级缓存
  • 84.8. 在 Hibernate 组件中使用依赖注入
  • 84.9. 使用自定义 EntityManagerFactory
  • 84.10. 使用两个 EntityManager
  • 84.11. 使用传统的 persistence.xml 文件
  • 84.12. 使用 Spring Data JPA 和 Mongo 存储库
  • 84.13. 自定义 Spring Data 的 Web 支持
  • 84.14. 将 Spring 数据存储库公开为 REST 端点
  • 84.15. 配置 JPA 使用的组件
  • 84.16. 使用两个数据源配置 jOOQ
  • 85. Database Initialization
  • 85.1. 使用 JPA 初始化数据库
  • 85.2. 使用 Hibernate 初始化数据库
  • 85.3. 初始化数据库
  • 85.4. 初始化 Spring Batch 数据库
  • 85.5. 使用更高级别的数据库迁移工具
  • 85.5.1. 在启动时执行 Flyway 数据库迁移
  • 85.5.2. 在启动时执行 Liquibase 数据库迁移
  • 86. Messaging
  • 86.1. 禁用事务 JMS 会话
  • 87. Batch Applications
  • 87.1. 在启动时执行 Spring Batch 作业
  • 88. Actuator
  • 88.1. 更改 Actuator 端点的 HTTP 端口或地址
  • 88.2. 自定义“ whitelabel”错误页面
  • 88.3. 清理明智的价值观
  • 89. Security
  • 89.1. 关闭 Spring Boot 安全性配置
  • 89.2. 更改 UserDetailsService 并添加用户帐户
  • 89.3. 在代理服务器上运行时启用 HTTPS
  • 90. Hot Swapping
  • 90.1. 重新加载静态内容
  • 90.2. 重新加载模板,而无需重新启动容器
  • 90.2.1. Thymeleaf 模板
  • 90.2.2. FreeMarker 模板
  • 90.2.3. Groovy 模板
  • 90.3. 快速重启应用
  • 90.4. 重新加载 Java 类而无需重新启动容器
  • 91. Build
  • 91.1. 生成内部版本信息
  • 91.2. 生成 Git 信息
  • 91.3. 自定义依赖关系版本
  • 91.4. 使用 Maven 创建可执行 JAR
  • 91.5. 使用 Spring Boot 应用程序作为依赖项
  • 91.6. 运行可执行 Jar 时提取特定的库
  • 91.7. 创建带有排除项的不可执行的 JAR
  • 91.8. 远程调试以 Maven 开头的 Spring Boot 应用程序
  • 91.9. 在不使用 spring-boot-antlib 的情况下从 Ant 构建可执行归档文件
  • 92. Traditional Deployment
  • 92.1. 创建可部署的 War 文件
  • 92.2. 将现有应用程序转换为 Spring Boot
  • 92.3. 将 WAR 部署到 WebLogic
  • 92.4. 使用 Jedis 代替 Lettuce
  • X. Appendices
  • A.常见的应用程序属性
  • B.配置元数据
  • B.1.元数据格式
  • B.1.1.组属性
  • B.1.2.属性属性
  • B.1.3.提示属性
  • B.1.4. 重复的元数据项
  • B.2.提供手动提示
  • B.2.1. 价 Value hint
  • B.2.2. Value provider
  • Class Reference
  • Handle As
  • Logger Name
  • Spring Bean 参考
  • Spring Profile 名称
  • B.3.使用 Comments 处理器生成您自己的元数据
  • B.3.1. 嵌套属性
  • B.3.2. 添加其他元数据
  • C.自动配置类
  • C.1.从“ spring-boot-autoconfigure”模块
  • C.2.来自“ spring-boot-actuator-autoconfigure”模块
  • D.测试自动配置 Comments
  • E.可执行的 Jar 格式
  • E.1.嵌套 JAR
  • E.1.1. 可执行的 Jar 文件结构
  • E.1.2. 可执行 War 文件结构
  • E.2. Spring Boot 的“ JarFile”类
  • E.2.1. 与标准 Java“ JarFile”的兼容性
  • E.3.运行可执行Jar
  • E.3.1. 启动 Lists
  • E.3.2. Exploded archives
  • E.4.属性启动器功能
  • E.5.可执行 Jar 限制
  • E.6.替代独立 Jar 包解决方案
  • F.依赖版本
  • 20. Developer Tools

    Spring Boot 包括一组额外的工具,这些工具可以使应用程序开发体验更加愉快。 spring-boot-devtools 模块可以包含在任何项目中,以提供其他开发时功能。要包括 devtools 支持,请将模块依赖项添加到您的构建中,如以下 Maven 和 Gradle Lists 所示:

    Maven.

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

    Gradle.

    configurations {
    	developmentOnly
    	runtimeClasspath {
    		extendsFrom developmentOnly
    dependencies {
    	developmentOnly("org.springframework.boot:spring-boot-devtools")
    

    Note

    运行完全打包的应用程序时,将自动禁用开发人员工具。如果您的应用程序是从java -jar启动的,或者是从特殊的类加载器启动的,则将其视为“生产应用程序”。在 Maven 中将依赖项标记为可选,或在 Gradle 中使用自定义的“ developmentOnly”配置(如上所示)是一种最佳实践,它可以防止将 devtools 过渡地应用到使用项目的其他模块。

    Tip

    重新打包的存档默认情况下不包含 devtools。如果要使用某些远程 devtools 功能,则需要禁用excludeDevtools build 属性以包括它。 Maven 和 Gradle 插件均支持该属性。

    20.1 属性默认值

    Spring Boot 支持的一些库使用缓存来提高性能。例如,template engines缓存已编译的模板,以避免重复分析模板文件。而且,Spring MVC 可以在提供静态资源时向响应添加 HTTP 缓存 Headers。

    虽然缓存在 Producing 非常有益,但在开发过程中可能适得其反,从而使您无法看到刚刚在应用程序中所做的更改。因此,默认情况下,spring-boot-devtools 禁用缓存选项。

    缓存选项通常由application.properties文件中的设置配置。例如,Thymeleaf 提供了spring.thymeleaf.cache属性。无需手动设置这些属性,spring-boot-devtools模块会自动应用合理的开发时配置。

    由于在开发 Spring MVC 和 Spring WebFlux 应用程序时需要有关 Web 请求的更多信息,因此开发人员工具将为web日志记录组启用DEBUG日志记录。这将为您提供有关传入请求,正在处理的处理程序,响应结果等的信息。如果您希望记录所有请求详细信息(包括潜在的敏感信息),则可以打开spring.http.log-request-details配置属性。

    Note

    如果您不希望应用属性默认值,则可以在application.properties中将spring.devtools.add-properties设置为false

    Tip

    有关 devtools 应用的属性的完整列表,请参见DevToolsPropertyDefaultsPostProcessor

    20.2 自动重启

    每当 Classpath 上的文件更改时,使用spring-boot-devtools的应用程序都会自动重新启动。当在 IDE 中工作时,这可能是一个有用的功能,因为它为代码更改提供了非常快速的反馈循环。默认情况下,将监视 Classpath 上指向文件夹的任何条目的更改。请注意,某些资源,例如静态资产和视图模板不需要重新启动应用程序

    Triggering a restart

    当 DevTools 监视 Classpath 资源时,触发重启的唯一方法是更新 Classpath。导致 Classpath 更新的方式取决于您使用的 IDE。在 Eclipse 中,保存修改后的文件将导致 Classpath 被更新并触发重新启动。在 IntelliJ IDEA 中,构建项目(Build -> Build Project)具有相同的效果。

    Note

    只要启用了分叉,您还可以使用受支持的构建插件(Maven 和 Gradle)来启动应用程序,因为 DevTools 需要隔离的应用程序类加载器才能正常运行。默认情况下,Gradle 和 Maven 在 Classpath 上检测到 DevTools 时会这样做。

    Tip

    与 LiveReload 一起使用时,自动重新启动效果很好。 请参阅“ LiveReload”部分了解详情。如果使用 JRebel,则禁用自动重新启动,而有利于动态类重新加载。仍可以使用其他 devtools 功能(例如 LiveReload 和属性替代)。

    Note

    DevTools 依靠应用程序上下文的关闭钩子在重新启动期间将其关闭。如果禁用了关机钩子(SpringApplication.setRegisterShutdownHook(false)),它将无法正常工作。

    Note

    在确定 Classpath 上的条目是否应在更改后触发重新启动时,DevTools 会自动忽略名为spring-bootspring-boot-devtoolsspring-boot-autoconfigurespring-boot-actuatorspring-boot-starter的项目。

    Note

    DevTools 需要自定义ApplicationContext使用的ResourceLoader。如果您的应用程序已经提供了,它将被包装。不支持在ApplicationContext上直接覆盖getResource方法。

    Restart vs Reload

    Spring Boot 提供的重启技术通过使用两个类加载器来工作。不变的类(例如,来自第三方 jar 的类)将被加载到* base 类加载器中。您正在积极开发的类将加载到 restart 类加载器中。重新启动应用程序后,将丢弃 restart 类加载器,并创建一个新的类加载器。这种方法意味着应用程序的重启通常比“冷启动”要快得多,因为 base *类加载器已经可用并已填充。

    如果您发现重新启动对于应用程序而言不够快,或者遇到类加载问题,则可以考虑从 ZeroTurnaround 重新加载诸如JRebel之类的技术。这些方法通过在加载类时重写类来使其更易于重新加载。

    20.2.1 记录条件评估中的更改

    默认情况下,每次应用程序重新启动时,都会记录一个报告,其中显示了条件评估增量。该报告显示了在进行更改(例如添加或删除 bean 以及设置配置属性)时对应用程序自动配置的更改。

    要禁用报告的日志记录,请设置以下属性:

    spring.devtools.restart.log-condition-evaluation-delta=false
    

    20.2.2 排除资源

    某些资源在更改时不一定需要触发重新启动。例如,Thymeleaf 模板可以就地编辑。默认情况下,更改/META-INF/maven/META-INF/resources/resources/static/public/templates中的资源不会触发重新启动,但会触发live reload。如果要自定义这些排除项,则可以使用spring.devtools.restart.exclude属性。例如,要仅排除/static/public,则可以设置以下属性:

    spring.devtools.restart.exclude=static/**,public/**
    

    Tip

    如果要保留这些默认值并“添加”其他排除项,请改用spring.devtools.restart.additional-exclude属性。

    20.2.3 注意其他路径

    当您对不在 Classpath 上的文件进行更改时,您可能希望重新启动或重新加载应用程序。为此,使用spring.devtools.restart.additional-paths属性配置其他路径以监视更改。您可以使用spring.devtools.restart.exclude属性described earlier来控制其他路径下的更改是触发完全重启还是live reload

    20.2.4 禁用重启

    如果您不想使用重新启动功能,则可以使用spring.devtools.restart.enabled属性将其禁用。在大多数情况下,您可以在application.properties中设置此属性(这样做仍会初始化重新启动类加载器,但它不会监视文件更改)。

    如果您需要完全禁用重启支持(例如,因为它不适用于特定的库),则需要在调用SpringApplication.run(…)之前将spring.devtools.restart.enabled System属性设置为false,如以下示例所示:

    public static void main(String[] args) {
    	System.setProperty("spring.devtools.restart.enabled", "false");
    	SpringApplication.run(MyApp.class, args);
    

    20.2.5 使用触发文件

    如果使用持续编译更改文件的 IDE,则可能更喜欢仅在特定时间触发重新启动。为此,可以使用“触发文件”,这是一个特殊文件,当您要实际触发重新启动检查时必须对其进行修改。更改文件只会触发检查,并且仅在 Devtools 检测到必须执行某些操作时才会重新启动。可以手动或使用 IDE 插件来更新触发文件。

    要使用触发文件,请将spring.devtools.restart.trigger-file属性设置为触发文件的路径。

    Tip

    您可能希望将spring.devtools.restart.trigger-file设置为global setting,以便所有项目的行为都相同。

    20.2.6 自定义重启类加载器

    如前面的重新启动与重新加载部分所述,重新启动功能是通过使用两个类加载器实现的。对于大多数应用程序,此方法效果很好。但是,有时可能会导致类加载问题。

    默认情况下,IDE 中的任何打开的项目都将使用“重新启动”类加载器加载,而任何常规的.jar文件都将使用“基本”类加载器加载。如果您在多模块项目上工作,并且并非每个模块都导入到 IDE 中,则可能需要自定义内容。为此,您可以创建一个META-INF/spring-devtools.properties文件。

    spring-devtools.properties文件可以包含以restart.excluderestart.include为前缀的属性。 include元素是应上拉到“重新启动”类加载器中的项目,而exclude元素是应下推到“基本”类加载器中的项目。该属性的值是一个应用于 Classpath 的正则表达式模式,如以下示例所示:

    restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
    restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar
    

    Note

    所有属性键都必须是唯一的。只要属性以restart.include.restart.exclude.开头,它就会被考虑。

    Tip

    Classpath 中的所有META-INF/spring-devtools.properties都已加载。您可以将文件打包在项目内部或项目使用的库中。

    20.2.7 已知限制

    重新启动功能不适用于使用标准ObjectInputStream反序列化的对象。如果需要反序列化数据,则可能需要结合使用 Spring 的ConfigurableObjectInputStreamThread.currentThread().getContextClassLoader()

    不幸的是,一些第三方库在不考虑上下文类加载器的情况下反序列化。如果发现这样的问题,则需要向原始作者请求修复。

    20.3 LiveReload

    spring-boot-devtools模块包括一个嵌入式 LiveReload 服务器,该服务器可用于在更改资源时触发浏览器刷新。可从livereload.com免费为 Chrome,Firefox 和 Safari 使用 LiveReload 浏览器扩展。

    如果您不想在应用程序运行时启动 LiveReload 服务器,则可以将spring.devtools.livereload.enabled属性设置为false

    Note

    一次只能运行一台 LiveReload 服务器。在启动应用程序之前,请确保没有其他 LiveReload 服务器正在运行。如果从 IDE 启动多个应用程序,则只有第一个具有 LiveReload 支持。

    20.4 全局设置

    您可以通过将名为.spring-boot-devtools.properties的文件添加到$HOME文件夹中来配置全局 devtools 设置(请注意,文件名以“.”开头)。添加到该文件的所有属性都适用于您机器上所有使用 devtools 的 Spring Boot 应用程序。例如,要将重新启动配置为始终使用trigger file,则应添加以下属性:

    ~/.spring-boot-devtools.properties.

    spring.devtools.reload.trigger-file=.reloadtrigger
    

    Note

    .spring-boot-devtools.properties中激活的配置文件不会影响特定于配置文件的配置文件的加载。

    20.5 远程应用程序

    Spring Boot 开发人员工具不仅限于本地开发。远程运行应用程序时,您还可以使用多种功能。选择加入远程支持。要启用它,您需要确保重新打包的 Files 中包含devtools,如以下 Lists 所示:

    <build>
    	<plugins>
    		<plugin>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-maven-plugin</artifactId>
    			<configuration>
    				<excludeDevtools>false</excludeDevtools>
    			</configuration>
    		</plugin>
    	</plugins>
    </build>
    

    然后,您需要设置一个spring.devtools.remote.secret属性,如以下示例所示:

    spring.devtools.remote.secret=mysecret
    

    Warning

    在远程应用程序上启用spring-boot-devtools是安全隐患。您永远不应在生产部署上启用支持。

    远程 devtools 支持分为两部分:接受连接的服务器端端点和在 IDE 中运行的 Client 端应用程序。设置spring.devtools.remote.secret属性后,将自动启用服务器组件。Client 端组件必须手动启动。

    20.5.1 运行远程 Client 端应用程序

    远程 Client 端应用程序旨在在您的 IDE 中运行。您需要使用与您连接到的远程项目相同的 Classpath 来运行org.springframework.boot.devtools.RemoteSpringApplication。应用程序的单个必需参数是它连接到的远程 URL。

    例如,如果您使用的是 Eclipse 或 STS,并且您有一个名为my-app的项目已部署到 Cloud Foundry,则可以执行以下操作:

    Run菜单中选择Run Configurations…

    创建一个新的Java Application“启动配置”。

    浏览my-app项目。

    使用org.springframework.boot.devtools.RemoteSpringApplication作为主要类。

    https://myapp.cfapps.io添加到Program arguments(或任何远程 URL)。

    正在运行的远程 Client 端可能类似于以下 Lists:

    .   ____          _                                              __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
     \\/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
      '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /
     =========|_|==============|___/===================================/_/_/_/
     :: Spring Boot Remote :: 2.1.1.RELEASE
    2015-06-10 18:25:06.632  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code/spring-boot-samples/spring-boot-sample-devtools)
    2015-06-10 18:25:06.671  INFO 14938 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.spring[emailprotected]2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy
    2015-06-10 18:25:07.043  WARN 14938 --- [           main] o.s.b.d.r.c.RemoteClientConfiguration    : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'.
    2015-06-10 18:25:07.074  INFO 14938 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
    2015-06-10 18:25:07.130  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)
    

    Note

    因为远程 Client 端使用与真实应用程序相同的 Classpath,所以它可以直接读取应用程序属性。这就是读取spring.devtools.remote.secret属性并将其传递给服务器进行身份验证的方式。

    Tip

    始终建议使用https://作为连接协议,以便对通信进行加密并且不能截获密码。

    Tip

    如果需要使用代理来访问远程应用程序,请配置spring.devtools.remote.proxy.hostspring.devtools.remote.proxy.port属性。

    20.5.2 远程更新

    远程 Client 端以与local restart相同的方式监视应用程序 Classpath 中的更改。任何更新的资源都被推送到远程应用程序,并且(如果需要)触发重新启动。如果您迭代使用本地没有的云服务的功能,这将很有帮助。通常,远程更新和重新启动比完整的重建和部署周期要快得多。

    Note

    仅在远程 Client 端正在运行时监视文件。如果在启动远程 Client 端之前更改文件,则不会将其推送到远程服务器。