Java 9 Dependency Injection Write loosely coupled code with Spring 5 and Guice 1st Edition by Nilang Patel, Krunal Patel 9781788296472 1788296478

Java 9 Dependency Injection Write loosely coupled code with Spring 5 and Guice 1st Edition Nilang Patel Krunal Patel – Ebook PDF Instant Download/Delivery ISBN(s): 9781788296472, 1788296478

Product details:

• ISBN 10: 1788296478
• ISBN 13: 9781788296472
• Author: Nilang Patel, Krunal Patel

Use DI to make your code loosely coupled to manage and test your applications easily on Spring 5 and Google Guice
Learn the best practices and methodologies to implement DI
Write more maintainable Java code by decoupling your objects from their implementations

Table contents:

Java 9 Dependency Injection
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the authors
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
Why Dependency Injection?
Design patterns
Dependency Inversion Principle
Inversion of Control
Implementing DIP through IoC
Inverting the interface
Inverting object creation 
Different ways to invert object creation
Inversion of object creation through the factory pattern
Inversion of object creation through service locator
Dependency injection
Dependency injection types
Constructor injection
Setter injection
Interface injection
IoC containers
Summary
Dependency Injection in Java 9
Java 9 introduction
Key features
Java Platform Module System
JShell (REPL) – The Java Shell
JLink – Module Linker
Multi-release JAR files
Stream API enhancements
Stack-walking API
Immutable collections with convenient factory methods
HTTP/2.0 support
Modular Framework in Java 9
What is modularity?
Java Platform Module System
The need for a Java modular system
Modular JDK 
What is a module?
Structure of a module
Module Descriptor (module-info.java)
Module types
Dependency Injection using the Java 9 Modular Framework
Modules with Service Loader
Service (API) module
Service provider (Implementation) module
Service client application
Writing modular code using a command-line interface
Defining dependency between modules
Compiling and running modules
Summary
Dependency Injection with Spring
A brief introduction to Spring framework
Spring framework architecture
Core container layer
Data access/integration layer
Spring web layer
Spring test
Miscellaneous
Bean management in Spring container
Spring IoC container
Configuration
Containers in action
Dependency Injection (DI) in Spring
Constructor-based DI
Setter-based DI
Spring DI with the factory method
Static factory method 
Instance (non-static) factory method
Auto-wiring in Spring
Auto-wiring by name
Auto-wiring by type
Auto-wiring by constructor
Annotation-based DI
DI through XML configuration
Defining annotation
Activating annotation-based configuration
Defining a Java class as <bean> with annotation
Annotation with the factory method
DI with Java configuration
Summary
Dependency Injection with Google Guice
A brief introduction to the Google Guice framework
Guice setup
Dependency injection and JSR-330
Example of simple DI
Basic injection in Guice
Guice API and Phases
Start up phase
Module interface
The AbstractModule class
Binder
Injector
Guice
Provider
Runtime phase
Guice annotations
Inject
ProvidedBy
ImplementedBy
@Named
Binding in Guice
Linked bindings
Instance bindings
Untargeted bindings
Constructor bindings
Built-in bindings
Just-in-time Bindings
Binding annotations
Guice injection
Constructor Injection
Method injection
Field injection
Optional injection
Static injection
Summary
Scopes
Introduction to bean scopes in Spring
Bean definition 
Spring scopes
Singleton scope
Prototype scope
Request scope
Session scope
Application scope
Global session scope
websocket scope
How to define a bean scope
XML metadata configuration
Using the singleton scope
Using the prototype scope
Java configuration using annotations
Singleton scope with annotation
Prototype scope with annotation
Dependency injection and the bean scope
How to choose a bean scope
Scopes in Google Guice
Default scope
Singleton scope
Eager singletons
Summary
Aspect-Oriented Programming and Interceptors
AOP introduction
Spring AOP
XML(schema)-based Spring AOP
Declaring aspect
Declaring a point-cut
Point-cut designator
Patterns
Declaring Advice (interceptor)
Implementing before advice
Implementing after advice
Implementing around advice
Implementing after returning advice
Implementing AfterThrowing advice
@AspectJ annotation-based Spring AOP
Declaring aspect
Declaring point-cut
Declaring Advice
Declaring an advisor
Choosing AOP frameworks and style of configuration
Spring AOP versus AspectJ language
XML versus @AspectJ-style annotation for Spring AOP
Summary
IoC Patterns and Best Practices
Various patterns to achieve IoC
The factory method pattern
Defining the product (abstract type) and its concrete implementation
Defining the factory method (creator interface) and its concrete implementation
The service locator pattern
The template method pattern
The strategy pattern
Configuration styles
File-based (XML) versus code-based configuration
Injection using the setter method versus the constructor
Constructor-based DI
Setter-based DI
Circular dependency
Problems of circular dependency
Causes and solutions
The single responsibility principle
Deferring the setting of a dependency from constructor to setter
Relocation of classes and packages
Circular dependency in the Spring framework
Using setter/field injection over constructor injection
Using the @Lazy annotation
Best practices and anti-patterns
What to inject – the container itself or just dependencies?
Excessive injection
Achieving IoC in the absence of a container
Summary

People also search:

java dependency injection without framework

java dependency injection without spring

java 8 dependency injection

java update dependencies

java injection dependency