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
  • selecting / Choosing AOP frameworks and style of configuration
• 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)
  • about / Key features, Java Platform Module System, Java Platform Module System, The need for a Java modular system
  • need for / The need for a Java modular system
• 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
  • selecting / Choosing AOP frameworks and 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