Annotation. Create various design patterns to master the art of solving problems using Java Key Features This book demonstrates the shift from OOP to functional programming and covers reactive and functional patterns in a clear and step-by-step manner All the design patterns come with a practical use case as part of the explanation, which will improve your productivity Tackle all kinds of performance-related issues and streamline your developmentBook DescriptionHaving a knowledge of design patterns enables you, as a developer, to improve your code base, promote code reuse, and make the architecture more robust. As languages evolve, new features take time to fully understand before they are adopted en masse. The mission of this book is to ease the adoption of the latest trends and provide good practices for programmers.We focus on showing you the practical aspects of smarter coding in Java. We'll start off by going over object-oriented (OOP) and functional programming (FP) paradigms, moving on to describe the most frequently used design patterns in their classical format and explain how Java's functional programming features are changing them.You will learn to enhance implementations by mixing OOP and FP, and finally get to know about the reactive programming model, where FP and OOP are used in conjunction with a view to writing better code. Gradually, the book will show you the latest trends in architecture, moving from MVC to microservices and serverless architecture. We will finish off by highlighting the new Java features and best practices. By the end of the book, you will be able to efficiently address common problems faced while developing applications and be comfortable working on scalable and maintainable projects of any size.What you will learn Understand the OOP and FP paradigms Explore the traditional Java design patterns Get to know the new functional features of Java See how design patterns are changed and affected by the new features Discover what reactive programming is and why is it the natural augmentation of FP Work with reactive design patterns and find the best ways to solve common problems using them See the latest trends in architecture and the shift from MVC to serverless applications Use best practices when working with the new featuresWho this book is forThis book is for those who are familiar with Java development and want to be in the driver's seat when it comes to modern development techniques. Basic OOP Java programming experience and elementary familiarity with Java is expected.

• Title Page
• Copyright and Credits
• Packt Upsell
• Contributors
• Table of Contents
• Preface
• Chapter 1: From Object-Oriented to Functional Programming
  • Java – an introduction
  • Java programming paradigms
  • Imperative programming
    • Real-life imperative example
  • Object-oriented paradigm
    • Objects and classes
    • Encapsulation
    • Abstraction
    • Inheritance
    • Polymorphism
  • Declarative programming
  • Functional programming
    • Working with collections versus working with streams
  • An introduction to Unified Modeling Language
    • Class relations
      • Generalization
      • Realization
      • Dependency
      • Association
        • Aggregation
        • Composition
  • Design patterns and principles
    • Single responsibility principle
    • Open/closed principle
    • Liskov Substitution Principle
    • Interface Segregation Principle
    • Dependency inversion principle
  • Summary
• Chapter 2: Creational Patterns
  • Singleton pattern
    • Synchronized singletons
    • Synchronized singleton with double-checked locking mechanism
    • Lock-free thread-safe singleton
    • Early and lazy loading
  • The factory pattern
    • Simple factory pattern
      • Static factory
      • Simple factory with class registration using reflection
      • Simple factory with class registration using Product.newInstance
    • Factory method pattern
      • Anonymous concrete factory
    • Abstract factory
    • Simple factory versus factory method versus abstract factory
  • Builder pattern
    • Car builder example
    • Simplified builder pattern
    • Anonymous builders with method chaining
  • Prototype pattern
    • Shallow clone versus deep clone
  • Object pool pattern
  • Summary
• Chapter 3: Behavioral Patterns
  • The chain-of-responsibility pattern
    • Intent
    • Implementation
    • Applicability and examples
  • The command pattern
    • Intent
    • Implementation
    • Applicability and examples
  • The interpreter pattern
    • Intent
    • Implementation
    • Applicability and examples
  • The iterator pattern
    • Intent
    • Implementation
    • Applicability and examples
  • The observer pattern
    • Intent
    • Implementation
  • The mediator pattern
    • Intent
    • Implementation
    • Applicability and examples
  • The memento pattern
    • Intent
    • Implementation
    • Applicability
  • The state pattern
  • The strategy pattern
    • Intent
    • Implementation
  • The template method pattern
    • Intent
    • Implementation
  • The null object pattern
    • Implementation
  • The visitor pattern
    • Intent
    • Implementation
  • Summary
• Chapter 4: Structural Patterns
  • Adapter pattern
    • Intent
    • Implementation
    • Examples
  • Proxy pattern
    • Intent
    • Implementation
    • Examples
  • Decorator pattern
    • Intent
    • Implementation
    • Examples
  • Bridge pattern
    • Intent
    • Implementation
    • Examples
  • Composite pattern
    • Intent
    • Implementation
    • Examples
  • Façade pattern
    • Intent
    • Implementation
    • Examples
  • Flyweight pattern
    • Intent
    • Implementation
    • Examples
  • Summary
• Chapter 5: Functional Patterns
  • Introducing functional programming
    • Lambda expressions
    • Pure functions
    • Referential transparency
    • First-class functions
    • Higher-order functions
    • Composition
    • Currying
    • Closure
    • Immutability
    • Functors
    • Applicatives
    • Monads
  • Introducing functional programming in Java
    • Lambda expressions
    • Streams
    • Stream creator operations
    • Stream intermediate operations
    • Stream terminal operations
  • Re-implementing OOP design patterns
    • Singleton
    • Builder
    • Adapter
    • Decorator
    • Chain of responsibility
    • Command
    • Interpreter
    • Iterator
    • Observer
    • Strategy
    • Template method
  • Functional design patterns
    • MapReduce
      • Intent
      • Examples
    • Loan pattern
      • Intent
      • Examples
    • Tail call optimization
      • Intent
      • Examples
    • Memoization
      • Intent
      • Examples
    • The execute around method
      • Intent
      • Examples
  • Summary
• Chapter 6: Let's Get Reactive
  • What is reactive programming?
  • Introduction to RxJava
  • Installing the RxJava framework
    • Maven installation
    • JShell installation
  • Observables, Flowables, Observers, and Subscriptions
  • Creating Observables
    • The create operator
    • The defer operator
    • The empty operator
    • The from operator
    • The interval operator
    • The timer operator
    • The range operator
    • The repeat operator
  • Transforming Observables
    • The subscribe operator
    • The buffer operator
    • The flatMap operator
    • The groupBy operator
    • The map operator
    • The scan operator
    • The window operator
  • Filtering Observables
    • The debounce operator
    • The distinct operator
    • The elementAt operator
    • The filter operator
    • The first/last operator
    • The sample operator
    • The skip operator
    • The take operator
  • Combining Observables
    • The combine operator
    • The join operator
    • The merge operator
    • The zip operator
  • Error handling
    • The catch operator
    • The do operator
    • The using operator
    • The retry operator
  • Schedulers
  • Subjects
  • Example project
  • Summary
• Chapter 7: Reactive Design Patterns
  • Patterns for responsiveness
    • Request-response pattern
    • Asynchronous-communication pattern
    • Caching pattern
    • Fan-out and quickest-reply pattern
    • Fail-fast pattern
  • Patterns for resilience
    • The circuit-breaker pattern
    • Failure-handling pattern
    • Bounded-queue pattern
    • Monitoring patterns
    • Bulkhead pattern
  • Patterns for elasticity
    • Single responsibility pattern
    • Stateless-services pattern
    • Autoscaling pattern
    • Self-containment pattern
  • Patterns for message-driven implementation
    • Event-driven communication pattern
    • Publisher-subscriber pattern
    • Idempotency pattern
  • Summary
• Chapter 8: Trends in Application Architecture
  • What is application architecture?
  • Layered architecture
    • Layered architecture with an example
    • Tiers versus layers
    • What does layered architecture guarantee?
    • What are the challenges with layered architecture?
  • Model View Controller architecture
    • MVC architecture with an example
    • A more contemporary MVC implementation
    • What does MVC architecture guarantee?
    • What are the challenges with MVC architecture?
  • Service-oriented architecture
    • Service-oriented architecture with an example
    • Web services
      • SOAP versus REST
    • Enterprise service bus
    • What does service-oriented architecture guarantee?
    • What are the challenges with service-oriented architecture?
  • Microservices-based Architecture
    • Microservice architecture with an example
    • Communicating among services
    • What does microservices-based architecture guarantee?
    • What are challenges with microservices-based architecture?
  • Serverless architecture
    • Serverless architecture with an example
    • Independence from infrastructure planning
    • What does serverless architecture guarantee?
    • What are the challenges with serverless architecture?
  • Summary
• Chapter 9: Best Practices in Java
  • A brief history of Java
    • Features of Java 5
    • Features of Java 8
    • Currently supported versions of Java
  • Best practices and new features of Java 9
    • Java platform module system
    • JShell
    • Private methods in interfaces
    • Enhancements in streams
    • Creating immutable collections
    • Method addition in arrays
    • Additions to the Optional class
    • New HTTP client
    • Some more additions to Java 9
  • Best practices and new features of Java 10
    • Local variable type inference
    • copyOf method for collections
    • Parallelization of full garbage collection
    • Some more additions to Java 10
  • What should be expected in Java 11?
  • Summary
• Other Books You May Enjoy
• Index