Index
A
- Abstract Window Toolkit (AWT) / Configuring custom PropertyEditors
- ACID (Atomic, Consistent, Isolated, Durable) / Pulling data through a Mono/Flux and chain of operations
- Actuator endpoint
- autoconfig / Adding production-ready support, Working with additional Actuator endpoints
- beans / Adding production-ready support, Working with additional Actuator endpoints
- configprops / Adding production-ready support, Working with additional Actuator endpoints
- dump / Adding production-ready support
- env / Adding production-ready support, Working with additional Actuator endpoints
- health / Adding production-ready support, Working with additional Actuator endpoints
- info / Adding production-ready support, Working with additional Actuator endpoints
- metrics / Adding production-ready support, Working with additional Actuator endpoints
- mappings / Adding production-ready support, Working with additional Actuator endpoints
- trace / Adding production-ready support
- working with / Working with additional Actuator endpoints
- auditevents / Working with additional Actuator endpoints
- heapdump / Working with additional Actuator endpoints
- logfile / Working with additional Actuator endpoints
- loggers / Working with additional Actuator endpoints
- status / Working with additional Actuator endpoints
- Actuator module / Adding production-ready support
- Advanced Message Queuing Protocol (AMQP)
- about / Learning about the Turbine server, Getting started with RabbitMQ
- fundamentals / AMQP fundamentals
- airline Bookings microservice / The airline Bookings microservice
- airline Payments microservice / The airline Payments microservice
- Airline Ticket System
- about / The Airline Ticket System
- functionalities / Airline functionalities
- solution diagram / Solution diagram
- AJAX calls
- handling, on server / Handling AJAX calls on the server
- Allowed Origin / Configuring WebSocket handlers
- Amazon Web Services (AWS) / Calling one microservice from another with client-side load balancing
- AngularJS
- CMS application, integrating with / Integrate with AngularJS
- concepts / AngularJS concepts
- controllers / Controllers
- services / Services
- application entry point, creating / Creating the application entry point
- Category Controller, creating / Creating the Category Controller
- Category Service, creating / Creating the Category Service
- AOP (Aspect Oriented Programming) / Implementing microservice circuit breakers
- Apache Tomcat
- Embedded Netty, from / Switching from Embedded Netty to Apache Tomcat
- APIs
- testing / Testing APIs
- API strangling
- about / Creating a Gateway API
- reference / Creating a Gateway API
- application
- bundling, as runnable JAR file / Bundling up the application as a runnable JAR file
- changes, viewing on target system / Making local changes and seeing them on the target system
- changes, making / Making local changes and seeing them on the target system
- changes, viewing / Making local changes and seeing them on the target system
- messaging, adding as new component / Adding messaging as a new component to an existing application
- pushing, to Cloud Foundry / Pushing app to Cloud Foundry and adjusting the settings
- launching, Gradle used / Launching an application using Gradle
- application properties, Spring Boot reference documentation
- reference / How it works...
- application settings
- asynchronous web client
- authentication
- versus authorization / Authentication versus authorization
- about / Authentication versus authorization
- Authentication microservice
- creating / Creating the Authentication microservice
- Auth microservice
- creating / Creating the Auth microservice
- security, configuring / Configuring the security
- testing / Testing the Auth microservice
- client credentials flow / Client credentials flow
- implicit grant flow / Implicit grant flow
- authorization / Authentication versus authorization
- authorizing methods / Authorizing methods
- autoconfiguration report
B
- babel.js
- reference / Creating a Gateway API
- backpressure / Learning the tenets of reactive programming
- basic RESTful application
- behavior-driven development (BDD) / Introduction
- bindings
- configuring, on Spring AMQP / Configuring exchanges, queues, and bindings on Spring AMQP
- declaring, in yaml / Declaring exchanges, queues, and bindings in yaml
- book catalog management system
- creating / Creating a simple application, How to do it..., How it works...
- build data
- adding, to /application/info / Adding build data to /application/info
C
- callback hell / Creating a reactive ImageService
- calls
- tracing / Tracing calls
- capabilities, Spring Data
- reference / How it works...
- cascade failure / When the services fail, hello Hystrix
- CategoryResource class
- creating / Creating the CategoryResource class
- certificate keystore
- reference / Getting ready
- chat microservice
- about / Consuming WebSocket messages from the web page
- securing / Securing the chat microservice
- authentication, versus authorization / Authentication versus authorization
- chat service
- saved comments, publishing to / Publishing saved comments to a chat service
- creating, to handle WebSocket traffic / Creating a chat service to handle WebSocket traffic
- WebSocket messages, brokering / Brokering WebSocket messages
- saved comments, broadcasting / Broadcasting saved comments
- WebSocket handlers, configuring / Configuring WebSocket handlers
- Circuit Breaker pattern
- reference / Hystrix in a nutshell
- circuit breaker solution
- reference / Implementing microservice circuit breakers
- circuits
- monitoring / Monitoring circuits
- classic Spring MVC
- versus reactive Spring WebFlux / Comparing reactive Spring WebFlux against classic Spring MVC
- client-side load balancing
- microservice, calling / Calling one microservice from another with client-side load balancing
- cloud / Profile-based sets of beans
- cloud-native
- reference / Deploying to Cloud Foundry
- Cloud Foundry
- application, deploying to / Deploying to Cloud Foundry
- installation link / Deploying to Cloud Foundry
- about / Profile-based sets of beans
- application, pushing to / Pushing app to Cloud Foundry and adjusting the settings
- reference / Pushing app to Cloud Foundry and adjusting the settings
- CMS
- Docker image, creating for / Creating the Docker image for CMS
- CMS application
- running / Running the application, Running the application
- @SpringBootApplication annotation / Looking under the hood
- @Configuration annotation / Looking under the hood
- @EnableAutoConfiguration annotation / Looking under the hood
- @Component annotation / Looking under the hood
- executing, in IntelliJ IDEA / IntelliJ IDEA
- executing, in command line / Command line
- CMS application structure
- creating / Creating the CMS application structure
- CMS project
- about / The CMS project
- entities / The CMS project
- metadata section / Project metadata section
- dependencies section / The dependencies section
- generating / Generating the project
- code generation / Solving a problem
- cold publishers / Let's play with the Reactor
- command-line runners
- command line
- used, for running CMS application / Command line
- using, with Spring Boot Maven plugin / Command line via the Maven goal
- using, with JAR file / Command line via the JAR file
- commands, Docker
- docker run / Docker run
- docker container / Docker container
- docker network / Docker network
- docker volume / Docker volume
- companion object / Companion objects
- components, Project Reactor
- publishers / Components
- subscribers / Components
- Config Server
- microservice settings, offloading / Offloading microservice settings to a configuration server
- settings, offloading / Offloading microservice settings to a configuration server
- securing / Securing the Config Server
- Config Server project
- creating / Creating the Config Server project
- configuration
- toggling, custom @Enable annotations used / Using custom @Enable annotations to toggle configuration, How it works...
- configuration property bean
- creating / Creating configuration property beans
- constructor injection / Creating a reactive ImageService, Creating custom metrics, Displaying comments
- Consul
- setting up / Setting up Consul, How to do it..., How it works...
- reference / How to do it...
- used, for externalizing environmental configuration / Externalizing an environmental config using Consul and envconsul, How it works...
- consumer groups
- containerized solution
- running / Running the containerized solution
- Content Delivery Network
- about / Creating the application entry point
- reference / Creating the application entry point
- content delivery networks (CDN) / Profile-based sets of beans
- Content Management System (CMS) application
- integrating, with AngularJS / Integrate with AngularJS
- controllers / Controllers
- core container / Core container
- Cross-origin Resource Sharing (CORS) / Configuring WebSocket handlers
- Cucumber
- used, for writing tests / Writing tests using Cucumber, How to do it..., How it works...
- Cucumber-JVM
- reference / Writing tests using Cucumber
- cURL
- reference / How to do it...
- custom @Enable annotations
- used, for toggling configuration / Using custom @Enable annotations to toggle configuration, How it works...
- custom conditional bean instantiations
- custom connectors
- custom finders
- creating / Creating custom finders
- custom health check
- writing / Writing a custom health check
- custom health indicators
- custom HttpMessageConverters
- configuring / Configuring custom HttpMessageConverters, How to do it..., How it works...
- custom interceptors
- configuring / Configuring custom interceptors, How to do it..., How it works...
- customized metrics
- adding, for tracking message flow / Adding customized metrics to track message flow
- custom metrics
- creating / Creating custom metrics
- custom PropertyEditors
- configuring / Configuring custom PropertyEditors, How to do it..., How it works...
- custom PropertySource
- adding, to environment / Adding a custom PropertySource to the environment using EnvironmentPostProcessor, How it works...
- custom remote Shell commands
- custom servlet filters
- configuring / Configuring custom servlet filters, How it works...
- custom Spring Boot autoconfiguration
- custom Spring Boot autoconfiguration starter
- custom static path mappings
- configuring / Configuring custom static path mappings, How to do it..., How it works...
- custom type formatters
- configuring / Configuring custom type formatters, How to do it..., How it works...
D
- DAO (Data Access Object) / Spring Data JPA
- Dashing
- Micrometer metrics, integrating with / Integrating Micrometer metrics with Dashing, How to do it..., How it works...
- data access layer
- creating / Creating the final data access layer
- database
- initializing, with Spring JPA / Initializing the database with Spring JPA and Hibernate
- initializing, with Hibernate / Initializing the database with Spring JPA and Hibernate
- initializing, with Spring JDBC / Initializing the database with Spring JDBC
- database connection
- setting up / Setting up a database connection, Getting ready, How to do it..., How it works...
- database schema
- data repository service
- setting up / Setting up a data repository service, How it works...
- data types, Redis
- strings / Data types
- lists / Lists
- sets / Sets
- Debug mode / Creating a message producer/message consumer
- dependencies
- about / Getting started
- testing / Test dependencies
- Dependency Management Gradle plugin
- development environment
- setting up / Setting up our development environment
- Dialect / Tailoring the UI with authorization checks
- direct exchange / AMQP fundamentals
- distribution summary file / Creating custom metrics
- Docker
- installing / Installing Docker
- reference / Installing Docker
- bridge / Docker networks
- overlay network / Docker networks
- basics / Learning the basics of Docker
- RabbitMQ server, starting with / Starting the RabbitMQ server with Docker
- infrastructure, placing on / Putting the infrastructure on Docker
- docker-compose file
- creating / Creating a docker-compose file
- docker-compose project
- reference / Dockerizing the whole solution
- docker-compose tool
- about / The docker-compose tool
- installing / Installing docker-compose
- solution, running / Running the solution
- network, testing / Testing the network
- Docker-Maven-plugin
- configuring / Configuring the docker-maven-plugin
- adding, on pom.xml / Adding the plugin on pom.xml
- Docker commands / Docker commands
- docker container command / Docker container
- Docker containers / Containers
- Docker Hub
- image, pushing to / Pushing the image to Docker Hub
- Redis image, pulling from / Pulling the Redis image from the Docker Hub
- RabbitMQ image, pulling from / Pulling the RabbitMQ image from Docker Hub
- reference / Creating Docker images
- Docker images
- about / Docker images
- creating, for CMS / Creating the Docker image for CMS
- creating / Creating Docker images, How to do it..., How it works...
- Dockerized CMS
- running / Running the Dockerized CMS
- Docker network
- about / Docker networks
- creating, for application / Creating a Docker network for our application
- docker network command / Docker network
- docker run command / Docker run
- Docker Spring profile
- configuring / Configuring the Docker Spring profile
- Docker Swarm / The docker-compose tool
- docker volume command / Docker volume
- Docker volumes / Docker volumes
- Domain-Driven Design (DDD) / Airline functionalities
- DRY (Don't Repeat Yourself) / Testing with a real MongoDB database
- DS (Discovery Service) / Calling one microservice from another with client-side load balancing
- DSL (Domain-Specific Language) / Spring Security, Spring Data for Reactive Extensions
- dynamic application restart triggers
- configuring / Configuring dynamic application restart triggers, How it works...
E
- EDGE server
- creating / Creating the EDGE server
- EDGE service project / Understanding the EDGE service project
- Elvis operator / Elvis operator
- Embedded Netty
- reference / Switching from Embedded Netty to Apache Tomcat
- switching, to Apache Tomcat / Switching from Embedded Netty to Apache Tomcat
- embedded servlet containers
- selecting / Choosing embedded servlet containers, How it works...
- embedded Spring Boot app tests / Fully embedded Spring Boot app tests
- envconsul
- used, for externalizing environmental configuration / Externalizing an environmental config using Consul and envconsul, How it works...
- environment
- custom PropertySource, adding to / Adding a custom PropertySource to the environment using EnvironmentPostProcessor, How it works...
- environmental configuration
- about / Spring Boot environment configuration, hierarchy, and precedence, How it works...
- externalizing, property files used / Externalizing an environmental configuration using property files, How to do it..., How it works...
- externalizing, environment variables used / Externalizing an environmental configuration using environment variables, How it works...
- externalizing, Java system properties used / Externalizing an environmental configuration using Java system properties, How to do it..., How it works...
- externalizing, JSON used / Externalizing an environmental config using JSON, How it works...
- externalizing, Consul used / Externalizing an environmental config using Consul and envconsul
- externalizing, envconsul used / Externalizing an environmental config using Consul and envconsul
- EnvironmentPostProcessor
- custom PropertySource, adding to environment / Adding a custom PropertySource to the environment using EnvironmentPostProcessor, How it works...
- Eureka
- services, searching / Dynamically registering and finding services with Eureka
- services, registering / Dynamically registering and finding services with Eureka
- reference / Introducing @SpringCloudApplication
- service discovery / Service discovery using Spring Cloud Netflix – Eureka
- Eureka server
- checking / Checking the Eureka server
- securing / Securing the Eureka Server
- Eureka server main class
- creating / Creating the Eureka server main class
- exchanges
- configuring, on Spring AMQP / Configuring exchanges, queues, and bindings on Spring AMQP
- declaring, in yaml / Declaring exchanges, queues, and bindings in yaml
- about / AMQP fundamentals
- exchanges, RabbitMQ
- about / Exchanges
- direct exchanges / Direct exchanges
- fanout exchanges / Fanout exchanges
- topic exchanges / Topic exchanges
- header exchanges / Header exchanges
- executors
- scheduling / Scheduling executors, How to do it...
F
- fabric8
- reference / Configuring the docker-maven-plugin
- fanout exchange / AMQP fundamentals
- Fat-JAR / Running the application
- fat JAR / Getting started
- Feign
- field injection
- reference / Querying with MongoOperations
- final product
- testing / Checking out the final product
- Flapdoodle / Spring Boot starters
- Flight microservice project
- cloning / Cloning the Flight microservice project
- Flights microservice / Flights microservice
- Flux
- used, for pulling data / Pulling data through a Mono/Flux and chain of operations
- Flyway / How it works...
- functional reactive programming (FRP) / Introducing user chatting
- functions
- declaring, in Kotlin / Declaring functions in Kotlin
G
- Gateway API
- about / Using Spring Session
- creating / Creating a Gateway API
- Git / Spring Cloud Config
- GitHub repository addresses, for projects
- references / Dockerizing the microservices
- Gradle
- used, for launching application / Launching an application using Gradle
- Gradle-Docker plugin configuration options
- reference / How it works...
- Gradle multi-project builds
- reference / How it works...
- Graphite
- Micrometer metrics, integrating with / Integrating Micrometer metrics with Graphite, Getting ready, How to do it..., How it works...
H
- Hibernate
- reference / Spring Data JPA
- database, initializing / Initializing the database with Spring JPA and Hibernate
- hierarchy / Spring Boot environment configuration, hierarchy, and precedence
- Homebrew
- reference / Installing RabbitMQ broker
- hot code
- reloading, Spring Boot's DevTools used / Using Spring Boot's DevTools for hot code reloading
- hot publishers / Let's play with the Reactor
- hprof heap dump / Working with additional Actuator endpoints
- httpbin
- HTTPie
- reference / Showing some Mono/Flux-based endpoints
- HTTP protocol
- about / A few words about the HTTP protocol
- and persistent connections / HTTP and persistent connections
- Hyper SQL Database (HSQLDB) / Getting ready
- Hypertext Application Language (HAL) / How it works...
- Hystrix
- overview / Hystrix in a nutshell
- collection commands statistics / Collection commands statistics with Hystrix
- about / How it works...
- using / Using Spring Cloud Netflix – Hystrix, How to do it..., How it works...
- Hystrix Dashboard / Hystrix Dashboard, Monitoring circuits
I
- IDE
- installing / Installing IDE
- image ownership
- wiring / Wiring in image ownership
- authorizing methods / Authorizing methods
- images microservice
- securing / Securing the images microservice
- method security / Securing the images microservice
- immediately-invoked function expression (IIFE) / Consuming WebSocket messages from the web page, Creating a Gateway API
- in-memory database
- used, for creating tests / Creating tests using an in-memory database, How to do it..., How it works...
- integration testing / Creating tests for MVC controllers
- IntelliJ IDEA
- about / IntelliJ IDEA
- used, for running CMS application / IntelliJ IDEA
- IPC (Inter-Process Communication) / Netflix Ribbon
J
- Jackson
- adding, for Kotlin / Adding Jackson for Kotlin
- JAR file
- command line, using with / Command line via the JAR file
- Java Persistence API (JPA) / How it works...
- Java system properties
- used, for externalizing environmental configuration / Externalizing an environmental configuration using Java system properties, How it works...
- JCP (Java Community Process) / Spring Data JPA
- JMX
- Spring Boot, monitoring via / Monitoring Spring Boot via JMX, How to do it...
- jOOQ / Solving a problem
- JPA (Java Persistence API) / Solving a problem
- JPA component test
- creating / Creating a JPA component test, How to do it..., How it works...
- JRebel
- JSON
- used, for externalizing environmental configuration / Externalizing an environmental config using JSON, How it works...
- JsonPath
- reference / Pinging our app for general health
- JsonSlurper
- reference / Pinging our app for general health
- JSON Viewer
- JSR 356
- versus Spring WebFlux messaging / JSR 356 versus Spring WebFlux messaging
- JVM (Java Virtual Machine) / Learning Kotlin basics
K
- Kotlin
- basics / Learning Kotlin basics
- characteristics / Main characteristics of Kotlin
- syntax / Syntax
- semantics / Semantics
- functions, declaring in / Declaring functions in Kotlin
- simple function, with parameters / Simple function with parameters and return type
- simple function, with return type / Simple function with parameters and return type
- simple function, without return / Simple function without return
- single expressions functions / Single expressions functions
- functions, overriding / Overriding a function
- data classes / Data classes
- objects / Objects
- companion objects / Companion objects
- project, creating / Creating the project
- project use case / Project use case
- Jackson, adding for / Adding Jackson for Kotlin
- Kotlin idioms
- string interpolation / Kotlin idioms
- Smart Casts / Smart Casts
- range expressions / Range expressions
- null safety / Null safety
- kryo
- reference / Introduction to Spring Cloud
L
- Liquibase
- reference / How it works...
- lists
- about / Lists
- main commands / Main commands
- LiveReload
- reference / Using Spring Boot's DevTools for hot code reloading, How to do it...
- configuring / Configuring LiveReload
- load balancing rules
- reference / How it works...
M
- Mail microservice
- creating / Creating the Mail microservice
- running / Running the Mail microservice
- Mail microservice project
- creating / Creating the Mail microservice project
- RabbitMQ dependencies, adding / Adding RabbitMQ dependencies
- RabbitMQ stuff, configuring / Configuring some RabbitMQ stuff
- Mail message, modeling / Modeling a Mail message
- MailSender class / The MailSender class
- RabbitMQ queue listener, creating / Creating the RabbitMQ queue listener
- management context
- configuring / Configuring management context, How to do it..., How it works...
- Matt Stine
- reference / A quick primer on microservices
- Maven
- installing / Installing Maven
- Maven plugins
- for Kotlin / Looking for the Maven plugins for Kotlin
- message flow
- tracking, by adding customized metrics / Adding customized metrics to track message flow
- message producer/message consumer
- creating / Creating a message producer/message consumer
- comments, displaying / Displaying comments
- comments, producing / Producing comments
- about / AMQP fundamentals
- messages
- consuming, with Spring messaging / Consuming messages with Spring Messaging
- producing, with Spring messaging / Producing messages with Spring Messaging
- messaging
- adding, as new component to existing application / Adding messaging as a new component to an existing application
- method security / Securing the images microservice
- metrics
- collecting, with Zipkin / Collecting metrics with Zipkin
- emitting / Emitting metrics, Getting ready, How to do it..., How it works...
- Micrometer
- reference / Metrics, Creating custom metrics
- Micrometer metrics
- integrating, with Graphite / Integrating Micrometer metrics with Graphite, Getting ready, How to do it..., How it works...
- integrating, with Dashing / Integrating Micrometer metrics with Dashing, How to do it..., How it works...
- microservice
- integrations, testing / Testing the microservice's integrations
- monitoring / Monitoring the microservices
- dockerizing / Dockerizing the microservices
- about / A quick primer on microservices
- calling, with client-side load balancing / Calling one microservice from another with client-side load balancing
- settings offloading, to configuration server / Offloading microservice settings to a configuration server
- session details, sharing with / Sharing session details with other microservices
- microservice circuit breakers
- implementing / Implementing microservice circuit breakers
- MockMvc
- reference / How it works...
- mock objects
- used, for creating tests / Creating tests using mock objects, How to do it..., How it works...
- modules, Spring / Spring modularity
- MongoDB
- preparing / Preparing MongoDB
- installation link / Getting underway with a reactive data store
- MongoOperations
- querying with / Querying with MongoOperations
- Mono
- used, for pulling data / Pulling data through a Mono/Flux and chain of operations
- Mono/Flux-based endpoints / Showing some Mono/Flux-based endpoints
- Multirun
- MVC controllers
- tests, creating for / Creating tests for MVC controllers, How to do it..., How it works...
N
- named client / Spring Cloud Netflix
- Netflix Ribbon / Netflix Ribbon
- Netty
- reference / Spring WebFlux
- about / Spring WebFlux
- NewsResource class / NewsResource
- null safety, Kotlin
- safe calls / Safe calls
- Elvis operator / Elvis operator
O
- OAuth 2.0 flow
- entities / Creating the Authentication microservice
- OAuth 2.0, for protecting microservices
- about / Protecting the microservices with OAuth 2.0
- security dependency, adding / Adding the security dependency
- application.yaml file, configuring / Configuring the application.yaml file
- JwtTokenStore Bean, creating / Creating the JwtTokenStore Bean
- object-relational mapping (ORM) / Setting up a data repository service
- OpenJDK
- installing / Installing OpenJDK
- OSI model
- reference / A few words about the HTTP protocol
P
- pagination / Adding the repository layer
- pgAdmin3
- about / Installing and configuring pgAdmin3
- installing / Installing and configuring pgAdmin3
- configuring / Installing and configuring pgAdmin3
- Pivotal Web Services (PWS)
- reference / Deploying to Cloud Foundry
- about / Deploying to Cloud Foundry
- plane microservice
- running / Running the plane microservice
- Plane service
- creating / Creating the Plane service
- planes microservice
- creating / Creating the planes microservice
- coding / Coding the planes microservice
- reactive repository / The reactive repository
- POJO (Plain Old Java Object) pattern / Spring Data MongoDB
- pom.xml
- configuring, for Spring Data JPA / Configuring pom.xml for Spring Data JPA
- PostgreSQL database
- preparing / Preparing a PostgreSQL database
- Postman / Service discovery and load balancing in practice
- precedence / Spring Boot environment configuration, hierarchy, and precedence
- production
- property settings, overriding / Overriding property settings in production
- production-ready support
- adding, to Spring Boot application / Adding production-ready support
- profile-based beans / Profile-based sets of beans
- project
- creating, with Spring Initializr / Creating the project with Spring Initializr
- Project Lombok
- reference / Coding the planes microservice, Spring Boot starters
- about / Spring Boot starters
- Project Reactor
- about / Project Reactor
- components / Components
- reference / Introducing Reactor types
- projects, Spring Cloud
- Spring Cloud Netflix / Spring Cloud Netflix
- Spring Cloud Config / Spring Cloud Config
- Spring Cloud Consul / Spring Cloud Consul
- Spring Cloud Security / Spring Cloud Security
- Spring Cloud Bus / Spring Cloud Bus
- Spring Cloud Stream / Spring Cloud Stream
- property
- exploring / Delving into Spring Boot's property support
- property files
- used, for externalizing environmental config / Externalizing an environmental configuration using property files, How to do it..., How it works...
- property settings
- reference / Delving into Spring Boot's property support
- overriding, in production / Overriding property settings in production
- @ConfigurationProperties, versus @Value / @ConfigurationProperties versus @Value
- publishers / Components
Q
- Query by Example / Querying by example
- queues
- configuring, on Spring AMQP / Configuring exchanges, queues, and bindings on Spring AMQP
- declaring, in yaml / Declaring exchanges, queues, and bindings in yaml
R
- RabbitMQ
- Spring Application, integrating with / Integrating Spring Application and RabbitMQ
- exchanges / Understanding RabbitMQ exchanges, queues, and bindings
- queues / Queues
- bindings / Bindings
- Spring beans, declaring for / Declaring Spring beans for RabbitMQ
- using / Getting started with RabbitMQ
- reference / Installing RabbitMQ broker
- installing / Installing RabbitMQ broker
- reference, in Windows / Launching the RabbitMQ broker
- RabbitMQ broker
- installing / Installing RabbitMQ broker
- launching / Launching the RabbitMQ broker
- RabbitMQ image
- pulling, from Docker Hub / Pulling the RabbitMQ image from Docker Hub
- RabbitMQ JMS Client
- reference / Getting started with RabbitMQ
- RabbitMQ queues
- consuming, reactively / Consuming the RabbitMQ queues reactively
- RabbitMQ Reactor beans
- configuring / Configuring RabbitMQ Reactor beans
- RabbitMQ server
- starting, with Docker / Starting the RabbitMQ server with Docker
- starting / Starting the RabbitMQ server
- range expressions, Kotlin
- simple case / Range expressions
- until case / The until case
- downTo case / The downTo case
- step case / Step case
- React.js
- reference / Securing WebSockets
- reactive data store
- about / Getting underway with a reactive data store
- query, solving / Solving a problem
- Spring Data repositories, wiring up with Spring Boot / Wiring up Spring Data repositories with Spring Boot
- reactive file controller
- creating / Creating a reactive file controller
- reactive ImageService
- creating / Creating a reactive ImageService
- reactive operations
- logging / Logging reactive operations
- reactive programming
- tenets / Learning the tenets of reactive programming
- references / Introducing Reactor types
- need for / Why use reactive programming?
- benefits / Why use reactive programming?
- asynchronous API, need for / Illustrating how going from async to sync can be easy, but the opposite is not
- synchronous API, need for / Illustrating how going from async to sync can be easy, but the opposite is not
- reactive repository
- creating / Creating a reactive repository
- Reactive repository
- working / Reactive repositories in practice
- creating / Creating the first Reactive repository
- reactive sequences
- hot / Hot and cold
- Reactive Spring / Reactive Spring
- reactive Spring WebFlux
- versus classic Spring MVC / Comparing reactive Spring WebFlux against classic Spring MVC
- Reactive Streams
- about / Learning the tenets of reactive programming
- reference / Introducing Reactor types
- reactive types / Reactive types
- reactive web application
- creating, with Spring Initializr / Creating a reactive web application with Spring Initializr
- Reactor
- working with / Let's play with the Reactor
- Reactor operations
- map() / Introducing Reactor types
- flatMap() / Introducing Reactor types
- filter() / Introducing Reactor types
- groupBy() / Introducing Reactor types
- sort() / Introducing Reactor types
- Reactor RabbitMQ / Reactor RabbitMQ
- Reactor types / Introducing Reactor types
- reading comments feature / Displaying comments
- Redis
- about / Understanding Redis
- data types / Data types
- redis-cli tool
- configuring / Configuring the redis-cli tool
- Redis image
- pulling, from Docker Hub / Pulling the Redis image from the Docker Hub
- Redis instance
- running / Running the Redis instance
- Remote Update
- using / Using Remote Update, How to do it...
- restarting
- versus reloading / Using Spring Boot's DevTools for hot code reloading
- REST layer
- modifying / Changing the REST layer
- Spring WebFlux dependency, adding / Adding the Spring WebFlux dependency
- CategoryResource, modifying / Changing the CategoryResource
- REST resources
- creating / Creating the REST resources, Hello REST resources
- Lombok dependency, adding / Models, Adding Lombok dependency
- models, creating / Creating the models
- Tag class, creating / Tag
- Category class, creating / Category
- User class, creating / User
- News class, creating / News
- CategoryResource class / Creating the CategoryResource class
- UserResource class / UserResource
- NewsResource class / NewsResource
- Ribbon / Calling one microservice from another with client-side load balancing
- route
- creating, with Spring Cloud Gateway / Creating our first route with Spring Cloud Gateway
- route matching patterns
- configuring / Configuring route matching patterns, How to do it..., How it works...
- routing keys / AMQP fundamentals
- runnable JAR file
- application, bundling up as / Bundling up the application as a runnable JAR file
S
- @SpringCloudApplication / Introducing @SpringCloudApplication
- SaaS (Software as a Service) / Creating the Mail microservice
- safe calls / Null safety
- SAM (Single Abstract Method) rules / Creating a reactive ImageService
- saved comments
- publishing, to chat service / Publishing saved comments to a chat service
- broadcasting / Broadcasting saved comments
- self-executing binaries
- SendGrid
- about / Creating the Mail microservice
- reference / Creating the SendGrid account
- SendGrid account
- creating / Creating the SendGrid account
- Server-Sent Events (SSE) / Server-Sent Events, Server-Sent Events, Creating the Turbine server microservice
- service discovery
- about / Understanding the service discovery power, Dynamically registering and finding services with Eureka
- REST layer / The REST layer
- client / Understanding the discovery client
- and load balancing / Service discovery and load balancing in practice
- with Spring Cloud Consul / Service discovery using Spring Cloud Consul, How to do it..., How it works...
- with Eureka / Service discovery using Spring Cloud Netflix – Eureka
- service layer
- adding / Adding service layer
- model, modifying / Changes in the model
- new review, adding / Adding a new review
- news, checking / Keeping the news safely
- prerequisites / Before starting the service layer
- CategoryService class, creating / CategoryService
- UserService class, creating / UserService
- NewsService class, creating / NewsService
- Swagger, configuring / Configuring Swagger for our APIs
- fixing / Fixing the service layer
- CategoryService, modifying / Changing the CategoryService
- service layer methods / Authorizing methods
- service registry / Dynamically registering and finding services with Eureka
- services / Services
- service testing / Creating tests for MVC controllers
- ServletWebServerFactory
- Tomcat, tuning via / Tuning Tomcat via ServletWebServerFactory, How to do it..., How it works...
- session / Brokering WebSocket messages
- session details
- sharing, with microservices / Sharing session details with other microservices
- sets
- about / Sets
- main commands / Main commands
- shaded JAR / Getting started
- Signal Handlers
- reference / How it works...
- Simple (or Streaming) Text Oriented Message Protocol (STOMP) / Consuming WebSocket messages from the web page
- simple application
- creating / Creating a simple application, How to do it..., How it works...
- Single Sign-On (SSO) / Creating the Authentication microservice
- slice-based testing
- about / Slice-based testing
- embedded MongoDB, using / Testing with embedded MongoDB
- MongoDB database, using / Testing with a real MongoDB database
- Smart Casts / Smart Casts
- SMTP (Simple Mail Transfer Protocol) / Creating the Mail microservice
- social media platform
- building / Getting started
- Software as a Service (SaaS) / Introduction
- Spock
- used, for writing tests / Writing tests using Spock, How to do it..., How it works...
- reference / How it works...
- Spring
- modules / Spring modularity
- for Apache Kafka / Spring for Apache Kafka
- reference / Using Spring Boot's autoconfiguration report
- spring.io blog
- reference / Spring Security
- Spring Actuator
- about / Spring Actuator
- endpoints / Actuator Endpoints
- application custom information / Application custom information
- endpoints, testing / Testing endpoints
- Spring AMQP
- about / Spring AMQP
- adding, in pom.xml file / Adding Spring AMQP in our pom.xml
- exchanges, configuring / Configuring exchanges, queues, and bindings on Spring AMQP
- queues, configuring / Configuring exchanges, queues, and bindings on Spring AMQP
- bindings, configuring on / Configuring exchanges, queues, and bindings on Spring AMQP
- Spring Application
- integrating, with RabbitMQ / Integrating Spring Application and RabbitMQ
- Spring beans
- declaring, for RabbitMQ / Declaring Spring beans for RabbitMQ
- Spring Boot
- about / Spring Boot
- autoconfiguration report / Using Spring Boot's autoconfiguration report
- autoconfiguration / Understanding Spring Boot autoconfiguration, How it works...
- monitoring, via JMX / Monitoring Spring Boot via JMX, How to do it...
- managing, via SSHd Shell / Managing Spring Boot via SSHd Shell and writing custom remote Shell commands, How to do it..., How it works...
- Spring Boot Actuator
- adding, in pom.xml / Adding Spring Boot Actuator in our pom.xml
- about / Using Spring Boot's autoconfiguration report, Creating custom metrics
- Spring Boot Admin
- about / Spring Boot Admin
- running / Running Spring Boot Admin
- Spring Boot application
- running / Running a Spring Boot application
- production-ready support, adding / Adding production-ready support
- pinging, for general health / Pinging our app for general health
- metrics / Metrics
- securing / Securing a Spring Boot application
- Spring Boot DevTools
- used, for reloading hot code / Using Spring Boot's DevTools for hot code reloading
- about / Creating a message producer/message consumer
- adding, to project / Adding Spring Boot DevTools to a project, How it works...
- reference / Adding Spring Boot DevTools to a project
- Spring Boot executable JAR
- Spring Boot Maven plugin
- command line, using with / Command line via the Maven goal
- Spring Boot starters
- Spring Boot template
- Spring Cloud
- about / Spring Cloud, Introduction to Spring Cloud, Getting started with Spring Cloud, How to do it..., How it works...
- projects / Spring Cloud
- BOM (Bill of Materials) / Introduction to Spring Cloud
- reference / Introduction to Spring Cloud, A quick primer on microservices
- Spring Cloud Bus / Spring Cloud Config, Spring Cloud Bus
- Spring Cloud Config
- about / Spring Cloud Config
- reference / Offloading microservice settings to a configuration server
- Spring Cloud Config Server
- about / Spring Cloud Config Server, Offloading microservice settings to a configuration server
- enabling / Enabling Spring Cloud Config Server
- GitHub, using as repository / Using GitHub as a repository
- Spring Boot application, configuring / Configuring the Spring Boot application
- Git repository, configuring as properties source / Configuring the Git repository as a properties source
- running / Running the Config Server
- testing / Testing our Config Server
- Spring Cloud Consul
- about / Spring Cloud Consul
- reference / Spring Cloud service discovery, How it works...
- service discovery / Service discovery using Spring Cloud Consul, How to do it..., How it works...
- Spring Cloud Eureka
- creating / Creating Spring Cloud Eureka
- Spring Cloud Eureka server
- configuring / Configuring the Spring Cloud Eureka server
- running / Running the Spring Cloud Eureka server
- Spring Cloud Feign / Spring Cloud Netflix
- Spring Cloud Gateway
- about / Spring Cloud Gateway
- running / Running the Spring Cloud Gateway
- route, creating with / Creating our first route with Spring Cloud Gateway
- Spring Cloud Gateway main class
- creating / Creating the Spring Cloud Gateway main class
- Spring Cloud Gateway project
- creating / Creating the Spring Cloud Gateway project
- configuring / Configuring the Spring Cloud Gateway project
- Spring Cloud Hystrix / Spring Cloud Netflix, Spring Cloud Hystrix
- Spring Cloud Netflix
- Spring Cloud Netflix Eureka / Spring Cloud Netflix
- Spring Cloud Ribbon / Spring Cloud Netflix
- Spring Cloud Security / Spring Cloud Security
- Spring Cloud service discovery / Spring Cloud service discovery
- Spring Cloud Sleuth / Spring Cloud Zipkin server and Sleuth
- Spring Cloud Stream
- about / Spring Cloud Stream
- reference / Peeking at Spring Cloud Stream (with RabbitMQ)
- logging with / Logging with Spring Cloud Stream
- Spring Cloud Zipkin server
- about / Spring Cloud Zipkin server and Sleuth
- infrastructure / Infrastructure for the Zipkin server
- creating / Creating the Spring Cloud Zipkin server
- boostrap.yaml, configuring / Configuring boostrap.yaml and application.yaml
- application.yaml, configuring / Configuring boostrap.yaml and application.yaml
- running / Running the Zipkin server
- Spring Cloud Zookeeper
- reference / Spring Cloud service discovery
- Spring Cloud Zuul / Spring Cloud Zuul
- Spring community
- projects / Spring Data project
- Spring container
- Twitter credentials, declaring for / Declaring Twitter credentials for the Spring container
- Spring Core Framework
- about / Spring Core Framework
- core container / Core container
- Spring Data
- about / Spring Data
- for Reactive Extensions / Spring Data for Reactive Extensions
- Spring Data Commons Documentation
- reference / Adding the repository layer
- Spring Data JPA
- about / Spring Data JPA
- pom.xml, configuring for / Configuring pom.xml for Spring Data JPA
- Postgres connections, configuring / Configuring the Postgres connections
- models, mapping / Mapping the models
- JPA repositories, adding in CMS application / Adding the JPA repositories in the CMS application
- transactions, configuring / Configuring transactions
- data, checking on database structure / Checking the data on the database structure
- Spring Data MongoDB
- about / Spring Data MongoDB
- PostgreSQL, removing / Removing the PostgreSQL and Spring Data JPA dependencies
- domain model, mapping / Mapping the domain model
- database connection, configuring / Configuring the database connection
- repository layer, adding / Adding the repository layer
- persistence, checking / Checking the persistence
- Spring Data project / Spring Data project
- Spring Data Reactive / Spring Data Reactive
- Spring Data Reactive Redis
- about / Spring Data Reactive Redis
- ReactiveRedisConnectionFactory, configuring / Configuring the ReactiveRedisConnectionFactory
- ReactiveRedisTemplate, providing / Providing a ReactiveRedisTemplate
- Tracked Hashtag repository, creating / Creating Tracked Hashtag repository
- REST resources, exposing / Exposing the REST resources
- Spring Data repositories
- wiring up, with Spring Boot / Wiring up Spring Data repositories with Spring Boot
- Spring Data REST service
- Spring Expression Language (SpEL) / Authorizing methods
- Spring Fox / Creating the REST resources
- Spring Initializr
- reference / The CMS project, Creating the Config Server project, Getting started, Creating a reactive web application with Spring Initializr, Test dependencies
- project, creating / Creating the project with Spring Initializr
- about / Getting started
- used, for creating reactive web application / Creating a reactive web application with Spring Initializr
- Spring Integration / Spring Integration
- Spring IoC containers / Core container
- Spring IO Platform
- reference / Getting started
- Spring JDBC
- database, initializing / Initializing the database with Spring JDBC
- Spring JMS / Spring JMS
- Spring JPA
- database, initializing / Initializing the database with Spring JPA and Hibernate
- Spring Loaded
- Spring messaging
- about /
- messages, consuming with / Consuming messages with Spring Messaging
- messages, producing with / Producing messages with Spring Messaging
- Spring Messaging
- messages, consuming with / Consuming messages with Spring Messaging
- Spring Messaging AMQP / Spring Messaging AMQP
- Spring MVC
- advantages / Why is Spring doing this?
- Spring MVC (model-view-controller) / Spring Core Framework
- Spring reactive web clients
- about / Spring reactive web clients
- WebClient, producing / Producing WebClient in a Spring Way
- models creation, for gathering tweets / Creating the models to gather Tweets
- authentication, with Twitter APIs / Authentication with Twitter APIs
- server-sent events (SSE) / Some words about server-sent events (SSE)
- gather service, creating / Creating the gather service
- Twitter API, consuming / Listening to the Rabbit Queue and consuming the Twitter API
- Spring Security
- about / Spring Security
- prebuilt rules / Authorizing methods
- reference / Tailoring the UI with authorization checks
- Spring Session
- using / Using Spring Session
- reference / Using Spring Session
- benefits / Using Spring Session
- Gateway API, creating / Creating a Gateway API
- Spring Team
- projects / Spring Data project
- Spring Tools Suite / Spring Tools Suite
- Spring WebFlux
- about / Spring WebFlux, Spring WebFlux
- event-loop model / Event-loop model
- Spring WebFlux messaging
- versus JSR 356 / JSR 356 versus Spring WebFlux messaging
- Spring Web MVC module /
- SSHd Shell
- Spring Boot, managing via / Managing Spring Boot via SSHd Shell and writing custom remote Shell commands, How to do it..., How it works...
- starters / Spring Boot starters
- stereotype annotation / Looking under the hood
- streams
- filtering / Filtering streams
- strings
- about / Strings
- main commands / Main commands
- subscribers / Components
- Swagger
- about / Creating the REST resources
- configuring / Configuring Swagger for our APIs, Configuring Swagger
- dependencies, adding to pom.xml / Adding dependencies to pom.xml
- documented API, creating / First documented API
- system
- running / Running the system
T
- tests
- creating, for MVC controllers / Creating tests for MVC controllers, How to do it..., How it works...
- creating, in-memory database used / Creating tests using an in-memory database, How to do it..., How it works...
- creating, mock objects used / Creating tests using mock objects, How to do it..., How it works...
- writing, Cucumber used / Writing tests using Cucumber, How to do it..., How it works...
- writing, Spock used / Writing tests using Spock, How to do it..., How it works...
- Thymeleaf template
- interacting with / Interacting with a Thymeleaf template
- Tomcat
- tuning, via ServletWebServerFactory / Tuning Tomcat via ServletWebServerFactory, How to do it..., How it works...
- topic exchange / AMQP fundamentals
- Tracked Hashtag repository
- service layer, creating / Creating the service layer
- Tracked Hashtag Service
- modifying / Changing the Tracked Hashtag Service
- Spring Starter RabbitMQ dependency, adding / Adding the Spring Starter RabbitMQ dependency
- RabbitMQ connections, configuring / Configuring the RabbitMQ connections
- exchanges, creating / Creating exchanges, queues, and bindings for the Twitter Hashtag Service
- bindings, creating / Creating exchanges, queues, and bindings for the Twitter Hashtag Service
- queues, creating / Creating exchanges, queues, and bindings for the Twitter Hashtag Service
- messages, sending to broker / Sending the messages to the broker
- running / Running Tracked Hashtag Service
- Tracked Hashtag Service container
- Turbine server / Learning about the Turbine server
- Turbine server microservice
- creating / Creating the Turbine server microservice
- Tweet Dispatcher container
- running / Running the Tweet Dispatcher container
- Tweet Dispatcher project
- creating / Creating the Tweet Dispatcher project
- Spring Initializr, using / Using Spring Initializr once again
- additional dependencies / Additional dependencies
- configuring / Tweet Dispatcher
- Tweet Gathering container
- running / Running the Tweet Gathering container
- Tweet Gathering project
- configuring / Tweet Gathering
- twelve-factor app
- Twelve-Factor App methodology
- about / Introduction
- reference / Introduction
- Twitter
- enabling, in application / Enabling Twitter in our application
- Twitter application
- creating / Creating a Twitter application
- pom.xml, configuring / Configuring pom.xml
- image, creating / Creating the image
- container, running / Running the container
- Twitter credentials
- producing / Producing Twitter credentials
- configuring, in application.yaml / Configuring Twitter credentials in application.yaml
- declaring, for Spring container / Declaring Twitter credentials for the Spring container
- Twitter Gathering project
- creating / Creating the Twitter Gathering project
- structure / Project structure
- running / Running the Twitter Gathering
- testing / Testing stuff
- Twitter setting models
- about / Modelling objects to represent Twitter settings
- Twittertoken / Twittertoken
- TwitterAppSettings / TwitterAppSettings
U
- uber JAR / Getting started
- unit testing / Unit testing, Creating tests for MVC controllers
- user
- registering, without authentication / Registering users without authentication
- linking, to session / Linking a user to a session
- user-specific messages
- sending / Sending user-specific messages
- user-to-user messages
- sending / Sending user-to-user messages
- user chatting / Introducing user chatting
- user interface (UI)
- about / Securing a Spring Boot application
- altering, with authorization checks / Tailoring the UI with authorization checks
- UserResource class / UserResource
V
- @Value
- versus @ConfigurationProperties / @ConfigurationProperties versus @Value
- about / @ConfigurationProperties versus @Value
- version control system (VCS) / Configuring the Spring Cloud Eureka server
- versions, Spring Cloud modules
- reference / How it works...
- vertical slices / Adding messaging as a new component to an existing application
W
- WebFlux controllers
- testing / Testing WebFlux controllers
- WebMvc component test
- webpack
- reference / Creating a Gateway API
- WebSocket handlers
- configuring / Configuring WebSocket handlers
- WebSocket messages
- brokering / Brokering WebSocket messages
- consuming, from web page / Consuming WebSocket messages from the web page
- WebSockets
- about / WebSockets
- securing / Securing WebSockets
- WebSocket traffic
- handling, to create chat service / Creating a chat service to handle WebSocket traffic
- work stealing / Implementing microservice circuit breakers
Y
- yaml
- exchanges, declaring in / Declaring exchanges, queues, and bindings in yaml
- queues, declaring in / Declaring exchanges, queues, and bindings in yaml
- bindings, declaring in / Declaring exchanges, queues, and bindings in yaml
Z
- Zipkin
- metrics, collecting with / Collecting metrics with Zipkin
- ZooKeeper / How it works...