Spring Core

Front 1

Spring Triangle

Back 1

* Injection & dependency
* AOP
* Enterprise Service Abstractions

Front 2

How Spring Works in High-Level

Back 2

POJOs & Configuration Instruction -> Spring ApplicationContext CREATES Fully configured app sys (Ready for use)

Front 3

One line to get context

Back 3

ApplicationContext context
= new ClassPathXmlApplicationContext("application-config.xml");

Front 4

How is Spring context implemented?

Back 4

* "singletons" by default (one instance per bean)
* generate objects by reflection

Front 5

Reflection

Back 5

Examples
* Class c = "foo".getClass()
* c.getMethods()

Front 6

Dependency Injection

Back 6

* Constructor: constructor-arg
* Setter: nested elements inside bean defn, i.e. <property name="repository" ref="repository"/>

Front 7

Case for constructor DI

Back 7

* enforce mandatory dependencies [can also have required=true flag with setter DI]
* promote immutability (can assign dependencies to final fields)
* concise for programmatic usage - creation and injection in one line of code

Front 8

Case for setters

Back 8

* Allow optional dependencies and defaults
* Have descriptive names
* follow JavaBean conventions
* Inherited automatically

Front 9

Automatic Value Type Conversion

Back 9

* value = "29" --> new Integer("29")
* property editor

Front 10

Singleton example

Back 10

public class LegacySingleton {
(1) public static LegacySingleton inst = new LegacySingleton(); // public static new
(2) private LegalSingleton(){} // private construction
(3) public static LegacySingleton getInstance() { return inst; } // static getInstance() method to retrieve instance

Front 11

FactoryBean

Back 11

implements FactoryBean & implements Object getObject() for beans which are complex to create

Front 12

FactorBeans example

Back 12

* JndiObjectFactoryBean
* FBs for creating remoting proxies
* FBs for configuring data access technologies like Hibernate

Front 13

Where can a Spring app context be used?

Back 13

Spring app contexts can be bootstrapped in any environment, e.g. JUnit, Web app, EJB, standalone app

Front 14

.+ApplicationContext examples

Back 14

ClassPathXmlApplicationContext
FileSystemXmlApplicationContext
XmlWebApplicationContext

Front 15

Resource Loading Prefixes

Back 15

say, XmlWebAppContext
* classpath:
* file:
* http:

Front 16

recommendation for layering of app context files

Back 16

Partitioning Configuration
1. app beans
2. infrastructure beans (env. specific)

N.B. these two evolve at a different rate

Front 17

Benefits of DI

Back 17

(1). Separation of concern -> Code reusability
(2). promotes programming to interfaces
(3) improves testability - can unit test with stub dependencies
(4) centralised control over object lifecycle

Front 18

Spring xml namespaces

Back 18

context
tx
util

Front 19

Phases of app life cycle

Back 19

1. init
2. use
3. destruction (release any sys resources & now can eligible for garbage collection)

Front 20

Init phrase of life cycle

Back 20

init phase completes when a context is created

(1) Load bean defns
(2) initialise bean instances, i.e. new's

Front 21

Load bean defns

Back 21

(1) *parse* XML files
(2) bean defns (indexed by own's id) are loaded into the context's BeanFactory [kinda like a *HashMap*]
(3) *BeanFactoryPostProcessor* beans are invoked - can modify defns of any bean

Front 22

BeanFactory vs FactoryBean

Back 22

BF: factory to get beans
FB: interface with getObject()

Front 23

BeanFactoryPostProcessor extension point

Back 23

* useful for applying transformations to groups of bean defintions
* there are several useful implementions
* can implement BFPP

Front 24

BFPP

Back 24

BeanFactoryPostProcessor

Front 25

example of BFPP

Back 25

PropertyPlaceholderConfigurer

${vars} in bean defns are subs'ed with values from .properties file

<bean class="PPC">
<property name="location" value="/WEB-INF/datasource.properties" />

more concise:
<context:property-placeholder location="..."/>

Front 26

Initialise bean instances

Back 26

* each bean is eagerly instantiated by default (w/ dependencies injected)
* after DI, each bean goes through a post-processing phase
* after post-processing, bean init'ed and ready for use, tracked by id until context destroyed

Front 27

Application context - defn

Back 27

Spring's *bootstrap* object that loads all the high-level (*entry-point*) objects that
are *required* by your application.

Front 28

DI - formal defn

Back 28

A *pattern* (design) whereby *collaborators* are passed into an object from the
*outside*

Front 29

How does FactoryBean work?

Back 29

1. created by Spring automatically
2. setters are called on the factory
3. getObject