舉報 
會員
Hands-On Design Patterns with Java
Dr. Edward Lavieri 著
更新時間：2021-06-24 14:59:06
開會員，本書免費讀 >
Javadesignpatternsarereusableandprovensolutionstosoftwaredesignproblems.Thisbookcoversover60battle-testeddesignpatternsusedbydeveloperstocreatefunctional,reusable,andflexiblesoftware.Hands-OnDesignPatternswithJavastartswithanintroductiontotheUnifiedModelingLanguage(UML),anddelvesintoclassandobjectdiagramswiththehelpofdetailedexamples.You'llstudyconceptsandapproachestoobject-orientedprogramming(OOP)andOOPdesignpatternstobuildrobustapplications.Asyouadvance,you'llexplorethecategoriesofGOFdesignpatterns,suchasbehavioral,creational,andstructural,thathelpyouimprovecodereadabilityandenablelarge-scalereuseofsoftware.You’llalsodiscoverhowtoworkeffectivelywithmicroservicesandserverlessarchitecturesbyusingclouddesignpatterns,eachofwhichisthoroughlyexplainedandaccompaniedbyreal-worldprogrammingsolutions.Bytheendofthebook,you’llbeabletospeedupyoursoftwaredevelopmentprocessusingtherightdesignpatterns,andyou’llbecomfortableworkingonscalableandmaintainableprojectsofanysize.
最新章節
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Chapter 9
- Chapter 8
- Chapter 7
- Chapter 6
品牌：中圖公司
上架時間：2021-06-24 12:22:02
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-06-24 14:59:06
- Other Books You May Enjoy
- Chapter 9
- Chapter 8
- Chapter 7
- Chapter 6
- Chapter 5
- Chapter 4
- Chapter 3
- Chapter 2
- Chapter 1
- Assessments
- Further reading
- Questions
- Summary
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the stateless design pattern
- Understanding the self-containment design pattern
- Understanding the publisher-subscriber design pattern
- Understanding the monitoring design pattern
- Programming the design pattern
- Understanding the idempotency design pattern
- Understanding the fan-out and quickest-reply design pattern
- Controlled failure
- Failure isolation
- Understanding the failure-handling design pattern
- Introducing a fail event
- Programming the design pattern
- Understanding the fail-fast design pattern
- Understanding the event-driven communication design pattern
- Use case
- Understanding the circuit-breaker design pattern
- Implementing the caching design pattern in Java
- Understanding the caching design pattern
- Understanding the bulkhead design pattern
- Understanding the bounded queue design pattern
- Implementing autoscaling
- Vertical scaling
- Horizontal scaling
- Understanding the autoscaling design pattern
- Implementing the asynchronous communication design pattern
- Understanding the asynchronous communication design pattern
- Message-driven
- Elastic
- Resilient
- Responsive
- Introducing reactive design patterns
- Technical requirements
- Reactive Design Patterns
- Further reading
- Questions
- Summary
- Programming the tail call design pattern
- Understanding the tail call design pattern
- Programming the streams design pattern
- Stream terminal operations
- Stream intermediate operations
- Understanding the streams design pattern
- Understanding the memoization design pattern
- Input-Map-Combiner-Reduce-Output
- Multiple maps
- Input
- Input-Multiple Maps-Reduce-Output
- Output
- Reduce
- Map
- Input
- Input-Map-Reduce-Output
- Output
- Map
- Input
- Input-Map-Output
- Understanding the MapReduce design pattern
- Implementing file processing
- Understanding the loan design pattern
- Implementing lambda with multiple parameters
- Implementing lambda with a single parameter
- Accessing variables
- Understanding the lambda design pattern
- Demonstrated implementation
- Understanding the execute around design pattern
- Introducing functional design patterns
- Technical requirements
- Functional Design Patterns
- Further reading
- Questions
- Summary
- Understanding the space-based pattern
- Understanding the service-oriented pattern
- FaaS implementation
- MBaaS implementation
- BaaS implementation
- SaaS implementation
- PaaS implementation
- IaaS implementation
- Understanding the serverless pattern
- Complex transformation example implementation
- Simple transformation example implementation
- Understanding the pipe-filter pattern
- Networking example implementation
- File sharing example implementation
- Understanding the peer-to-peer pattern
- Understanding the naked object pattern
- The MVCArchitecturalPattern class
- The BookController class
- BookView class
- Book class
- Book model-view-controller example implementation
- Understanding the model-view-controller pattern
- eCommerce example implementation
- Logistics example
- Understanding the microservices pattern
- Technical requirements
- Architectural Patterns - Part II
- Further reading
- Questions
- Summary
- Optical disc player example
- Construction quote example
- Understanding the microkernel pattern
- Cloud storage example
- Single client example
- Understanding the master–slave pattern
- Business application layers example
- Mobile operating system layers example
- Traditional operating system layers example
- Understanding the layered pattern
- Load
- Transform
- Extract
- Understanding the extract-transform-load pattern
- Event-driven architectural pattern – mediator
- Event-driven architectural pattern – broker
- Understanding the event-driven pattern
- Three-tier example
- Coffee shop example
- Understanding the client-server pattern
- Luxury cruise reservation system example
- University enterprise information system example
- Understanding the broker pattern
- Warehouse security bot example
- Coffee shop automation example
- Understanding the blackboard pattern
- Introducing architectural patterns
- Architectural Patterns - Part I
- Section 3: New Design Patterns
- Further reading
- Questions
- Summary
- Programming the design pattern
- UML class diagram
- Use case
- Implementing the proxy design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Soaring with the flyweight design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Implementing the facade design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the decorator design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Combining objects with the composite design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Implementing the abstraction example
- Learning about abstraction
- Crossing the bridge design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the adapter design pattern
- Introduction to structural design patterns
- Technical requirements
- Structural Design Patterns
- Further reading
- Questions
- Summary
- Programming the design pattern
- UML class diagram
- Use case
- Implementing the singleton design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Examining the simple factory design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Using the prototype design pattern
- Programming the design pattern
- UML class diagram
- Use case
- Exploring the factory method design pattern
- Driver class
- Director class
- Builder classes
- Interface
- Roaster class
- Programming the design pattern
- UML class diagram
- Use case
- Building with the builder design pattern
- Driver class
- Type-C classes
- TypeB classes
- TypeA classes
- Abstract Factory class
- Interfaces
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the abstract factory design pattern
- Introducing creational design patterns
- Technical requirements
- Creational Design Patterns
- Further reading
- Questions
- Summary
- Understanding the visitor pattern
- Understanding the template method pattern
- UML class diagram
- Strategizing with the strategy pattern
- Application output
- Driver
- PrinterController
- Printer
- PrinterOffLine
- PrinterOnLine
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the state pattern
- Programming the design pattern
- UML class diagram
- Use case
- Observing the observer pattern
- Programming the design pattern
- UML class diagram
- Use case
- Using the null object pattern
- Programming the design pattern
- UML class diagram
- Use case
- Examining the memento pattern
- WidgetProductionSystem
- EmergencyBreak
- The SystemAccelerator class
- Hopper
- AssemblySystem
- Starter
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the mediator pattern
- Programming the design pattern
- UML class diagram
- Use case
- Using the iterator pattern
- InterpreterDriver class
- The Conversion class
- The MapIntToCharacters class
- The Expression interface
- Programming the design pattern
- UML class diagram
- Use case
- Using the interpreter pattern
- Slider-related methods
- Power-related methods
- Accessor methods
- Constructor
- Class variables
- Programming the design pattern
- UML class diagram
- Use case
- Exploring the command pattern
- Admin email handler
- HR email handler
- Finance email handler
- Advising email handler
- Alumni email handler
- Academic email handler
- Main email handler
- University email handler interface
- Programming the design pattern
- UML class diagram
- Use case
- Understanding the chain of responsibility pattern
- Introducing behavioral design patterns
- Technical requirements
- Behavioral Design Patterns
- Section 2: Original Design Patterns
- Further reading
- Questions
- Summary
- Learning the complete OOP class
- Being purposeful with inheritance
- Encapsulating to protect
- Creating concise objects
- Principles of design patterns
- Method call chaining
- Overloading constructors and methods
- Constructors
- Driver class
- Accessors and mutators
- Object-oriented programming approaches
- The this reference
- Instance variables
- Sample OOP class
- Polymorphism
- Encapsulation
- Inheritance
- Portability
- Primary benefits of OOP
- Introduction to object-oriented programming
- Technical requirements
- Object-Oriented Design Patterns
- Further reading
- Questions
- Summary
- Package diagrams
- Object diagrams
- Deployment diagrams
- Composite structure diagrams
- Component diagrams
- Class diagrams
- Understanding structural UML diagrams
- Use case diagrams
- State machine diagrams
- Timing diagrams
- Communication diagrams
- Sequence diagrams
- Interaction diagrams
- Activity diagrams
- Understanding behavioral UML diagrams
- Introducing UML
- Technical requirements
- Unified Modeling Language Primer
- Section 1: Introducing Design Patterns
- 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 reviewer
- About the author
- Contributors
- Packt.com
- Why subscribe?
- About Packt
- Dedication
- Hands-On Design Patterns with Java
- Copyright and Credits
- Title Page
- coverpage
- coverpage
- Title Page
- Copyright and Credits
- Hands-On Design Patterns with Java
- Dedication
- About Packt
- Why subscribe?
- Packt.com
- Contributors
- About the author
- About the reviewer
- 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
- Section 1: Introducing Design Patterns
- Unified Modeling Language Primer
- Technical requirements
- Introducing UML
- Understanding behavioral UML diagrams
- Activity diagrams
- Interaction diagrams
- Sequence diagrams
- Communication diagrams
- Timing diagrams
- State machine diagrams
- Use case diagrams
- Understanding structural UML diagrams
- Class diagrams
- Component diagrams
- Composite structure diagrams
- Deployment diagrams
- Object diagrams
- Package diagrams
- Summary
- Questions
- Further reading
- Object-Oriented Design Patterns
- Technical requirements
- Introduction to object-oriented programming
- Primary benefits of OOP
- Portability
- Inheritance
- Encapsulation
- Polymorphism
- Sample OOP class
- Instance variables
- The this reference
- Object-oriented programming approaches
- Accessors and mutators
- Driver class
- Constructors
- Overloading constructors and methods
- Method call chaining
- Principles of design patterns
- Creating concise objects
- Encapsulating to protect
- Being purposeful with inheritance
- Learning the complete OOP class
- Summary
- Questions
- Further reading
- Section 2: Original Design Patterns
- Behavioral Design Patterns
- Technical requirements
- Introducing behavioral design patterns
- Understanding the chain of responsibility pattern
- Use case
- UML class diagram
- Programming the design pattern
- University email handler interface
- Main email handler
- Academic email handler
- Alumni email handler
- Advising email handler
- Finance email handler
- HR email handler
- Admin email handler
- Exploring the command pattern
- Use case
- UML class diagram
- Programming the design pattern
- Class variables
- Constructor
- Accessor methods
- Power-related methods
- Slider-related methods
- Using the interpreter pattern
- Use case
- UML class diagram
- Programming the design pattern
- The Expression interface
- The MapIntToCharacters class
- The Conversion class
- InterpreterDriver class
- Using the iterator pattern
- Use case
- UML class diagram
- Programming the design pattern
- Understanding the mediator pattern
- Use case
- UML class diagram
- Programming the design pattern
- Starter
- AssemblySystem
- Hopper
- The SystemAccelerator class
- EmergencyBreak
- WidgetProductionSystem
- Examining the memento pattern
- Use case
- UML class diagram
- Programming the design pattern
- Using the null object pattern
- Use case
- UML class diagram
- Programming the design pattern
- Observing the observer pattern
- Use case
- UML class diagram
- Programming the design pattern
- Understanding the state pattern
- Use case
- UML class diagram
- Programming the design pattern
- PrinterOnLine
- PrinterOffLine
- Printer
- PrinterController
- Driver
- Application output
- Strategizing with the strategy pattern
- UML class diagram
- Understanding the template method pattern
- Understanding the visitor pattern
- Summary
- Questions
- Further reading
- Creational Design Patterns
- Technical requirements
- Introducing creational design patterns
- Understanding the abstract factory design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Interfaces
- Abstract Factory class
- TypeA classes
- TypeB classes
- Type-C classes
- Driver class
- Building with the builder design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Roaster class
- Interface
- Builder classes
- Director class
- Driver class
- Exploring the factory method design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Using the prototype design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Examining the simple factory design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Implementing the singleton design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Summary
- Questions
- Further reading
- Structural Design Patterns
- Technical requirements
- Introduction to structural design patterns
- Understanding the adapter design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Crossing the bridge design pattern
- Learning about abstraction
- Implementing the abstraction example
- Use case
- UML class diagram
- Programming the design pattern
- Combining objects with the composite design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Understanding the decorator design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Implementing the facade design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Soaring with the flyweight design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Implementing the proxy design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Summary
- Questions
- Further reading
- Section 3: New Design Patterns
- Architectural Patterns - Part I
- Introducing architectural patterns
- Understanding the blackboard pattern
- Coffee shop automation example
- Warehouse security bot example
- Understanding the broker pattern
- University enterprise information system example
- Luxury cruise reservation system example
- Understanding the client-server pattern
- Coffee shop example
- Three-tier example
- Understanding the event-driven pattern
- Event-driven architectural pattern – broker
- Event-driven architectural pattern – mediator
- Understanding the extract-transform-load pattern
- Extract
- Transform
- Load
- Understanding the layered pattern
- Traditional operating system layers example
- Mobile operating system layers example
- Business application layers example
- Understanding the master–slave pattern
- Single client example
- Cloud storage example
- Understanding the microkernel pattern
- Construction quote example
- Optical disc player example
- Summary
- Questions
- Further reading
- Architectural Patterns - Part II
- Technical requirements
- Understanding the microservices pattern
- Logistics example
- eCommerce example implementation
- Understanding the model-view-controller pattern
- Book model-view-controller example implementation
- Book class
- BookView class
- The BookController class
- The MVCArchitecturalPattern class
- Understanding the naked object pattern
- Understanding the peer-to-peer pattern
- File sharing example implementation
- Networking example implementation
- Understanding the pipe-filter pattern
- Simple transformation example implementation
- Complex transformation example implementation
- Understanding the serverless pattern
- IaaS implementation
- PaaS implementation
- SaaS implementation
- BaaS implementation
- MBaaS implementation
- FaaS implementation
- Understanding the service-oriented pattern
- Understanding the space-based pattern
- Summary
- Questions
- Further reading
- Functional Design Patterns
- Technical requirements
- Introducing functional design patterns
- Understanding the execute around design pattern
- Demonstrated implementation
- Understanding the lambda design pattern
- Accessing variables
- Implementing lambda with a single parameter
- Implementing lambda with multiple parameters
- Understanding the loan design pattern
- Implementing file processing
- Understanding the MapReduce design pattern
- Input-Map-Output
- Input
- Map
- Output
- Input-Map-Reduce-Output
- Input
- Map
- Reduce
- Output
- Input-Multiple Maps-Reduce-Output
- Input
- Multiple maps
- Input-Map-Combiner-Reduce-Output
- Understanding the memoization design pattern
- Understanding the streams design pattern
- Stream intermediate operations
- Stream terminal operations
- Programming the streams design pattern
- Understanding the tail call design pattern
- Programming the tail call design pattern
- Summary
- Questions
- Further reading
- Reactive Design Patterns
- Technical requirements
- Introducing reactive design patterns
- Responsive
- Resilient
- Elastic
- Message-driven
- Understanding the asynchronous communication design pattern
- Implementing the asynchronous communication design pattern
- Understanding the autoscaling design pattern
- Horizontal scaling
- Vertical scaling
- Implementing autoscaling
- Understanding the bounded queue design pattern
- Understanding the bulkhead design pattern
- Understanding the caching design pattern
- Implementing the caching design pattern in Java
- Understanding the circuit-breaker design pattern
- Use case
- Understanding the event-driven communication design pattern
- Understanding the fail-fast design pattern
- Programming the design pattern
- Introducing a fail event
- Understanding the failure-handling design pattern
- Failure isolation
- Controlled failure
- Understanding the fan-out and quickest-reply design pattern
- Understanding the idempotency design pattern
- Programming the design pattern
- Understanding the monitoring design pattern
- Understanding the publisher-subscriber design pattern
- Understanding the self-containment design pattern
- Understanding the stateless design pattern
- Use case
- UML class diagram
- Programming the design pattern
- Summary
- Questions
- Further reading
- Assessments
- Chapter 1
- Chapter 2
- Chapter 3
- Chapter 4
- Chapter 5
- Chapter 6
- Chapter 7
- Chapter 8
- Chapter 9
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-06-24 14:59:06
