Java 9 dependency injection write loosely coupled code with Spring 5 and Guice
Create clean code with Dependency Injection principles About This Book 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 obj...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham ; Mumbai :
Packt Publishing
2018.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631484306719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Packt Upsell
- Contributors
- Table of Contents
- Preface
- Chapter 1: 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
- Chapter 2: 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
- Chapter 3: 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
- Chapter 4: 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
- Chapter 5: 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
- Chapter 6: 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
- Chapter 7: 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
- Other Books You May Enjoy
- Index.
