Index
A
- @AspectJ annotation-based Spring AOP
- about / @AspectJ annotation-based Spring AOP
- aspect, declaring / Declaring aspect
- point-cut, declaring / Declaring point-cut
- Advice, declaring / Declaring Advice
- advisor, declaring / Declaring an advisor
- Advice (interceptor)
- before advice, declaring / Implementing before advice
- after advice, implementing / Implementing after advice
- around advice, implementing / Implementing around advice
- after returning advice, implementing / Implementing after returning advice
- AfterThrowing advice, implementing / Implementing AfterThrowing advice
- annotation / Runtime phase
- annotation-based DI
- about / Annotation-based DI
- through XML configuration / DI through XML configuration
- defining / Defining annotation
- configuration, activating / Activating annotation-based configuration
- factory method, using / Annotation with the factory method
- annotations, Google Guice framework
- Inject / Inject
- ProvidedBy / ProvidedBy
- ImplementedBy / ImplementedBy
- @Named / @Named
- AOP frameworks
- Apache Tomcat server / Session scope
- aspect-oriented programming (AOP)
- about / AOP introduction
- concern / AOP introduction
- aspect / AOP introduction
- join-point / AOP introduction
- advice / AOP introduction
- point-cut / AOP introduction
- target object / AOP introduction
- AOP-Proxy / AOP introduction
- weaving / AOP introduction
- compile-time weaving / AOP introduction
- post-compile-time (or binary) weaving / AOP introduction
- runtime weaving / AOP introduction
- auto-wiring
- in Spring / Auto-wiring in Spring
- by name / Auto-wiring by name
- by type / Auto-wiring by type
- by constructor / Auto-wiring by constructor
- autoproxying / @AspectJ annotation-based Spring AOP
B
- bean
- class / Bean definition
- name / Bean definition
- constructor-arg / Bean definition
- properties / Bean definition
- autowiring mode / Bean definition
- lazy initialization mode / Bean definition
- initialization method / Bean definition
- destruction method / Bean definition
- about / Declaring point-cut
- bean management, Spring container
- about / Bean management in Spring container
- Spring IoC container / Spring IoC container
- configuration / Configuration
- containers, using / Containers in action
- bean scopes
- about / Spring scopes
- singleton scope / Singleton scope
- prototype scope / Prototype scope
- request scope / Request scope
- session scope / Session scope
- application scope / Application scope
- global session scope / Global session scope
- websocket scope / websocket scope
- defining / How to define a bean scope
- XML metadata configuration / XML metadata configuration
- Java configuration, using annotations / Java configuration using annotations
- Dependency Injection (DI) / Dependency injection and the bean scope
- and Dependency Injection (DI) / Dependency injection and the bean scope
- selecting / How to choose a bean scope
- bindings, Google Guice framework
- linked bindings / Linked bindings
- instance bindings / Instance bindings
- untargeted bindings / Untargeted bindings
- constructor bindings / Constructor bindings
- built-in bindings / Built-in bindings
- Just-in-time (JIT) binding / Just-in-time Bindings
- annotations / Binding annotations
- built-in bindings
- Loggers / Built-in bindings
C
- circular dependency
- about / Circular dependency
- issues / Problems of circular dependency
- causes and solutions / Causes and solutions
- single responsibility principle, using / The single responsibility principle
- dependency setting, differences / Deferring the setting of a dependency from constructor to setter
- classes and packages, reloacation / Relocation of classes and packages
- in Spring framework / Circular dependency in the Spring framework
- command line interface
- used, for writing modular code / Writing modular code using a command-line interface
- configuration styles
- about / Configuration styles
- file-based (XML), versus code-based / File-based (XML) versus code-based configuration
- constructor-based DI / Constructor-based DI
- constructor bindings / Constructor bindings
- constructor injection / Constructor Injection
- Context Dependency Injection (CDI) / IoC containers
D
- Dependency Injection (DI)
- about / Dependency injection
- types / Dependency injection types
- constructor injection / Constructor injection, Constructor Injection
- setter injection / Setter injection
- interface injection / Interface injection
- Modular Framework, using / Dependency Injection using the Java 9 Modular Framework
- using, with Java configuration / DI with Java configuration
- example / Example of simple DI
- and bean scope / Dependency injection and the bean scope
- setter-based DI / Setter-based DI
- Dependency Injection (DI), Google Guice
- method injection / Method injection
- field injection / Field injection
- optional injection / Optional injection
- static injection / Static injection
- Dependency Injection (DI), Spring
- about / Dependency Injection (DI) in Spring
- constructor-based DI / Constructor-based DI
- setter-based DI / Setter-based DI
- factory method, using / Spring DI with the factory method
- and bean scope / Dependency injection and the bean scope
- Dependency Injection Principle (DIP)
- implementing, through IoC / Implementing DIP through IoC
- Dependency Inversion Principle (DIP) / Dependency Inversion Principle, Various patterns to achieve IoC
- design patterns
- about / Design patterns
- advantages / Design patterns
- design principle / Design patterns
- DIP implementation, through IoC
- interface, inverting / Inverting the interface
- object creation, inverting / Inverting object creation
- object creation, inverting ways / Different ways to invert object creation
- object creation, inversion through factory pattern / Inversion of object creation through the factory pattern
- object creation, inversion through service locator / Inversion of object creation through service locator
E
- excessive injection / Excessive injection
- Expression Language (EL) / Core container layer
F
- factory method
- static factory method / Static factory method
- instance (non-static) factory method / Instance (non-static) factory method
- factory method pattern
- product (abstract type), defining / Defining the product (abstract type) and its concrete implementation
- concrete implementation / Defining the product (abstract type) and its concrete implementation, Defining the factory method (creator interface) and its concrete implementation
- creator interface / Defining the factory method (creator interface) and its concrete implementation
- features, Java 9
- about / Key features, Java Platform Module System
- JShell (REPL) – The Java Shell / JShell (REPL) – The Java Shell
- jLink - Module Linker / JLink – Module Linker
- Multi-Release JAR files / Multi-release JAR files
- Stream API enhancements / Stream API enhancements
- Stack-Walking API / Stack-walking API
- immutable collections, with convenient factory methods / Immutable collections with convenient factory methods
- HTTP/2.0 support / HTTP/2.0 support
- field injection / Field injection
G
- global session scope / Global session scope
- Google Guice framework
- about / A brief introduction to the Google Guice framework
- setup / Guice setup
- dependency injection / Dependency injection and JSR-330
- JSR-330 / Dependency injection and JSR-330
- basic injection / Basic injection in Guice
- API and phases / Guice API and Phases
- annotations / Guice annotations
- binding / Binding in Guice
- injection / Guice injection
- scopes / Scopes in Google Guice
I
- instance bindings / Instance bindings
- interface injection / Interface injection
- Inversion of Control (IoC)
- about / Inversion of Control
- DIP, implementing / Implementing DIP through IoC
- achieving, ways / Implementing DIP through IoC
- containers / IoC containers
- various patterns, for achieving / Various patterns to achieve IoC
- achieving, without container / Achieving IoC in the absence of a container
- IoC container
- anti-patterns / Best practices and anti-patterns
- injection issue / What to inject – the container itself or just dependencies?
J
- Java 9
- about / Java 9 introduction
- features / Key features
- Modular Framework / Modular Framework in Java 9
- Java Development Kit (JDK) / Java 9 introduction
- Java Enterprise Edition (Java EE) / Java 9 introduction
- Java Micro Edition platforms (Java ME) / Java 9 introduction
- Java Platform Module System (JPMS)
- Java Specification Request (JSR) 330 / A brief introduction to the Google Guice framework
- Java Standard Edition (Java SE) / Java 9 introduction
- Just-in-time (JIT) binding
- default constructors / Just-in-time Bindings
- constructors with @Inject / Just-in-time Bindings
L
- @Lazy annotation
- using / Using the @Lazy annotation
- linked bindings / Linked bindings
- Logger / Built-in bindings
M
- method injection / Method injection
- modular code
- writing, command line interface used / Writing modular code using a command-line interface
- Modular Framework
- about / Modular Framework in Java 9
- modularity / What is modularity?
- Java Platform Module System (JPMS) / Java Platform Module System
- JDK / Modular JDK
- module / What is a module?
- used, for Dependency Injection / Dependency Injection using the Java 9 Modular Framework
- modules, with Service Loader / Modules with Service Loader
- module
- structure / Structure of a module
- Module Descriptor (module-info.java) / Module Descriptor (module-info.java)
- named application modules / Module types
- types / Module types
- platform modules / Module types
- automatic modules / Module types
- unnamed modules / Module types
- dependency, defining / Defining dependency between modules
- executing / Compiling and running modules
- compiling / Compiling and running modules
- module interface / Start up phase
- modules, data access/integration layer
- transaction / Data access/integration layer
- Object XML mapping (OXM) / Data access/integration layer
- Object Relationship Mapping (ORM) / Data access/integration layer
- Java Database Connectivity (JDBC) / Data access/integration layer
- Java Messaging Service (JMS) / Data access/integration layer
- modules, with Service Loader
- Service (API) module / Service (API) module
- Service Provider (Implementation) module / Service provider (Implementation) module
- service client application / Service client application
O
- optional dependency / Setter injection
- optional injection / Optional injection
P
- phases, Google Guice framework
- start-up phase / Start up phase
- run-time phase / Runtime phase
- Plain Old Java Object (POJO) / A brief introduction to Spring framework
- point-cut
- declaring / Declaring a point-cut
- point-cut designator (PCD) / Point-cut designator
- patterns / Patterns
- point-cut designator (PCD) / Point-cut designator
- point-cut signatures / Declaring point-cut
- private point-cuts / Declaring point-cut
- protected point-cuts / Declaring point-cut
- prototype scope
- using, with annotation / Prototype scope with annotation
- provides keyword / Service provider (Implementation) module
- public point-cuts / Declaring point-cut
R
- Read-Eval-Print Loop (REPL) / JShell (REPL) – The Java Shell
S
- scopes, Google Guice
- about / Scopes in Google Guice
- session / Scopes in Google Guice
- request / Scopes in Google Guice
- default scope / Default scope
- singleton scope / Singleton scope
- service locator pattern
- about / The service locator pattern
- differences / The service locator pattern
- limitations / What to inject – the container itself or just dependencies?
- session / Session scope
- setter-based DI / Setter-based DI, Setter-based DI
- setter/field injection
- using, over constructor injection / Using setter/field injection over constructor injection
- setter injection / Setter injection
- singleton scope, Google Guice
- using, with annotation / Singleton scope with annotation
- about / Singleton scope
- eager singletons / Eager singletons
- Spring
- Dependency Injection (DI) / Dependency Injection (DI) in Spring
- auto-wiring / Auto-wiring in Spring
- bean scopes / Introduction to bean scopes in Spring
- scopes / Spring scopes
- Spring AOP
- about / Spring AOP
- XML(schema)-based Spring AOP / XML(schema)-based Spring AOP
- @AspectJ annotation-based Spring AOP / @AspectJ annotation-based Spring AOP
- versus AspectJ language / Spring AOP versus AspectJ language
- XML, versus @AspectJ-style annotation / XML versus @AspectJ-style annotation for Spring AOP
- Spring Application Context file / Spring IoC container
- Spring beans / Core container layer
- Spring context / Core container layer
- Spring core / Core container layer
- Spring Expression Language (SpEL)
- benefits / Core container layer
- Spring framework
- about / A brief introduction to Spring framework
- architecture / Spring framework architecture
- Spring framework architecture
- core container layer / Core container layer
- data access/integration layer / Data access/integration layer
- Spring web layer / Spring web layer
- Spring test / Spring test
- aspect and AOP / Miscellaneous
- instrumentation / Miscellaneous
- messaging / Miscellaneous
- Spring Prototype / Runtime phase
- Spring web layer
- web / Spring web layer
- servlet / Spring web layer
- portlet / Spring web layer
- StackTraceElement / Stack-walking API
- start-up phase, Google Guice framework
- module interface / Module interface
- AbstractModule class / The AbstractModule class
- Binder / Binder
- Injector / Injector
- Guice framework / Guice
- provider / Provider
- static injection / Static injection
- strategy pattern / The strategy pattern
- Streaming Text-Oriented Messaging Protocol (STOMP) / Miscellaneous
- style of configuration
T
- template method pattern / The template method pattern
U
- untargeted bindings / Untargeted bindings
W
- websocket scope / websocket scope
X
- XML
- versus @AspectJ-style annotation / XML versus @AspectJ-style annotation for Spring AOP
- XML(schema)-based Spring AOP
- about / XML(schema)-based Spring AOP
- aspect, declaring / Declaring aspect
- point-cut, declaring / Declaring a point-cut
- Advice (interceptor), declaring / Declaring Advice (interceptor)
- XML metadata configuration, bean scope
- singleton scope, using / Using the singleton scope
- prototype scope, using / Using the prototype scope