舉報 
會員
Hands-On Microservices with Kotlin
IfyouareaKotlindeveloperwithabasicknowledgeofmicroservicearchitecturesandnowwanttoeffectivelyimplementtheseservicesonenterprise-levelwebapplications,thenthisbookisforyou
最新章節
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Summary
- Dashboard
- Pipeline
- Continuous Delivery
品牌：中圖公司
上架時間：2021-06-30 18:31:00
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:11:44
- Other Books You May Enjoy
- Summary
- Dashboard
- Pipeline
- Continuous Delivery
- Continuous Integration
- Handling CI and CD
- Behavior-Driven Development
- Test Driven Development
- Testing pyramid
- Other tests
- E2E tests
- Integration tests
- Unit tests
- Understanding type of tests
- Testing effectively
- Splitting
- Domains
- Understanding our classes
- Layering the application
- Decouple services
- Explicit context configuration
- Constructor injection
- Managing the Spring context
- Lambda
- Default parameters
- Expressions
- Inferred types
- Using Kotlin idioms
- Best Practices
- Summary
- Updating the application
- Managing our application
- Creating an application
- Publishing to OpenShift
- Uploading to GitHub
- Adding tests
- Creating an example microservice
- Building our application
- Downloading the OpenShift client
- Create an OpenShift account
- Installing Git
- Creating a GitHub account
- Setting things up
- Deploying Microservices
- Summary
- Create management beans
- Using JMX
- Understanding JMX
- Java Managing Extensions
- Protecting Actuator endpoints
- Defining health indicators
- Trace endpoint
- Metrics endpoint
- Health endpoint
- Understanding Actuator's endpoints
- Enabling SpringBoot Actuator
- SpringBoot Actuator
- Building a failing microservice
- Recovering
- Alerting
- What is monitoring?
- Understanding monitoring
- Monitoring Microservices
- Summary
- Testing our controller expressively
- Testing our services expressively
- Adding Kluent
- Fluent tests
- Verifying Mock invocation
- Returning mocked values
- Setting up a mock
- Why we mock
- Mocking beans
- Using MockMvc
- Testing beans
- Understanding SpringBootTest
- Creating a simple microservice
- Understanding SpringBootTest
- Testing Spring Microservices
- Summary
- Controlling the service
- Getting logs from a service
- Scaling instances
- Controlling services
- Creating the service
- Creating our Docker
- Creating a microservice
- Creating a registry
- Publishing a microservice as a service
- Deleting a service
- Getting logs from a service
- Adding a service
- Creating a swarm
- Creating a Cloud
- Scaling down
- Independently scaling
- Design for scaling
- Horizontal scaling
- Vertical scaling
- Scaling directions
- A scalable architecture
- Scaling Microservices
- Summary
- Integrating Docker with Maven
- Publishing a Docker
- Creating an account on Docker Hub
- Understanding repositories
- Publishing Dockers
- Running the microservice
- Dockerize our microservice
- Creating a Dockerfile
- Creating an example microservice
- Building Dockers with microservices
- Managing images
- Pulling images
- Starting with Docker
- Installing Docker
- Docker
- Containers
- Virtual machines
- Understanding containers
- Starting with Docker
- Creating Dockers
- Summary
- Defining routes
- Creating a Gateway
- Gateway
- Using Spring Boot actuator
- Connecting to the Discovery Server
- Creating a Service Discovery Server
- Service discovery
- Using application profiles
- Ciphering data
- Getting configurations
- Creating a Configuration Server
- Configuration Server
- Creating a Spring Cloud microservice
- Spring Cloud Netflix
- Circuit breaker
- Gateway
- Load Balancer
- Service discovery
- Configuration server
- Spring Cloud architecture
- What is a Cloud-Native application?
- Understanding Spring Cloud
- Creating Cloud-Native Microservices
- Summary
- Finding Customers
- Mapping DELETE
- Mapping POST to CREATE
- Mapping GET to READ
- Bringing back our service
- From CRUD to REST
- Using ReactiveMongoTemplate
- Completing our initialization
- Using the repository
- Creating a repository
- Reactive repositories
- Sending commands to MongoDB
- Configuring our connection
- Setting up the project
- Using Spring Data
- Using commands
- Creating a database
- Connecting with the Mongo client
- Starting our database server
- Installing MongoDB
- What is a NoSQL database?
- What is a SQL database?
- NoSQL databases
- Reactive Spring Data
- Summary
- Publishing errors
- Capturing errors on Handlers
- Handling reactive errors
- Processing a JSON body
- Using query parameters
- Handling multiple routes
- Using reactive services
- Creating handlers
- Using RouterFunction
- Using functional web programming
- Receiving objects reactively
- Using Flux in a service
- Publishing multiple objects
- Using Mono in a service
- Publishing a single object
- Understanding subscribers and publishers
- Creating reactive services
- Blocking is not reactive
- Creating a customer service
- Adding a RestController
- Serving static context
- Using Netty
- Creating a Spring WebFlux application
- Understanding Spring WebFlux
- Creating Reactive Microservices
- Summary
- Avoiding the controller advice
- Creating business exceptions
- Using controller advice
- Handling errors
- Validating objects
- Deserializing complex objects
- From a request into an object
- Understanding deserialization
- Handling null values
- Adding telephones to our customers
- Working with complex objects
- Using simple objects
- Understanding serialization
- Working with JSON
- Empty responses
- Answering an UPDATE request
- Answering a DELETE request
- Answering a POST request
- Answering a GET request
- Using ResponseEntity
- Handling HTTP statuses
- Using the service
- Binding the right bean
- Creating an implementation
- Creating a service interface
- Implementing a service layer
- Using verb and mapping annotations
- Handling HTTP PUT
- Handling HTTP DELETE
- Handling HTTP POST
- Handling HTTP verbs
- Generic errors
- Collections
- Single resources
- Standard HTTP verbs and statuses
- HTTP verbs and statuses
- Understanding request parameters
- Defining request parameters
- Understanding path variables
- Getting path variables
- Creating a map of customers
- Path and request parameters
- Understanding our controller
- Creating a RestController
- What is a controller
- Understanding RestController
- Creating RESTful Services
- Summary
- Running different configurations
- Defining beans with conditionals
- Defining an additional bean
- Creating beans explicitly
- Creating conditional beans
- Executing with profiles
- Defining profile values
- Using profiles
- Understanding Spring Expression Language
- Using command-line arguments
- Using Yaml
- Using properties
- Setting configuration values
- Configuring our application
- Creating executable JARs
- Running Spring Boot applications
- Making JARs not WARs
- Packaging
- Packaging and running a Spring Boot application
- Autowiring
- Using components
- Understanding the component scan
- Defining Spring application context
- Creating an application object
- Spring Boot application structure
- Tips and Tricks
- Debugging
- Modifying our microservice
- Executing life cycle phases and goals
- Opening our Maven project
- Using IntelliJ IDEA
- Repositories
- Build
- Dependencies
- Project properties
- Maven parent
- Project definition
- Understanding the POM file
- Introduction to Maven goals
- Life cycle phases
- Using Maven
- Understanding advanced usage
- Gitignore
- Resource files
- Source files
- Maven Files
- Reviewing the generated project files
- Understanding basic usage
- Using Spring Initializr
- Installing IntelliJ IDEA CE 2017.2
- Testing the installation
- Windows
- Unix /MacOS X
- Installing Maven 3.5
- Testing the installation
- Windows
- UNIX/Mac OS X
- Installing JDK 8
- Setting up
- Creating a Spring Boot application
- Getting Started with Spring Boot 2.0
- Summary
- Cloud Native microservices
- Software as a Service
- Platform as a Service
- Infrastructure as a Service
- Service models
- Hybrid cloud
- Public cloud
- Private cloud
- Deployment models
- Containers
- Cloud computing
- Cloud Native microservices
- Reactive microservices
- Akka
- Java reactive streams
- Project Reactor
- Reactive Extensions
- Reactive frameworks
- Back pressure
- Message-driven
- Elastic
- Resilient
- Responsive
- Reactive Manifesto
- Reactive programming
- Reactive microservices
- Using DDD in microservices
- Context mapping
- Bounded context
- Ubiquitous language
- What is Domain-Driven Design
- Domain-Driven Design
- Automation
- Scalability
- Fallbacks
- Recovery
- Alerting
- Monitoring
- Logging
- Downstream
- Upstream
- Build for failure
- Independently deployable
- Isolation
- Hiding implementation
- Single responsibility
- Loosely couple
- Modelled around business capabilities
- Defining design principles
- Microservices principles
- From the monolith to microservices
- Differentiating microservices from SoA
- Understanding SoA
- What is a microservice?
- Understanding Microservices
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewers
- About the author
- Contributors
- PacktPub.com
- Why subscribe?
- Packt Upsell
- Dedication
- Title Page
- coverpage
- coverpage
- Title Page
- Dedication
- Packt Upsell
- Why subscribe?
- PacktPub.com
- Contributors
- About the author
- About the reviewers
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- To get the most out of this book
- Download the example code files
- Download the color images
- Conventions used
- Get in touch
- Reviews
- Understanding Microservices
- What is a microservice?
- Understanding SoA
- Differentiating microservices from SoA
- From the monolith to microservices
- Microservices principles
- Defining design principles
- Modelled around business capabilities
- Loosely couple
- Single responsibility
- Hiding implementation
- Isolation
- Independently deployable
- Build for failure
- Upstream
- Downstream
- Logging
- Monitoring
- Alerting
- Recovery
- Fallbacks
- Scalability
- Automation
- Domain-Driven Design
- What is Domain-Driven Design
- Ubiquitous language
- Bounded context
- Context mapping
- Using DDD in microservices
- Reactive microservices
- Reactive programming
- Reactive Manifesto
- Responsive
- Resilient
- Elastic
- Message-driven
- Back pressure
- Reactive frameworks
- Reactive Extensions
- Project Reactor
- Java reactive streams
- Akka
- Reactive microservices
- Cloud Native microservices
- Cloud computing
- Containers
- Deployment models
- Private cloud
- Public cloud
- Hybrid cloud
- Service models
- Infrastructure as a Service
- Platform as a Service
- Software as a Service
- Cloud Native microservices
- Summary
- Getting Started with Spring Boot 2.0
- Creating a Spring Boot application
- Setting up
- Installing JDK 8
- UNIX/Mac OS X
- Windows
- Testing the installation
- Installing Maven 3.5
- Unix /MacOS X
- Windows
- Testing the installation
- Installing IntelliJ IDEA CE 2017.2
- Using Spring Initializr
- Understanding basic usage
- Reviewing the generated project files
- Maven Files
- Source files
- Resource files
- Gitignore
- Understanding advanced usage
- Using Maven
- Life cycle phases
- Introduction to Maven goals
- Understanding the POM file
- Project definition
- Maven parent
- Project properties
- Dependencies
- Build
- Repositories
- Using IntelliJ IDEA
- Opening our Maven project
- Executing life cycle phases and goals
- Modifying our microservice
- Debugging
- Tips and Tricks
- Spring Boot application structure
- Creating an application object
- Defining Spring application context
- Understanding the component scan
- Using components
- Autowiring
- Packaging and running a Spring Boot application
- Packaging
- Making JARs not WARs
- Running Spring Boot applications
- Creating executable JARs
- Configuring our application
- Setting configuration values
- Using properties
- Using Yaml
- Using command-line arguments
- Understanding Spring Expression Language
- Using profiles
- Defining profile values
- Executing with profiles
- Creating conditional beans
- Creating beans explicitly
- Defining an additional bean
- Defining beans with conditionals
- Running different configurations
- Summary
- Creating RESTful Services
- Understanding RestController
- What is a controller
- Creating a RestController
- Understanding our controller
- Path and request parameters
- Creating a map of customers
- Getting path variables
- Understanding path variables
- Defining request parameters
- Understanding request parameters
- HTTP verbs and statuses
- Standard HTTP verbs and statuses
- Single resources
- Collections
- Generic errors
- Handling HTTP verbs
- Handling HTTP POST
- Handling HTTP DELETE
- Handling HTTP PUT
- Using verb and mapping annotations
- Implementing a service layer
- Creating a service interface
- Creating an implementation
- Binding the right bean
- Using the service
- Handling HTTP statuses
- Using ResponseEntity
- Answering a GET request
- Answering a POST request
- Answering a DELETE request
- Answering an UPDATE request
- Empty responses
- Working with JSON
- Understanding serialization
- Using simple objects
- Working with complex objects
- Adding telephones to our customers
- Handling null values
- Understanding deserialization
- From a request into an object
- Deserializing complex objects
- Validating objects
- Handling errors
- Using controller advice
- Creating business exceptions
- Avoiding the controller advice
- Summary
- Creating Reactive Microservices
- Understanding Spring WebFlux
- Creating a Spring WebFlux application
- Using Netty
- Serving static context
- Adding a RestController
- Creating a customer service
- Blocking is not reactive
- Creating reactive services
- Understanding subscribers and publishers
- Publishing a single object
- Using Mono in a service
- Publishing multiple objects
- Using Flux in a service
- Receiving objects reactively
- Using functional web programming
- Using RouterFunction
- Creating handlers
- Using reactive services
- Handling multiple routes
- Using query parameters
- Processing a JSON body
- Handling reactive errors
- Capturing errors on Handlers
- Publishing errors
- Summary
- Reactive Spring Data
- NoSQL databases
- What is a SQL database?
- What is a NoSQL database?
- Installing MongoDB
- Starting our database server
- Connecting with the Mongo client
- Creating a database
- Using commands
- Using Spring Data
- Setting up the project
- Configuring our connection
- Sending commands to MongoDB
- Reactive repositories
- Creating a repository
- Using the repository
- Completing our initialization
- Using ReactiveMongoTemplate
- From CRUD to REST
- Bringing back our service
- Mapping GET to READ
- Mapping POST to CREATE
- Mapping DELETE
- Finding Customers
- Summary
- Creating Cloud-Native Microservices
- Understanding Spring Cloud
- What is a Cloud-Native application?
- Spring Cloud architecture
- Configuration server
- Service discovery
- Load Balancer
- Gateway
- Circuit breaker
- Spring Cloud Netflix
- Creating a Spring Cloud microservice
- Configuration Server
- Creating a Configuration Server
- Getting configurations
- Ciphering data
- Using application profiles
- Service discovery
- Creating a Service Discovery Server
- Connecting to the Discovery Server
- Using Spring Boot actuator
- Gateway
- Creating a Gateway
- Defining routes
- Summary
- Creating Dockers
- Starting with Docker
- Understanding containers
- Virtual machines
- Containers
- Docker
- Installing Docker
- Starting with Docker
- Pulling images
- Managing images
- Building Dockers with microservices
- Creating an example microservice
- Creating a Dockerfile
- Dockerize our microservice
- Running the microservice
- Publishing Dockers
- Understanding repositories
- Creating an account on Docker Hub
- Publishing a Docker
- Integrating Docker with Maven
- Summary
- Scaling Microservices
- A scalable architecture
- Scaling directions
- Vertical scaling
- Horizontal scaling
- Design for scaling
- Independently scaling
- Scaling down
- Creating a Cloud
- Creating a swarm
- Adding a service
- Getting logs from a service
- Deleting a service
- Publishing a microservice as a service
- Creating a registry
- Creating a microservice
- Creating our Docker
- Creating the service
- Controlling services
- Scaling instances
- Getting logs from a service
- Controlling the service
- Summary
- Testing Spring Microservices
- Understanding SpringBootTest
- Creating a simple microservice
- Understanding SpringBootTest
- Testing beans
- Using MockMvc
- Mocking beans
- Why we mock
- Setting up a mock
- Returning mocked values
- Verifying Mock invocation
- Fluent tests
- Adding Kluent
- Testing our services expressively
- Testing our controller expressively
- Summary
- Monitoring Microservices
- Understanding monitoring
- What is monitoring?
- Alerting
- Recovering
- Building a failing microservice
- SpringBoot Actuator
- Enabling SpringBoot Actuator
- Understanding Actuator's endpoints
- Health endpoint
- Metrics endpoint
- Trace endpoint
- Defining health indicators
- Protecting Actuator endpoints
- Java Managing Extensions
- Understanding JMX
- Using JMX
- Create management beans
- Summary
- Deploying Microservices
- Setting things up
- Creating a GitHub account
- Installing Git
- Create an OpenShift account
- Downloading the OpenShift client
- Building our application
- Creating an example microservice
- Adding tests
- Uploading to GitHub
- Publishing to OpenShift
- Creating an application
- Managing our application
- Updating the application
- Summary
- Best Practices
- Using Kotlin idioms
- Inferred types
- Expressions
- Default parameters
- Lambda
- Managing the Spring context
- Constructor injection
- Explicit context configuration
- Decouple services
- Layering the application
- Understanding our classes
- Domains
- Splitting
- Testing effectively
- Understanding type of tests
- Unit tests
- Integration tests
- E2E tests
- Other tests
- Testing pyramid
- Test Driven Development
- Behavior-Driven Development
- Handling CI and CD
- Continuous Integration
- Continuous Delivery
- Pipeline
- Dashboard
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:11:44
