3.0

1
Ramkrishna IT Systems
Vivek S. Kulkarni

2
• Understand the architecture of Spring
Framework
• Understand Dependency Injection
• AOP
• Develop sample applications using
– Spring AOP
– Spring JDBC Support
– Spring Hibernate integration
– Transactional Support in Spring
– Spring Remoting
– Spring MVC

3
• Installing and Using STS
• Writing a simple Spring app
• Understanding ApplicationContext
• Learn bean lifecycle
• Learning Dependency Injection
– Constructor injection
– Setter Injection
• Annotation based DI

4
Course Agenda: Day 2
•
•
•
•
•
AOP : Advice, JoinPoints, PointCuts and Aspects
Adding behavior to an application using aspects
Introducing data access with Spring
Simplifying JDBC-based data access
Driving database transactions in a Spring
environment

5
Course Agenda: Day 3
• Introducing object-to-relational mapping (ORM)
• Getting started with Hibernate in a Spring
environment
• Web application architecture
• Getting started with Spring MVC
• Spring Remoting

6
Overview of the Spring
Framework
Introducing Spring in the context of enterprise
application architecture

7
What is Spring ?
A light-weight dependency injection and aspect-
oriented container and framework

8
What is Spring ?
Light-Weight : Processing overhead required by spring is
negligible
Non-intrusive : Spring enabled application may not have
any dependency on spring, They can be run inside or outside
of the spring framework without any change in source code.
Dependency Injection : Promotes program-to-interface
design principle, thus promotes loose coupling. This technique
is reverse of JNDI –i.e. you do not look-up for dependant
objects in your code, container figures out required objects
and creates them and INJECTS them.

9
What is Spring ?
Aspect-oriented : Application programmers do not write
logic for cross-cutting concerns such as logging, transaction,
security. The Spring framework provides the support for AOP.
Container : Spring is a container in the sense that it contains
and manages the lifecycle and configuration of application
objects. The association of different application objects, their
dependencies, their initialization etc. is configured and
container does the rest.
Framework : A large number of pre-defined classes and
interfaces provide a host of functionality required like
transaction management, MVC, integration with persistence
frameworks and so on. You write only business logic.

10
Goal of the Spring
Framework
• Provide comprehensive infrastructural support
for developing enterprise Java™ applications
– Spring deals with the plumbing
– So you can focus on solving the domain problem

11
Spring’s Support (1)
• Core support
Application Configuration
Enterprise Integration
Data Access

12
Application Configuration
• A typical application system consists of several
parts working together to carry out a use case
Component A Component B
Component C

13
A Typical Use Case
Spring Introduction
transfer(
“300.00”,
“1”, “2”)
updateAccount(a2);
new
new
loadAccount(“1”);
a1
loadAccount(“2”);
a2
debit(“300.00”)
credit(“300.00”)
updateAccount(a1);
Use Case : Bank Money Transfer

14
Spring’s Configuration
Support
• Spring provides support for assembling such an
application system from its parts
– Parts do not worry about finding each other
– Any part can easily be swapped out

15
TransferServiceImpl
Money Transfer System
Assembly
Spring
Part 2
Assembly
JdbcAccountRepository
Part 1
(1) new JdbcAccountRepository(…);
(2) new TransferServiceImpl();
(3) service.setAccountRepository(repository);
8

16
}
Parts are Just Plain Java Objects
public void setAccountRepository(AccountRepository ar) {
accountRepository = ar;
}
…
}
Part 1
Depends on service interface; conceals complexity of
implementation; allows for swapping out implementation
Part 2
public class JdbcAccountRepository implements
AccountRepository {
…
Implements a service interface
public class TransferServiceImpl implements TransferService {
private AccountRepository accountRepository;

17
Enterprise Integration
• Enterprise applications do not work in isolation
• They require enterprise services and resources
Database Connection Pool
Database Transactions
Security
Messaging
Remote Access
Caching

18
Spring Enterprise Integration
• Spring helps you integrate powerful enterprise
services into your application
– While keeping your application code simple and
testable
• Plugs into all Java EE™ application servers
– While capable of standalone usage

19
TransferServiceImpl
Enterprise Money Transfer
with Spring
Spring
JdbcAccountRepository
DataSource
For DB Connection Pooling
13
TransactionManager
For DB Transactions
MBean
Exporter
For JMX Management

20
Simple Application Code
@Transactional
public TransferConfirmation transfer(MonetaryAmount amount, in srcAccountId, int
targetAccountId ){
Account src = accountRepository.loadAccount(srcAccountId);
Account target = accountRepository.loadAccount(targetAccountId);
src.debit(amount);
target.credit(amount);
accountRepository.updateAccount(src);
accountRepository.updateAccount(target);
return new TransferConfirmation(...);
}
}
Tells Spring to run this method
in a database transaction

21
Spring makes data access easier to
– Manage resources for you
– Provide API helpers
– Support all major data access technologies
It also Supports Integration of
Hibernate
iBatis
JPA
Data Access

22
•
•
Acquisition of the connection
Participation in the transaction
•
•
•
•
Execution of the statement
Processing of the result set
Handling of any exception
Release of the connection
All handled
by Spring
Spring JDBC in a Nutshell
Spring's JDBC helper class
int count = jdbcTemplate.queryForInt(
"SELECT COUNT(*) FROM CUSTOMER");

23
Spring Framework History
• http://www.springsource.org/download
• Spring 3.0 (released 12/09)
– Requires Java 1.5+ and JUnit 4.7+
– REST support, JavaConfig, SpEL, more annotations
– Requires Java 1.4+ and supports JUnit 4
– Annotation DI, @MVC controllers, XML namespaces
– Compatible with Java 1.3+
– XML simplification, async JMS, JPA, AspectJ support

24
Download and install STS 2.3.3.M2 from SpringSource.com:
• Eclipse Based
• Has Spring Plug-ins
• Auto-Completion for Spring Config files
• Comes with Tomcat plugged-in
•Comes with Junit-plugged-in

25
Lab -1 : 30 minutes
Use STS for creating non-Spring App

26
Dependency Injection : Alternatives
• Creation using singletons
• Factory Pattern
• Reflection with Strategy Pattern
• Decorator
• Service Locator

27
Dependency Injection : Responsibility of co-ordination and
collaboration is taken away from objects
• Decoupling : Program-to-Interface principle
• Dependency graph
• Clean code
• Enforcing immutability if required
• Enforcing initialization
• Runtime changes in dependency rules
• Objects focus on their task and not worried about availability
of their dependent objects

28
Steps :
1.Identify the dependencies
2.Decide optional dependancies
3.Wire them together in XML file
4.Instantiate ApplicationContext(container)
5.Get Instance by calling getBean() method
Dependency Injection : Using Spring

29
With Spring
ApplicationContext ctx = …
Bank bank = ctx.getBean(“bankService”);
bank.withdraw(1234, 500);
Bank Service Example
Without Spring :
AccountRepository repos = new AccountRepositoryImpl();
Bank bank = new BankImpl(repos);
No need to instantiate AccountRepository, No
knowledge of Bank Implementation class

30
With Spring
ApplicationContext ctx = …
Bank bank = ctx.getBean(“bankService”);
Spring Bean Configuration File :
<bean id="bankService" class="bank.server.internal.BankImpl">
<constructor-arg ref="accountRepo"/>
</bean>
<bean id="accountRepo" class="bank.server.internal.AccountRepositoryImpl">
</bean>
“bankService” must match with bean id

31
Equivalent to
AccountRepository accountRepo = new bank.server.internal.AccountRepositoryImpl();
Bank Bank = new BankImpl(accountRepo);
</bean>
</bean>
Application Context
bankService Instance of BankImpl
accountRepo Instance of
AccountRepositoryImpl

32
Lab -2 : 40 minutes
Use STS for creating Spring App

33
Equivalent to
AccountRepository accountRepo = new
bank.server.internal.AccountRepositoryImpl();
DBAccessRService dbAccessService = new bank.server.internal.DBAccessServiceImpl();
Bank Bank = new BankImpl(accountRepo, dbAccessService);
Constructor Dependency Injection
<constructor-arg ref=“dbAccessService"/>
</bean>
</bean>
</bean>
<bean id=" dbAccessService " class=“bank.server.internal.DBAccessServiceImpl">
</bean>
2 class instances are expected to
be passed to constructor

34
Equivalent to
AccountRepository accountRepo = new bank.server.internal.AccountRepositoryImpl();
DBAccessRService dbAccessService = new bank.server.internal.DBAccessServiceImpl();
Bank Bank = new BankImpl();
bank.setAccountRepository(accountRepo );
bank. setDBAccess(dbAccessService);
Setter Dependency Injection
<bean id="banService" class="bank.server.internal.BankImpl">
<property name=“accountRepository” ref="accountRepo"/>
<property name=“dBAccess” ref=“dbAccessService"/>
</bean>
</bean>
</bean>
</bean>
2 class instances are expected to
be passed to Setters

35
Setter vis-à-vis constructor Dependency Injection
Constructor Dependency : When Do I Use
Enforce mandatory dependancy
Promote Immutability(by assigning dependencies to final vars)
Setter Dependency : When do I Use
Allow optional dependencies
Allow defaults
Config file is more readable(property names are generally
meaningful)
Inherited automatically(Constructors are required to be written in
sub-classes)

36
Mix-and –Match
<property name=“dbAccess”ref=“dbAccessService"/>
</bean>
</bean>
</bean>
</bean>
Setter vis-à-vis constructor Dependency Injection

37
Mix-and –Match
<property name=“dbAccess”ref=“dbAccessService"/>
</bean>
</bean>
</bean>
</bean>
Reccomendations
Use Constructor DI for required properties
Use Setter Injection for optional properties and defaults.
Be consistent in the approach.

38
<bean id=“someService" class=“example.SomeServiceImpl">
<property name=“balance” value=“10000"/>
</bean>
Container takes care of auto conversion of scalar values .
Throws Exception if type mis-match(non-convertible types)
Injection for scalars
Injecting Collections
class BankImpl implements Bank{
Collection<Account> accounts;
public void showAccount(){
for(Account acct : accounts){
System.out.println(acct.toString());
}
}

39
<bean id=“bankService" class=“bank.server.BankImpl">
<property name=“accounts”>
<list>
<ref bean =“current” >
<ref bean =“savings” />
<ref bean = “FD” />
<ref bean =“housingLoan />
</list>
</bean>
Collection<AccountService> accountServices;
BankImpl(Collection<AccountService> accounts){
this. accountServices = accounts;
}
public void showAccountServices(){
for(AccountService acct : accountServices){
System.out.println(acct.toString());
}
}
<set>
<ref bean =“current” >
<ref bean =“savings” />
<ref bean = “FD /
<ref bean =“housingLoan”/>
<ref bean =“housingLoan”/> //duplicate entry
</set>

40
<property name=“accounts”>
<map>
<entry key=“CurrentAccount” value-ref=“current” >
<entry key=“SaningsAccount” value-ref =“savings” />
<entry key=“FixedDeposit” value-ref = “FD” />
</map>
</bean>
Map<AccountService> accountServices;
BankImpl(Collection<AccountService> accounts){
}
for(String accountType : accountServices.keySet()){
System.out.println(accountServices.get(acctType).toString());
}
}
<map>
<entry key-ref=“someBean”
value-ref “otherbean” />
</map >
OR
<map>
<entry key=“someScalarType”
value=“someScalarType” />
</map>

41
<constructor-arg name=“accounts”>
<props>
<prop key=“CurrentAccount”>current </prop>
<prop key=“SaningsAccount” >savings</prop>
<prop key=“FixedDeposit” >FD</prop>
</props>
</bean>
Injecting Collections : Properties
Map<AccountService> accountServices;
BankImpl(Properties accounts){
}
for(String accountType : accountServices.keySet()){
System.out.println(accountServices.get(acctType).toString());
}
}
<props>
<prop key=“keyString”
>value</prop>
</props>

42
DI Advance Options:Inner-beans
<bean id="bankService" class="bank.server.internal.BankImpl" abstract="true" >
<constructor-arg >
<bean class="bank.server.internal.AccountRepositoryImpl" />
</constructor-arg>
</bean>
Implications :
1. Inner beans are always lazy initialized as opposed to early-init of outer beans
2. Inner beans are always scoped to scope of the outer bean

43
Options To do following
1. Control number of instances of a specific bean :
1 Per application (scope=“singleton” this is default)
1 Per usage (scope”prototype”)(This is useful if domain classes are used as
beans)
1 Per user-request (If HTTP capable Spring context is used using SpringMVC then
scope=“request”)
1 per session (If HTTP capable Spring context is used using SpringMVC then
scope=“session”)
Singleton here is different from singleton pattern. Here singleton does not mean
multiple instances cannot be created, all it means is application context keeps
only one copy.
c tx.getBean(“beanName”) method uses the scope attribute to decide the
creation
<bean id=“someId” class=“someClass” scope=“prototype” />
Controlling Bean Creation

44
Bean Scopes : singleton(default)

45
Bean Scopes : prototype
Destruction of prototypes is NOT managed by container .
You have to do the clean-up(call destroy method etc) explicitly in your
client code
OR create custom-BeanPostProcessor to do it for you.

46
Bean Scopes : prototype
Destruction of prototypes is NOT managed by container .
You have to do the clean-up(call destroy method etc) explicitly in your
client code(You need to type-cast ctx to
ConfigurableApplicationContext and call close()
OR create custom-BeanPostProcessor to do it for you.
Prototypes are not eager-initialized unlike singletons
Prototypes are injected once per singleton dependants.
Mutliple calls to getBean(“bankService”) will not refresh(re-instantiate)
the prototype.

47
Get same bean class with different id’s and with some common DI.
Over ride few property values.
Minimize repetitive declarations in xml
parent attribute for sub-beans
No class attribute
abstract=“true” for parent bean
DI Advance Options:sub-beans
<bean id="bankService" class="bank.server.internal.BankImpl" abstract="true" scope="singleton" >
<constructor-arg >
<bean class="bank.server.internal.AccountRepositoryImpl" scope="singleton"/>
</constructor-arg>
<constructor-arg>
<set>
<ref bean="current" />
<ref bean="saving" />
<ref bean="loan"/>
</set>
</constructor-arg>
<property name="bankName" value="RBI" />
<property name="branchCode" value="1234" />
</bean>
<bean id="sbi" parent="bankService" >
<property name="bankName" value="StateBank" />
</bean>
<bean id="axis" parent="bankService" >
</bean>

48
Parent bean could be an abstract class an interface, a concrete class or may
not be a class at all( it is just a set of properties that child beans share).
abstract=“true” for parent bean
Child beans are actually classes which are un-related classes sharing
common properties.
Child beans can overwrite the property values.
DI Advance Options:sub-beans with only property
inheritance
<bean id="bankService" abstract="true" >
<constructor-arg >
<bean class="bank.server.internal.AccountRepositoryImpl" />
</constructor-arg>
<constructor-arg>
<props>
<prop key="CURRENT ACCOUNT" >hello </prop>
<prop key="SAVING ACCOUNT">saving</prop>
<prop key="LOAN ACCOUNT" >loan </prop>
</props>
</constructor-arg>
<property name="bankName" value="SBI"></property>
</bean>
<bean id="sbi" class="bank.server.internal.SBI" parent="bankService" >
</bean>
<bean id="axis" class="bank.server.internal.AXIS" parent="bankService" >
<property name="bankName" value="AXIS"></property>
</bean>
</bean>

49
Allows runtime injection of methods into java classes(like
template method pattern)
2 Forms
Getter Injection : Returns a different spring bean at runtime
Method replacements : Runtime injection of different
implementation
Injecting Methods
1.Getter Injection :
•Bean class could be abstract(or concrete)
•abstract class Magician {
• abstract MagicBox getBox();
•}
•The method which needs to be replaced(injected) at runtime comes from some
other concrete class.
•To replace method, bytecode is instrumented by CGLIB at runtime and a
subclass of the current class is created and the method is injected into it
•So class who’s method is to be replaced can not be final, method cannot be
final either.

50
Allows runtime injection of methods into java classes(like template method
pattern)
2 Forms
Method injection using lookup-method: This is a getter Injection which
returns a different bean at runtime.
Method Injection using Method Replacer:
Injecting Methods
Choo Mantar !!

51
Allows runtime injection of methods into java classes(like
template method pattern)
2 Forms
Method replacements :
Injection Using Method-replacer:
Injecting Methods
2. Method Injection using Method-Replacer :
public class ElephantReplacer implements MethodReplacer {
public Object reimplement(Object arg0, Method arg1, Object[] arg2)
throws Throwable {
//System.out.println("Object whos method is to be
replaced"+arg0.toString()+" Name of Method "+arg1.getName()+" MYSORE ELEPHANT "+arg2[0]);
return "MYSORE ELEPHANT ";
}
}

52
Using non-managed beans (User instantiated beans) with Spring DI
These are normally Domain Beans(Pojos) created by say hibernate
session.load(). You want these objects to be monitored for dependency etc.
by Spring.
Use VM args to enable Load Time Weaving of AspectJ’s Aspect
-javaagent:C:core-spring-3.1.0.RELEASErepositoryorgaspectjaspectjweaver1.6.8aspectjweaver-1.6.8.jar
Injecting Non-spring beans
import org.springframework.beans.factory.annotation.Configurable;
@Configurable("magician")
public class Magician {
String magicwords;
MagicBox box;
…..}
<context:spring-configured />
<bean id="magician" class="com.rits.Magician" >
<property name="box" ref="magicbox"></property>
<property name="magicwords" value="Choo Mantar !!" />
</bean>
<bean id="magicbox" class="com.rits.MagicBoxImpl" />

53
Lab -3 : 45 minutes
Using Setter Injection, Collection Injections

54
<property name=“accountService” ref=“acctRepo” />
</bean>
<bean id=“acctRepo” class=“bank.server.internal.AccountRepositoryImpl” />
OR
<bean id=“bankService" class=“bank.server.BankImpl“ autowire=“byName” />
<bean id=“acctRepo” class=“bank.server. internal.AccountRepositoryImpl” />
AutoWiring
Autowiring of 4 types
1. byName : Attempts to find a bean in the container whose name(or ID) is the same as the
name of the property being wired(injected)
2. byType : Attempts to find a single bean in the container whose type matches the type of
the property being wired. If not found it ignores, if multiple macthes found then throws
org.springframework.beans.factory.UnsatisfiedDependencyException
3.constructor : Tries to match up one or more beans in the container with the parameters of
one of the constructors of the bean being wired. In case of ambiguity it throws
org.springframework.beans.factory.UnsatisfiedDependencyException
4. autodetect : Tries to apply constructor stretagy first if matching constructor found then it
will use contructor injection if not then will apply byType strategy and is matching type found
then applies setterInjection if neither is found then leaves property un-initialized.

55
Special attributes : factory-method/init-
method/destroy-method
1
<bean id=“someId” class=“someClass” factory-method=“getInstance() />
A static object creation method can be invoked instead of calling
constructor. Works for objects with private constructors and true
singletons.
<bean id=“someBean” class=“someClass” init-method=“doInit” />
<bean id=“someBean” class=“someClass” destroy-method=“doDestroy” />
Controlling Bean Creation

56
Special attributes : factory-bean Option-1 : POJO
factory
Useful for existing factory classes
<bean id=“someId” class=“someClass” factory-bean=“someFactory” factory-
method=“getInstance” />
<bean id=“someFactory” class=“someFactoryClass” />
An instance object creation method can be invoked instead of calling
constructor. Works for objects with private constructors and true
singletons
Bean Creation Using factory-bean

57
Option-II Use FactoryBean implementation
<bean id=“someFactoryId” class=“someFactoryClass” />
<bean id=“bankService” class=“BankImpl” >
<property name=“service” ref=“someFactoryId” />
</bean>
A Dependency Injection of the Object returned by the Template
Factory is done transparently (calling getObject Method)
e.g.
Class SomeFactoryClass implements FactoryBean<SomeService>{
public SomeService getObject() throws Exception { return new
SomeSevice() ;}
Bean Creation : Using FactoryBean interface

58
FactoryBean
• Spring uses FactoryBean Template
interface
RemoteProxies are created using FactoryBean
– DataSources are created using FactoryBean
for accessing Hibernate, iBatis etc.

59
ApplicationContext
• Spring provides a lightweight container
called “ApplicationContext”
– 3 flavours for resource(config file) loading
– 1. new ClassPathXmlApplicationContext(“com/sungard/application-config.xml”);
– $CLASSPATH/com/sungard/application-config.xml”
– 2. new FileSystemXmlApplicationContext(c:somedirapplication-config.xml”);
– OR
– new FileSystemXmlApplicationContext(../application-config.xml”);
– 3. XmlWebApplicationContext : Created by WebCOntainers resource loading happens
relative to WEB-INF/

60
ApplicationContext
• Loading multiple config files
• ApplicationContext ctx =
• new ClassPathXmlApplicationConext(new String[]{“application-config.xml”,
“oracle-infra-config.xml” , file:../someOther-config.xml”});
• Separate files for Infrastructure config than
actual application beans.

61
Phases of the Application
Lifecycle
Initialization
• Prepares for use
• Application
services
– Are created
– Configured
– May allocate
system resources
• Application is not
usable until this
phase is complete
Use
• Used by clients
• Application
services
– Process client
requests
– Carry out
application
behaviors
• 99.99% of the
time is spent in
this phase
Destruction
• Shuts down
• Application
services
– Release any
system resources
– Are eligible for
garbage
collection
11

62
Application Initialization
When We create an instance of the ApplicationContext :
Initialization is Complete
During applicationContext Creation, What Happens?
(when we call new CLassPathXMLApplicationContext(…)
1. Loading of Bean Definitions from config files
2. Creates dependancy graph
3. All singleton beans and pre-instantiated (unless lazy-init=“true” )
4. Initialization of bean Instances

63
Application Initialization :
Loading Bean Definitions
•The XML files are parsed.
Bean Definitions are loaded into the context’s
BeanFactory
Special Beans “BeanFactoryPostProcessor” are
invoked
These special beans can modify the bean
definitions before creating the objects.

64
Load Bean Definitions
application-config.xml
<beans>
Application Context
BeanFactory
transferService
accountRepository
dataSource
postProcess(BeanFactory)
BeanFactoryPostProcessors
<bean id=“transferService” …
<bean id=“accountRepository”…
</beans>
test-infrastructure-config.xml
<beans>
<bean id=“dataSource” …
</beans>
Can modify the definition of
any bean in the factory
before any objects are created
17

65
BeanFactoryPostProcessor
•An Extension Point to modify bean definitions programatically before
loading bean definitions
•Several useful special BeanFactoryPostProcessor beans are provided
by Spring
• e.g. PropertyPlaceholderConfigurer
It substitutes ${variables} in bean definitions with values
from .properties files
CustomEditorConfigurer
It loads custom editors into beanfactory.
You can write your own by implementing BeanFactoryPostProcessor interface

66
Custom Property Editors
class Contact{
public PhoneNumber getPhone() {
return phone;
}
public void setPhone(PhoneNumber phone) {
this.phone = phone;
}
public class PhoneNumber {
String areaCode;
String stdCode;
String number;
public PhoneNumber(String areaCode, String stdCode, String number) {
super();
this.areaCode = areaCode;
this.stdCode = stdCode;
this.number = number;
}
<bean id="contact" class="com.rits.training.Contact" >
<property name="phone" value="512-230-9630" />
</bean>
Need to convert
String into
PhoneNumber

67
mport java.beans.PropertyEditorSupport;
public class PhoneEditor extends PropertyEditorSupport {
@Override
public void setAsText(String text) throws IllegalArgumentException {
String stripped = stripOutNonNumerics(text);
String areaCode = stripped.substring(0,3);
String prefix = stripped.substring(3,6);
String number = stripped.substring(6);
PhoneNumber phone = new PhoneNumber(areaCode,prefix, number);
this.setValue(phone);
}
private String stripOutNonNumerics(String original){
StringBuffer allNumeric = new StringBuffer();
for(int i=0; i < original.length(); i++){
char c = original.charAt(i);
if(Character.isDigit(c)){
allNumeric.append(c);
}

68
We should tell Spring about our custom PhoneEditor
<bean id="contact" class="com.rits.training.Contact" >
<property name="phone" value="512-230-9630" />
</bean>
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
<property name="customEditors">
<map>
<entry key="com.rits.training.PhoneNumber">
<bean id="phoneEditor" class="com.rits.training.PhoneEditor" />
</entry>
</map>
</property>
</bean>
CustomEditorConfigurer is a BeanFactoryPostProcessor. It registers PhoneEditor with
BeanFactory, so BeanFactory would invoke this before creating Contact bean.

69
BeanFactoryPostProcessor : PropertyPlaceholderConfigurer
<property name=“URL” value=“${datasource.url}” />
<property name=“user” value=“${datasource.user}” />
<bean class=“org.springframework.beans.factory.config.
PropertyPlaceholderConfigurer”>
<property name=“location” value=“/WEB-INF/datasource.properties” />
File where the variable values reside
datasource.url=jdbc:oracle:thin:@localhost:1521:BANK
datasource.user=moneytransfer-app
</bean>
</beans>
datasource.properties
Variables to replace
Easily editable
21
<beans>
<bean id=“dataSource” class=“com.oracle.Jdbc.pool.OracleDataSource”>

70
Simplifying configuration with
<context:property-placeholder>
<beans ... >
<bean id=“dataSource” class=“com.oracle.Jdbc.pool.OracleDataSource”>
<property name=“URL” value=“${datasource.url}” />
<property name=“user” value=“${datasource.user}” />
</bean>
<context:property-placeholder location=“datasource.properties” />
</beans>
Creates the same PropertyPlaceholderConfigurer
bean definition in a more concise fashion

71
Registering for an Initialization
Callback with InitializingBean
• Initialization technique used prior to Spring 2.5
– Disadvantage: Ties your code to the framework
– Advantage: The only way to enforce initialization
code should run (not affected by configuration changes)
package org.springframework.beans.factory;
public interface InitializingBean {
public void afterPropertiesSet();
}
PropertyPlaceholderConfigurer
20
How PropertyPlaceholderConfigurer
Works
Spring Application Context
(after bean definitions are loaded)
postProcess(BeanFactory)
Bean definition
“dataSource”
URL=${datasource.url}
user=${datasource.user}
Bean definition
“dataSource”
URL=Jdbc:oracle:…
user=moneytransfer-app

72
Steps involved in Initializing Bean Instances
• Each bean is eagerly instantiated by default
– Created in the right order with its dependencies
injected
• After dependency injection each bean goes
through a post-processing phase
– Where further configuration and initialization can
occur
• After post processing the bean is fully initialized
and ready for use
– Tracked by its id until the context is destroyed

73
Bean Initialization Steps
Bean
Instantiated
Dependencies
InJected
Bean Post
Processed
Bean
Ready
For Use

74
Bean Post Processing
• Bean post processing can be broken down into
two steps
– Initialize the bean if instructed
– Call special BeanPostProcessors to perform additional
configuration

75
Initialize the Bean if
Instructed
• A bean can optionally register for one or more
initialization callbacks
– Useful for executing custom initialization behaviors
• There's more than one way to do it
– JSR-250 @PostConstruct
– <bean/> init-method attribute
– Implement Spring's InitializingBean interface

76
Registering for Initialization with @PostConstruct
public class TransferServiceImpl {
@PostConstruct
void init() {
// your custom initialization code
Tells Spring to call init
after DI
No restrictions on
method name or visibility
}
}
• This is the preferred initialization technique
– Flexible, avoids depending on Spring APIs
– Requires Spring 2.5 or better
30

77
Enabling Common Annotation- Based Initialization
• @PostConstruct will be ignored unless Spring is
instructed to detect and process it
<beans>
<bean id=“transferService” class=“example.TransferServiceImpl” />
<bean class=“org.springframework.context.annotation.
CommonAnnotationBeanPostProcessor” />
</beans>
Detects and invokes any
methods annotated with
@PostConstruct

78
Registering for an Initialization
Callback with InitializingBean
• Initialization technique used prior to Spring 2.5
– Disadvantage: Ties your code to the framework
– Advantage: The only way to enforce initialization
code should run (not affected by configuration changes)
package org.springframework.beans.factory;
public interface InitializingBean {
public void afterPropertiesSet();
}

79
Simplifying Configuration with
<context:annotation-config>
<beans>
<bean id=“transferService” class=“example.TransferServiceImpl” />
<context:annotation-config/>
</beans> Enables multiple BeanPostProcessors, including:
• RequiredAnnotationBeanPostProcessor
• CommonAnnotationBeanPostProcessor

80
Initializing a Bean You Do Not Control
•
Use init-method to initialize a bean you do not
control the implementation of
<bean id=“current”
class="bank.server.internal.CurentAccount"
init-method=“initialize”>
…
</bean>
Method can be any visibility, but must have no arguments
34
Class with no Spring dependency

81
Initialization : @Required
•RequiredAnnotationBeanPostProcessor
e.g.
@Required
public void setInterestRate(float interestRate) {
this.interestRate = interestRate;
System.out.println("Saving Account : interest ");
}rate property set”);
If interestRate property of this class is not configured in config file for DI,
container would throw
org.springframework.beans.factory.BeanCreationException
This is a useful technique for enforcing the initialization

82
Destroying : @PreDestroy
•BeanPostProcessor
Called when ctx.close() is invoked.
@PreDestroy
public void releaseResources() {
System.out.println(“Resources released”);
}
This is a useful technique for enforcing the release of some resources like DB
connections etc.

83
Destroying : destroy-method
<bean id=“somBean” class=“SomeClass” destroy-method=“someMethod” />
connections etc.
43
Topics in this session
• Introduction to Spring's XML namespaces
• The lifecycle of a Spring application context
– The initialization phase
– The use phase
– The destruction phase
• Bean scoping
Use DestructionInitialization

84
Destroying : destroy-method
<bean id=“somBean” class=“SomeClass” destroy-method=“someMethod” />
connections etc.
43
• Introduction to Spring's XML namespaces
• The lifecycle of a Spring application context
– The initialization phase
– The use phase
– The destruction phase
• Bean scoping
Use DestructionInitialization
44
The Lifecycle of a Spring Application
Context (2) - The Use Phase
• When you invoke a bean obtained from the
context the application is used
• But exactly what happens in this phase?
ApplicationContext context = // get it from somewhere
// Lookup the entry point into the application
TransferService service =
(TransferService) context.getBean(“transferService”);
// Use it!
service.transfer(new MonetaryAmount(“50.00”), “1”, “2”);

85
Ramkrishna IT Systems 45
Inside The Bean Request
(Use) Lifecycle
• If the bean is just your raw object it is simply
invoked directly (nothing special)
TransferServiceImpl
transfer(“$50”, “1”, 2”)
transfer(“$50”, “1”, 2”)
TransferServiceImpl
• If your bean has been wrapped in a proxy
things get more interesting
Spring Proxy

86
Inside The Bean Request
(Use) Lifecycle
• If the bean is just your raw object it is simply
invoked directly (nothing special)
TransferServiceImpl
transfer(“$50”, “1”, 2”)
transfer(“$50”, “1”, 2”)
TransferServiceImpl
Spring Proxy

87
TransferServiceImpl
transfer(“$50”, “1”, 2”)
transfer(“$50”, “1”, 2”)
TransferServiceImpl
Spring Proxy

88
Annotation-Based
Dependency Injection
Introducing Spring’s Annotations for

89
Topics in this Session
•
•
•
•
•
•
•
•
•
Configuration Approaches
Java-based Configuration
Annotation Quick Start
Other Configuration Annotations
Component Scanning
Stereotype and Meta-annotations
When To Use What
Summary & Lab
Advanced Options

90
Configuration
Instructions
How Spring Works
Your Application Classes (POJOs)
Spring
Application Context
Creates
Fully configured
application system
Ready for use

91
The Approach You’re Used to
public TransferServiceImpl(AccountRepository ar) {
this.accountRepository = ar;
}
…
}
public class JdbcAccountRepository implements AccountRepository {
public void setDataSource(DataSource ds) {
this.dataSource = ds;
}
…
}
4
Use POJOs with constructor arguments
and/or property setters for configuration

92
The Approach You’re Used to
<beans>
<bean id=“transferService” class=“app.impl.TransferServiceImpl””>
<constructor-arg ref=“accountRepository” />
</bean>
<bean id=“accountRepository” class=“app.impl.JdbcAccountRepository””>
<property name=“dataSource” ref=“dataSource” />
</bean>
<bean id=“dataSource” class=“com.oracle.jdbc.pool.OracleDataSource””>
<property name=“URL” value=“jdbc:oracle:thin:@localhost:1521:BANK” />
<property name=“user” value=“moneytransfer-app” />
</bean>
</beans>
5
<bean> defines a bean

93
Alternative Approaches
• Bean definitions can also be defined and
configured in Java
• Or by using annotations in Spring-managed classes
• Both are alternatives to XML approach
– Not intended as complete replacements
– Can be used together

94
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

95
Java-based Approach
• Spring 3.0 introduces Java-based configuration
– Based on the old JavaConfig project
• Use Java code to define and configure beans
– Configuration still external to POJO classes to be
configured
– More control over bean instantiation and configuration
– More type-safety
• Still produces bean definitions
– Spring remains in charge applying post-processors etc.

96
•The central artifact in Spring's new Java-configuration support is
the @Configuration-annotated class.
•These classes consist principally of @Bean-annotated methods
•These Methods define instantiation, configuration, and initialization logic for objects to
be managed by the Spring IoC container.
•Annotating a class with the @Configuration indicates that the class can be used by the
Spring IoC container as a source of bean definitions.
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
<beans>
<bean id="myService" class=“com.rits.training.MyServiceImpl"/>
</beans>
XML Way
Spring3.0 Java Configuration Class

97
@Configuration-annotated classes are sub-classed at load time by CGLIB so
They should not be final
They should have no-arg non-private constructor
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
Getting bean instances using AnnotationConfigApplicationContext.
Class client{
public static void main(String[] args){
AnnotationConfigApplicationContext ctx =
new AnnotaionConfigApplicationContext(AppConfig.class)
}
No XML
Just Use
@Configuration
class Name

98
@Mix-Match of Java-Based and XML based configuration
(@Configuration –centric)
@ImportResource("test-infrastructure-Java_Based_config.xml")
public class BankConfig {
private @Value(“#{jdbcProperties.oracleURL}") String url;
private @Value(“#{jdbcProperties.oracleUser}") String username;
private @Value(“#{jdbcProperties.oraclePassword}") String password;
private @Value(“#{jdbcProperties.oracleDriver}") String driver;
…..
public @Bean(scope=“singleton”) DriverManagerDataSource dataSource() {
return new DriverManagerDataSource(url, username, password);
}
testdb.properties
oracleDriver=oracle.jdbc.driver.OracleDriver
oracleURL=jdbc:oracle:thin:@localhost:1521:XE
oracleUser=system
oraclePassword=system
<util:properties id="jdbcProperties"
location="testdb.properties"/>
test-infrastructure-…xml

99
@Configuration("configBank")
@ImportResource("test-infrastructure-Java_Based_config.xml")
public class BankConfig {
private @Value("#{jdbcProperties.oracleURL}") String url;
private @Value("#{jdbcProperties.oracleUser}") String username;
…..
@Bean(name="bankService")
@Scope("prototype")
Bank bankService(){
Collection<AccountService> accts = new ArrayList<AccountService>();
accts.add(currentAccount());
accts.add(loan());
accts.add(saving());
return new BankImpl(accountRepository(),accts);
}
@Bean(name="acctRepo")
AccountRepository accountRepository(){
return new AccountRepositoryImpl(dataSource());
}
@Bean(name="current")
AccountService currentAccount(){
CurentAccount acct= new CurentAccount("Ramkrishna IT",1000000);
acct.setAcctNo(123456789);
return acct;
} public @Bean DriverManagerDataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource(url, username,
password);
dataSource.setDriverClassName(driverClassName);
return dataSource;
}
}

100
Enabling Java-based Approach
• Making this work requires two steps:
– Define config class as Spring Bean
– Add <context:annotation-config/>
<beans xmlns="http://www.springframework.org/schema/beans
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="...">
Turns on checking of configuration
annotations for beans declared
in this context

101
Usage - Nothing Changes!
// Create the application from the configuration
ApplicationContext context =
new ClassPathXmlApplicationContext(“application-config.xml””);
// Look up the application service interface
Bank service = (Bank) context.getBean(“bankService””);
// Use the application

102
Implementing @Bean Methods
• Configuration in Java: call any code you want
– Not just constructors and property setters
• May not be private
• Method name becomes bean name
• Call @Bean method to refer to bean in same class
– We'll show how to refer to external beans later
• Same defaults as XML: beans are singletons
– Use @Scope annotation to change scope
@Bean @Scope("prototype")
public StatefulService service() {
…

103
@Bean Lifecycle
• Init- and destroy methods can be specified
– Using attributes of the annotation
– init really isn't required, can just call method yourself
@Bean(destroyMethod="close")
public DataSource dataSource() {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setUrl("jdbc:derby:rewardsdb");
// can call init method here if you need to
return dataSource;
}

104
Implementing @Configuration
Classes
• Must have default constructor
• Multiple @Configuration classes may exist
• Can import each other using @Import
– Equivalent to <import/> in XML
– Means included classes don't have to be defined as
Spring beans anymore
@Import({SecurityConfig.class, JmxConfig.class})
@Configuration
public class RewardsConfig {
…
}

105
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

106
Annotation-based
Configuration
• Spring 2.5 introduced annotation-based
configuration as another alternative to XML
• Moves configuration instructions into your code
– Unlike XML or Java-based approaches
• Can be used in combination with the other
approaches
Annotation injection is performed before XML injection, thus the latter
configuration will override the former for properties wired through both
approaches.

107
The Annotation-Based Approach
@Autowired
}
…
public class JdbcAccountRepository implements AccountRepository {
@Autowired
public void setDataSource(DataSource ds) {
this.dataSource = ds;}
…
}
17
Spring automatically tries to wire this
}

108
The Annotation-Based Approach
<beans>
<bean id=“transferService”
class=“app.impl.TransferServiceImpl”/”/>
<bean id=“accountRepository”
class=“app.impl.JdbcAccountRepository””/>
<bean id=“dataSource” class=“com.oracle.jdbc.pool.OracleDataSource””>
<property name=“URL” value=“jdbc:oracle:thin:@localhost:1521:BANK” />
<property name=“user” value=“moneytransfer-app” />
</bean>
</beans>
18
No need to specify
constructor-arg or
property

109
Quick Start Summary
• Spring container needs POJOs and wiring
instructions to assemble your application
• Wiring instructions can be provided in XML…
• …but also using Java with @Bean-methods
• … or @Autowired annotations…
• …or a combination

110
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

111
Configuration Annotations
•
•
•
•
•
•
@Autowired
@Qualifier / @Primary
@Resource
@Value
@Component / @Repository
Shown already:
– @Configuration / @Bean plus @Scope, @Import, etc.
– @PostConstruct / @PreDestroy / @Required

112
@Autowired
• Asks Spring to autowire fields, methods or
constructors by using the type`
– Requires unique match!
• Removes the need to specify constructor-arg
or property elements in XML`
public class TransferServiceImpl implements TransferService
@Autowired
}
…
}

113
@Autowired
• Methods can have any name
• Methods and constructors can have multiple
arguments that will all be injected
public class MyServiceImpl implements MyService
@Autowired
public void initialize(SomeDependency sd, OtherDependency od) {
this.someDependency = sd;
this.otherDependency = od;}
…
}

114
Disambiguation with @Autowired
• Disambiguation needed when multiple beans of
same type exist, one of which must be injected
• Using @Qualifier you can inject beans by name
@Autowired
@Qualifier(“primaryDataSource”)
private DataSource dataSource;
@Autowired
void init(@Qualifier(“primaryDataSource”) DataSource primary,
@Qualifier(“altDataSource”) DataSource alternative)
{ … }
24
Specify name of
bean to inject

115
Option-I use qualifier child element in <bean> definition
<bean class=“com.rits.SomeDBSource”>
<qualifier value=“primaryDataSource” >
</bean>
<bean class=“com.rits.SomeOtherDBSource”>
<qualifier value=“primaryDataSource” >
</bean>

116
Disambiguation with @Primary
Option-II Java-based config alternative solution:
one bean can be made the primary candidate for
autowiring
– Will be used in case of multiple matches by type
@Bean @Primary
public DataSource standardDataSource() {
…
}
@Bean
public DataSource backupDataSource() {
…
}

117
@Resource ("myBeanName")
•
•
•
•
JSR-250 annotation (not Spring-specific)
Injects a bean identified by the given name
Useful when auto wiring by type does not work
Can also lookup JNDI references
@Resource("myBackupRepository")
public void setBackupRepo(AccountRepository repo) {
this.backRepo = repo;
}
}
26
Option-III

118
@Resource in Spring
Some additional behavior over Java EE 5:
• By default, falls back to autowiring by type if no
bean with given name exists
• Works for all methods, not just setters
– But not for constructors!

119
SpEL and Annotations
• Use @Value for SpEL expressions in Java code
– On a field or method or on parameter of autowired
method or constructor
@Value("#{ systemProperties['user.region'] }")
private String defaultLocale;
@Value("#{ systemProperties['user.region'] }")
public void setDefaultLocale(String defaultLocale) { … }
@Autowired
public void configure(AccountRepository accountRepository,
@Value("#{ systemProperties['user.region'] }") String defaultLocale) {
…
}

120
Turns on checking of DI
annotations for beans declared
in this context
<bean id=“transferService” class=“transfer.TransferService””/>
<bean id=“accountRepository” class=“transfer.JdbcAccountRepository””/>
</beans>
29
For these Annotations to
Work…
We need to ‘enable them’, just like for Java-based
configuration
<beans xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="...">

121
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

122
@Component
• Identifies POJOs as Spring Beans
• Removes the need to specify almost anything in XML
@Component
@Autowired
}
…
}

123
@Component and names
• Default bean name is de-capitalized non-qualified name
• @Component takes an optional String to name the bean
– Arguably not a best practice to put bean names in your Java
code
”)@Component(“transferService”)
@Autowired
}
…
}

124
For This Annotation To Work…
• We need to enable ‘component scanning’
– Auto-enables <context:annotation-config/>
<beans xmlns="http://www.springframework.org/schema/beans
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package=“transfer””/>
</beans>
No more need to mention the
beans in the application context

125
@Scope and @Primary
Like with @Bean:
• @Scope allows customizing the instantiation strategy
”)@Scope(“prototype”) @Component
…
• @Primary allows making one component-scanned bean
the primary candidate for autowiring
@Primary @Component
public class DefaultCalculationService implements CalculationService {
…

126
Scanning and auto-wiring for
@Configuration classes
• Are picked up by component scanning
– No more need for XML bean definition or @Import
• Can use autowiring
– Like any Spring-bean
– Gives access to external beans from @Bean methods
• Can be autowired into another @Configuration
– Allowing for external @Bean methods to be called
– Type-safe, IDE-friendly alternative to by-name wiring

127
Combined Example
@Configuration
public class InfraConfig {
@Bean public DataSource dataSource() {
DataSource dataSource = ...;
return dataSource;
}
}
@Configuration @Import(InfraConfig.class)
public class RewardsConfig {
@Autowired InfraConfig infraConfig;
@Bean AccountRepository accountRepository() {
JdbcAccountRepository repository = new JdbcAccountRepository();
repository.setDataSource(infraConfig.dataSource());
return repository;
}
}
Import not needed if InfraConfig
was component-scanned
Alternative is to simply autowire
DataSource directly

128
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

129
Stereotype annotations
• Component scanning also checks for annotations
that are themselves annotated with @Component
– So-called stereotype annotations(Marker annotaion suggesting specific purpose
– Identify the architectural purpose of a class
– Particularly useful for matching (e.g. with AOP)
• Spring framework stereotype annotations:
– @Service – identify service classes
– @Repository – identify data access classes
– @Controller – identify web presentation classes
• Other Spring-based frameworks define their own

130
Meta-annotations
• A meta-annotation is an annotation which can be used to
annotate other annotations
• e.g. all of your service beans should be configurable using
component scanning and be transactional
@Transactional(timeout=60)
@Service
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyTransactionalService {
String value() default "";
}
@MyTransactionalService
...

131
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

132
When use what?
Annotations:
• Nice for frequently changing beans
– Start using for small isolated parts of your application
(e.g. Spring @MVC controllers)
• Pros:
– Single place to edit (just the class)
– Allows for very rapid development
• Cons:
– Configuration spread across your code base
– Only works for your own code
--Maintenance issues
--Recompilation for any changes

133
When use what?
XML:
• Cons:
– Some people just don't like XML...
• For infrastructure and more 'static' beans
• Pros:
– Is centralized in one (or a few) places
– Most familiar configuration format for most people
– Can be used for all classes (not just your own)

134
When use what?
Java-based:
• For full control over instantiation and
configuration
– As alternative to implementing FactoryBean
• Pros:
– Configuration still external to code
– Integrates well with legacy code
• Can call methods such as addDataSource(DataSource d)
• Cons:
– Wiring won't show up in STS
– No equivalent to the XML namespaces

135
•
•
•
•
•
•
•
•
•
Component Scanning
When To Use What
Summary & Lab
Advanced Options

136
Summary
• Spring’s configuration directives can be written
in XML, using Java or using annotations
• You can mix and match XML, Java and
annotations as you please
• Autowiring with @Component or @Configuration
allows for almost empty XML configuration files

137
Copyright 2005-2008 SpringSource. Copying, publishing or distributing without express written permission is prohibited.
LAB
Using Spring’s annotations to Configure and
test an application

138
AOP
•Aspect Oriented Programming
Cross-Cutting Concerns : Transactions, Logging, Security, Caching,
ErrorHandling
Goal :
Separation of cross-cutting concerns from business logic
Write common functionality at one place
Declaratively add the functionality in the code
Decoupling business domain logic from infrastructure code
No impact on adding or removing the infra functionality.

139
AOP
Cross-Cutting Concerns : Transactions, Logging, Security, Caching,
ErrorHandling
Goal :
Separation of cross-cutting concerns from business logic
Write common functionality at one place
Declaratively add the functionality in the code
Decoupling business domain logic from infrastructure code
No impact on domain code while adding/removing the infra.

140
AOP
Goal :
To Avoid Code Tangling(Mixing of concerns)
To avoid Code scattering(Duplication of code at multiple places)

141
Implementing Cross Cutting
Concerns Without Modularization
• Failing to modularize cross-cutting concerns
leads to two things
1. Code tangling
• A coupling of concerns
2. Code scattering
• The same concern spread across modules

142
Symptom #1: Tangling
public class RewardNetworkImpl implements RewardNetwork {
public RewardConfirmation rewardAccountFor(Dining dining) {
if (!hasPermission(SecurityContext.getPrincipal()) {
throw new AccessDeniedException();
}
Account a = accountRepository.findByCreditCard(…
Restaurant r = restaurantRepository.findByMerchantNumber(…
MonetaryAmount amt = r.calculateBenefitFor(account, dining);
…
}
}
Mixed Concerns

143
Duplication
8
Symptom #2: Scattering
public class HibernateAccountManager implements AccountManager {
public Account getAccountForEditing(Long id) {
}
…
public class HibernateMerchantReportingService implements
MerchantReportingService {
public List<DiningSummary> findDinings(String merchantNumber,
DateInterval interval) {
}
…

144
BankService
System Evolution Without
Modularization
Code
tangling
Security
Transactions
Logging
CustomerService ReportingService
Code
scattering

145
How AOP Works
1. Implement your mainline application logic
Focusing on the core problem
2. Write aspects to implement your cross-cutting
concerns
Spring provides many aspects out-of-the-box
3. Weave the aspects into your application
Adding the cross-cutting behaviours to the right
places

146
System Evolution: AOP based
BankService
Security
Aspect
CustomerService
Transaction
Aspect
ReportingService
Logging
Aspect

147
Leading AOP Technologies
• AspectJ
– Original AOP technology (first version in 1995)
– Offers a full-blown Aspect Oriented Programming
language
• Uses byte code modification for aspect weaving
• Spring AOP
– Java-based AOP framework with AspectJ integration
• Uses dynamic proxies for aspect weaving
– Focuses on using AOP to solve enterprise problems
– The focus of this session

148
•
•
•
•
•
•
What Problem Does AOP Solve?
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
– Named Pointcuts
– Context selecting pointcuts
– Working with annotations

149
Core AOP Concepts
•Aspect Oriented Programming : Terminology
Advice :
A piece of code that needs to be executed before/after/around
business logic. This code executes without knowledge of domain code.
What and when is defined by advice
Should it be applied before the method (Before advice)
Should it be applied after method execution (After-return advice)
Should it be applied before and after method (Around advice)
Should it be applied if method throws an exception(After-throwing)
Should it be applied after method execution (even if method throws
exception) (After advice)

150
AOP
JoinPoint :
• A join-point is a point in the execution of application where a
particular cross-cutting concern (advice) is to be plugged-in
• A JoinPoint could be a method invocation, a change of a field value
or it could be an exception being thrown
• Spring only supports method invocation as a JoinPoint

151
AOP
PointCut :
• Its an expression which decides the set of JoinPoints where the
advice is to applied.
•Advices define when and what is to be applied while PointCut defines
where it is to be applied.
•PointCuts in Spring define set of methods using regular expressions.

152
AOP
•Aspect :
• Aspect is combination of JoinPoints and PointCuts and advice
Introduction :
• It allows you to add new methods or attributes to existing classes
without changing them

153
AOP
•Target :
• Object on which advice is to applied
Proxy :
• A new Object which wraps the target object and intercepts the calls
from the Client.
•Proxy is the Object which will be created at runtime and it intercepts
the invocations.

154
AOP
•Weaving :
• Process of applying aspects on target objects
•Weaving in Spring happens at runtime
Proxy :
• A new Object which wraps the target object and intercepts the calls
from the Client.
•Proxy is the Object which will be created at runtime and it intercepts
the invocations.

155
Steps to Use AOP
1. Implement your mainline application logic
Focusing on the core problem
2. Write aspects to implement your cross-cutting
concerns
•
Spring provides many aspects out-of-the-box
3. Weave the aspects into your application
•
Adding the cross-cutting behaviours to the right
places

156
AOP Quick Start
• Consider this basic requirement
• How can you use AOP to meet it?
Log a message every time a property is about to change

157
Target Object :
Whose State Change is to be tracked
public class SimpleCache implements Cache {
private int cacheSize;
private DataSource dataSource;
private String name;
public void setCacheSize(int size) { cacheSize = size; }
public void setDataSource(DataSource ds) { dataSource = ds; }
public void setBeanName(String beanName) { name = beanName; }
public String toString() { return name; }
…
}

158
Implement the Aspect
@Aspect
public class PropertyChangeTracker {
private Logger logger = Logger.getLogger(getClass());
@Before(“execution(void set*(*))”)
public void trackChange() {
logger.info(“Property about to change…”);
}
}

159
<beans>
<aop:aspectj-autoproxy>
<aop:include name=“propertyChangeTracker” />
</aop:aspectj-autoproxy>
<bean id=“propertyChangeTracker” class=“example.PropertyChangeTracker” />
</beans>
20
Configures Spring to apply the
@Aspect to your beans
Configure the Aspect as a
Bean
aspects-config.xml

160
Include the Aspect
Configuration
<beans>
<import resource= “aspects-config.xml”/>
<bean name=“cache-A” class=“example.SimpleCache” ../>
<bean name=“cache-B” class=“example.SimpleCache” ../>
<bean name=“cache-C” class=“example.SimpleCache” ../>
</beans>
application-config.xml

161
Test the Application
ApplicationContext context =
new ClassPathXmlApplicationContext(“application-config.xml”);
Cache cache = (Cache) context.getBean(“cache-A”);
cache.setCacheSize(2500);
INFO: Property about to change…

162
SimpleCache
(target)
PropertyChange
Tracker (aspect)
4. Matching advice is executed
1. Spring creates a proxy that brings
the aspect and target together
23
3. All calls routed through proxy
Spring AOP Proxy (this)
<<interface>>
Cache
the business interface
of the target
How Aspects are Applied
2. The proxy implements
setCacheSize(2500)

163
}
}
Tracking Property Changes –
With Context
• Context is provided by the JoinPoint method
parameter
@Aspect
Context about the intercepted point
public void trackChange(JoinPoint point) {
String name = point.getSignature().getName();
Object newValue = point.getArgs()[0];
logger.info(name + “ about to change to ” + newValue +
“ on ” + point.getTarget());
INFO: setCacheSize about to change to 2500 on cache-A

164
•
•
•
•
•
•
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
– Named Pointcuts
– Context selecting pointcuts
– Working with annotations

165
Defining Pointcuts
• With Spring AOP you write pointcuts using
AspectJ’s pointcut expression language
– For selecting where to apply advice
• Complete expression language reference
available at
– http://www.eclipse.org/aspectj

166
Common Pointcut Designator
• execution(<method pattern>)
– The method must match the pattern
• Can chain together to create composite
pointcuts
– && (and), || (or), ! (not)
– [Modifiers] ReturnType [ClassType]
MethodName ([Arguments]) [throws ExceptionType]

167
Writing expressions
execution(* rewards.restaurant.*Service.find*(..))
package
type params
methoddesignator
return type

168
Execution Expression
Examples
execution(void send*(String))
– Any method starting with send that takes a single String
parameter and has a void return type
execution(* send(*))
– Any method named send that takes a single parameter
execution(* send(int, ..))
– Any method named send whose first parameter is an int (the
“..” signifies 0 or more parameters may follow)

169
Execution Expression
Examples
execution(void example.MessageServiceImpl.*(..))
– Any visible void method in the MessageServiceImpl class
execution(void example.MessageService+.send(*))
– Any void method named send in any object of type
MessageService (that include possible child classes or
implementors of MessageService)
execution(@javax.annotation.security.RolesAllowed void send*(..))
– Any void method starting with send that is annotated with
the @RolesAllowed annotation

170
Execution Expression Examples
working with packages
execution(* rewards.*.restaurant.*.*(..))
– There is one directory between rewards and restaurant
execution(* rewards..restaurant.*.*(..))
– There may be several directories between rewards and
restaurant
execution(* *..restaurant.*.*(..))
– Any sub-package called restaurant

171
Proxy BeforeAdvice Target
Before Advice

172
Before Advice Example
• Use @Before annotation
– If the advice throws an exception, target will not be
called
@Aspect
public void trackChange() {
logger.info(“Property about to change…”);
}
}
Track calls to all setter methods

173
After Advice
Proxy AfterReturning Target
Successful return

174
After Returning
• @Aspect
• public class PropertyChangeTracker {
• @Pointcut(" execution(* update*(..)) || execution(* set*(..))")
• void updateORSetMethod(){}
• @Pointcut("(!execution(* bank.server.internal.BankImpl.get*(*))) && execution(*
get*(..))")
• void getMethodAdvice(){}
• @After("updateORSetMethod()")
• void trackChange2(JoinPoint jp){
• String methodName = jp.getSignature().getName();
• Object newValue = jp.getArgs()[0];
• System.out.println("After Advice of PropertyChangeTracker1 invoked for method
"+methodName);
• System.out.println("After 1 Property changed to "+newValue);
• }
• }

175
After Advice
Proxy After Advice Target
Success or Exception

176
AfterThrowing Advice
Proxy After Advice Target
Exception

177
After Throwing
• @Aspect
• @Pointcut(" execution(* update*(..)) || execution(* set*(..))")
• void updateORSetMethod(){}
• @Pointcut("(!execution(* bank.server.internal.BankImpl.get*(*))) && execution(*
get*(..))")
• void getMethodAdvice(){}
• @After("updateORSetMethod()")
• @AfterThrowing(value="getMethodAdvice()",throwing="e")
• void handleException(JoinPoint p, Throwable e){
• System.out.println("DEBUG AfterThrowing invoked due ot Exception
"+e.getMessage()+"By method "+p.getSignature().getName()+" On Class
"+p.getTarget().getClass().getName());
• }
• }

178
Around Advice
Around TargetProxyProxy Around Target
proceed()
Around Advice

179
@Around
• @Aspect
• @Around("! execution(* bank.server.internal.BankImpl.get*(*)) && (execution(*
update*(..)) || execution(* set*(..))|| execution(* get*(..)))" )
• Object trackChange(ProceedingJoinPoint jp) throws Throwable{
– String methodName = jp.getSignature().getName();
• Object newValue =null;
– if(jp.getArgs().length>0){
– newValue = jp.getArgs()[0];
– }
– System.out.println("Kind ="+jp.getKind());
– System.out.println("PropertyChangeTracker FIRST invoked for method "+methodName);
– System.out.println("BEFORE Property Change About to change to "+newValue);
– Object value = jp.proceed();
– System.out.println("AROUND AFTER property change is complete value ="+value);
– if(value instanceof String)
– return value+"CHANGED BY ADVICE";
– return value;
• }}
}

181
Alternative Spring AOP
Syntax - XML
• Annotation syntax is Java 5+ only
• XML syntax works on Java 1.4
• Approach
– Aspect logic defined Java
– Aspect configuration in XML
• Uses the aop namespace

182
Tracking Property Changes -
Java Code
public void trackChange(JoinPoint point) {
…
}
}
Aspect is a Plain Java Class with no Java 5 annotations

183
Tracking Property Changes -
XML Configuration
<aop:config>
<aop:aspect ref=“propertyChangeTracker”>
<aop:before pointcut=“execution(void set*(*))” method=“trackChange”/>
</aop:aspect>
</aop:config>
<bean id=“propertyChangeTracker” class=“example.PropertyChangeTracker” />
• XML configuration uses the aop namespace

184
•
•
•
•
•
•
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
–
–
–
–
Named Pointcuts
Context selecting pointcuts
Working with annotations
Limitations of Spring AOP

185
• Allow to reuse and combine pointcuts
@Aspect
@Before(“serviceMethod() || repositoryMethod()”)
public void monitor() {
logger.info(“A business method has been accessed…”);
}
@Pointcut(“execution(* rewards.service..*Service.*(..))”)
public void serviceMethod() {}
@Pointcut(“execution(* rewards.repository..*Repository.*(..))”)
public void repositoryMethod() {}
}
Named pointcuts

186
}
}
Named pointcuts
• Expressions can be externalized
public class SystemArchitecture {
@Pointcut(“execution(* rewards.service..*Service.*(..))”)
public void serviceMethods() {}
}
@Aspect
public class ServiceMethodInvocationMonitor {
@Before(“com.acme.SystemArchitecture.serviceMethods()” )
public void monitor() {
logger.info(“A service method has been accessed…”);
Fully-qualified pointcut name
50

187
• Give the possibility to break one complicated
expression into several sub-expressions
• Allow pointcut expression reusability
• Best practice: consider externalizing expressions
into one dedicated class
– When working with many pointcuts
– When writing complicated expressions
Named pointcuts - Summary

188
•
•
•
•
•
•
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
–
–
–
–
Named Pointcuts

189
Context Selecting Pointcuts
• Pointcuts may also select useful join point
context
–
–
–
–
The currently executing object (proxy)
The target object
Method arguments
Annotations associated with the method, target, or
arguments
• Allows for simple POJO advice methods
– Alternative to working with a JoinPoint object directly
53

190
Context Selecting Example
• Consider this basic requirement
Log a message every time Server is about to start
public interface Server {
public void start(Map input);
public void stop();
}
In the advice, how do we access Server? Map?
54

191
Without context selection
@Before(“execution(void example.Server+.start(java.util.Map))”)
public void logServerStartup(JoinPoint jp) {
Server server = (Server) jp.getTarget();
Object[] args= jp.getArgs();
Map map = (Map) args[0];
…
}
• All needed info must be obtained from the
JoinPoint object

192
With context selection
@Before(“execution(void example.Server+.start(java.util.Map))
&& target(server) && args(input)”)
public void logServerStartup(Server server, Map input) {
…
}
• Best practice: use context selection
– Method attributes are bound automatically
- target(server) selects the target of the execution (your object)
- this(server) would have selected the proxy

193
Context Selection - Named
Pointcut
@Before(“serverStartMethod(server, input)”)
public void logServerStartup(Server server, Map input) {
…
}
@Pointcut(“execution(void example.Server+.start(java.util.Map))
&& target(server) && args(input)”)
public void serverStartMethod (Server server, Map input) {}
57
‘target’ binds the server starting up ‘args’ binds the argument value

194
•
•
•
•
•
•
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
–
–
–
–
Named Pointcuts

195
Pointcut expression examples
using annotations
• execution(
@org.springframework.transaction.annotation.Transactional
void *(..))
– Any method marked with the @Transactional
annotation
• execution( (@example.Tracked *) *(..))
– Any method that returns a value marked with the
@Tracked annotation

196
@Secured(allowedRoles={“teller”,”manager”})
public void waiveFee () {
…
}
60
Example
Requirements:
Run a security check before any @Secured service operation
Security logic depends on:
∉
∉
∉
annotation attribute value – what roles to check?
method name – what method is protected?
the ‘this’ object – Spring AOP proxy being protected

197
AOP and annotations - Example
@Before(“execution(* service..*.*(..)) && target(object) &&
@annotation(secured)””))
public void runCheck(JoinPoint jp, Object object, Secured secured) {
checkPermission(jp, object, secured.allowedRoles());
}
• Use of the annotation() designator

198
AOP and annotations
– Named pointcuts
@Before(“securedMethod(object, secured)””)
public void runCheck(JoinPoint jp, Object object, Secured secured) {
checkPermission(jp, object, secured.allowedRoles());
}
@Pointcut((“execution(* service..*.*(..)) && target(object) &&
@annotation(secured)””))
public void securedMethod(Object object, Secured secured) {}

199
•
•
•
•
•
•
Core AOP Concepts
Quick Start
Defining Pointcuts
Implementing Advice
Advanced topics
–
–
–
–
Named Pointcuts

200
• Can only advise public Join Points
• Can only apply aspects to Spring beans
• Some limitations of weaving with proxies
– Spring will add behavior using dynamic proxies if a
Join Point is declared on an interface
– If a Join Point is in a class without an interface,
Spring will revert to using CGLIB for weaving
– When using proxies, if method a() calls method b()
on the same class/interface, advice will never be
executed for method b()

201
Summary
• Aspect Oriented Programming (AOP)
modularizes cross-cutting concerns
• An aspect is a module containing cross-
cutting behavior
– Behavior is implemented as “advice”
– Pointcuts select where advice applies
– Five advice types: Before, AfterThrowing,
AfterReturning, After and Around
• Aspects are defined in Java with
annotations or XML configuration

202
LAB : Advance AOP

203
Data Access Using Spring
• Resource Management :
– Creating Connection Pools
– Acquiring and releasing connections from/to the pool
– Closing connections
– Demarcation of transaction
– Commit or rollback of transaction
– Iterating through ResultSet and creating JavaObjects
– Checking ErrorCodes and mapping exceptions to meaningful messages
– Checking Exception state and mapping it to meaningful messages
All the concerns listed above is a job of application developer.
Spring takes it away from developer.

204
Not Effective - Copy &
Pasting Code
doSomeWork(...) {
try {
get connection
begin transaction
execute SQL
process the result set
commit
}
catch (SQLException e) {
rollback
}throw application exception
} finally {
try {
close connection
}
catch {}
}
Unique
Copied
around
everywhere

205
Spring Features for resource Management
• Declarative transaction management
– Transactional boundaries declared via configuration
– Enforced by a Spring transaction manager
• Automatic connection management
– Connections acquired/released automatically
– No possibility of resource leak
• Intelligent exception handling
– Root cause failures always reported
– Resources always released properly

206
Spring Resource
Management
doSomeWork(..) {
try {
establish connection
begin transaction
execute SQL
commit
}
catch (SQLException) {
rollback
throw application exception
} finally {
try {
close connection
}
catch {}
}
BEFORE

207
After
Spring Resource
Management
@Transactional
doSomeWork(..) {
execute SQL
}

208
Spring Resource Management
Works Everywhere
• Works consistently with all leading data access
technologies
–
–
–
–
–
Java Database Connectivity (JDBC)
JBoss Hibernate
Java Persistence API (JPA)
EclipseLink
Apache iBatis
• In any environment
– Local (standalone app, web app)
– Full-blown JEE container
17

209
Service Repository
TransactionManager DataSource Connection
(input)
findDomainObject(criteria)
select data
domainObject
mapObject(ResultSet)
get connection
new
begin transaction
transaction
A Typical Application invocation sequence

210
Declarative Transaction
Management
• Spring adds the transaction management calls
around your service logic
• You simply declare the transactional policies and
Spring enforces them

211
Setting Transactional Policies
Declaratively
public void invoke(…) {
// your application logic
}
}
Tells Spring to always run this method
in a database transaction
public class ServiceImpl implements ServiceInterface {
@Transactional

212
Spring
TransactionInterceptor
begin commit
TransactionManager
ServiceImpl
Transaction
management
behavior is added
around your code
invoke(input)
You can change
transaction
managers without
affecting your
Application Code
Enforcing Declarative
Transactional Policies
Spring AOP Proxy

213
Effects on Connection
Management
• Connections are managed for you
– Driven by transactional boundaries
– Not the responsibility of application code
– No possibility of connection leak
• Repositories always use the transactional
connection for data access
– Spring provides several ways to ensure this

214
Local Hibernate Configuration
RewardNetworkImpl
Hibernate
AccountRepository
Hibernate
RestaurantRepository JdbcRewardRepository
SessionFactory
Hibernate
TransactionManager
BasicDataSource
LocalSession
FactoryBean
creates

215
Introduction to Spring JDBC
Simplifying JDBC-based data access with Spring
JDBC

216
• Problems with traditional JDBC
– Results in redundant, error prone code
– Leads to poor exception handling
• Spring’s JdbcTemplate
Configuration
Query execution
Working with result sets
Exception handling
• JDBC Namespace
2

217
Redundant, Error Prone Code
public List findByLastName(String lastName) {
List personList = new ArrayList();
Connection conn = null;
String sql = “select first_name, age from PERSON where last_name=?“;
try {
DataSource dataSource = DataSourceUtils.getDataSource();
conn = dataSource.getConnection();
ResultSet rs = ps.executeQuery();
while (rs.next()) {
String firstName = rs.getString(”first_name“);
int age = rs.getInt(“age”);
personList.add(new Person(firstName, lastName, age));
} catch (SQLException e) { /* ??? */ }
finally {
conn.close();
return personList;

218
Redundant, Error Prone Code
String sql = "select first_name, age from PERSON where last_name=?";
try {
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, lastName);
while (rs.next()) {
String firstName = rs.getString(“first_name”);
}
finally {
try {
conn.close();
}
return personList;
}
4
The bold matters - the
rest is boilerplate

219
Exception Handling is poor
String sql = “select first_name, age from PERSON where last_name=?“;
try {
while (rs.next()) {
String firstName = rs.getString(”first_name“);
finally {
conn.close();
return personList;
What can we do?

220
Spring’s JdbcTemplate
• Greatly simplifies use of the JDBC API
– Eliminates repetitive boilerplate code
– Alleviates common causes of bugs
– Handles SQLExceptions properly
• Without sacrificing power
– Provides full access to the standard JDBC constructs

221
Acquisition of the connection
Participation in the transaction
Execution of the statement
Processing of the result set
Handling any exceptions
Release of the connection
JdbcTemplate in a Nutshell
int count = jdbcTemplate.queryForInt(
“SELECT COUNT(*) FROM CUSTOMER””);
All handled
by Spring

222
Creating a JdbcTemplate
• Requires a DataSource
• Create a template once and re-use it
– Do not create one for each use
– Thread safe after construction
JdbcTemplate template = new JdbcTemplate(dataSource);

223
When to use JdbcTemplate
• Useful standalone
– Anytime JDBC is needed
– In utility or test code
– To clean up messy legacy code
• Useful for implementing a repository in
a layered application
– Also known as a data access object (DAO)

224
Implementing a JDBC-based
Repository
public class AccountRepositoryImpl implements AccountRepository {
private JdbcTemplate jdbcTemplate;
public AccountRepositoryImpl (JdbcTemplate template) {
public int getAccountCount() {
String sql = “select count(*) from Accounts”;
return jdbcTemplate.queryForInt(sql);
}
this.jdbcTemplate = template;
}
DI in config file

225
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${oracleDriver}" />
<property name="url" value="${oracleURL}" />
<property name="username" value="${oracleUser}" />
<property name="password" value="${oraclePassword}"></property>
</bean>
<bean class="bank.server.internal.AccountRepositoryImpl" >
<constructor-arg name="dataSource" ref="dataSource" />
<constructor-arg name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" >
<constructor-arg name="dataSource" ref="dataSource" />
</bean>
JdbcTemplate Mapping in Config File

226
Querying with JdbcTemplate
• JdbcTemplate can query for
– types (int, long, String)
– Generic Maps
– Domain Objects

227
Querying for Simple Java
Types (1)
• Query with no bind variables
public int getPersonCount() {
String sql = “select count(*) from PERSON”;
return jdbcTemplate.queryForInt(sql);

228
Querying With JdbcTemplate
• Query with a bind variable
– Note the use of a variable argument list
private JdbcTemplate jdbcTemplate;
public int getCountOfPersonsOlderThan(int age) {
return jdbcTemplate.queryForInt(
“select count(*) from PERSON where age > ?”, age);
No need for new Object[] { new Integer(age) }

229
Generic Queries
• JdbcTemplate can return each row of a ResultSet
as a Map
• When expecting a single row
– Use queryForMap(..)
• When expecting multiple rows
– Use queryForList(..)
• Useful for reporting, testing

230
Querying for Generic Maps
(1)
• Query for a single row
• returns:
Map { ID=1, FIRST_NAME=“John”, LAST_NAME=“Doe” }
public Map getPersonInfo(int id) {
String sql = “select * from PERSON where id=?”;
return jdbcTemplate.queryForMap(sql, id);
}
A Map of [Column Name | Field Value ] pairs

231
Querying for Generic Maps
(2)
• Query for multiple rows
• returns:
List {
0 - Map { ID=1, FIRST_NAME=“Vivek”, LAST_NAME=“Kulkarni” }
1 - Map { ID=2, FIRST_NAME=“Ram”, LAST_NAME=“Joshi” }
2 - Map { ID=3, FIRST_NAME=“Subhash”, LAST_NAME=“Bose” }
}
public List getAllPersonInfo() {
String sql = “select * from PERSON”;
return jdbcTemplate.queryForList(sql);
A List of Maps of [Column Name | Field Value ] pairs

3.0

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (16)

Similar to 3.0

Similar to 3.0 (20)

Recently uploaded

Recently uploaded (20)

3.0