Design Patterns and Best Practices in Java: A comprehensive guide to building smart and reusable code in Java

Description

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 Description Having 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 for This 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