Spring

Atul Kahate

Spring Framework

Atul Kahate

[email protected]

www.atulkahate.com

What is Spring?� Open source framework created by Rod Johnson

� Created to ease the development of complex (enterprise) application development

� Makes the usage of plain JavaBeans possible where EJBs were used earlierused earlier

� POJO-based development

� Modular in nature

2 Spring | Atul Kahate

Fernandes Clara

framework

Fernandes Clara

POJO-

Fernandes Clara

Modular

Spring Features� Lightweight – Small in size (2.5 MB JAR file), very little overheads in programming, Non-intrusive (no dependence on Spring-specific classes)

� Dependency Injection (DI) – Objects are passively provided with their dependencies, rather than they having to actively search for them (JNDI in the reverse)

� Aspect-Oriented Programming (AOP) – Separate business logic � Aspect-Oriented Programming (AOP) – Separate business logic from generic services, such as security, transaction management, etc

� Container –Takes care of lifecycle and configuration of applications

� Framework – Possible to configure complex applications from simple components with heavy usage of XML


Fernandes Clara

Lightweight

Fernandes Clara

Dependency

Fernandes Clara

Oriented

Fernandes Clara

Container

Fernandes Clara

Framework

Fernandes Clara

lifecycle

Fernandes Clara

applications

Fernandes Clara

heavy

Fernandes Clara

usage of XML

Fernandes Clara

� Container –Takes care of lifecycle and configuration of applications

Spring Modules


Core Container� Defines how beans are created, configured, and managed

� Contains the BeanFactory, which is the basis for the DI concept


Fernandes Clara

created,

Fernandes Clara

configured,

Fernandes Clara

managed

Fernandes Clara

BeanFactory,

Fernandes Clara

DI

Fernandes Clara

beans

Fernandes Clara

Container

Application Context Module� Builds on the core container

� Makes spring a framework

� Extends the concept of BeanFactory, adding support for internationalization, application lifecycle events, and validationvalidation

� Supplies services such as email, JNDI access, EJB access, remoting, etc


Fernandes Clara

Builds

Fernandes Clara

container

Fernandes Clara

framework

Fernandes Clara

internationalization,

Fernandes Clara

BeanFactory,

Fernandes Clara

application

Fernandes Clara

lifecycle

Fernandes Clara

events,

Fernandes Clara

validation

Fernandes Clara

email,

Fernandes Clara

access,

AOP Module� Serves as the basis for developing our own aspects for Spring applications

� Supports loose coupling of application objects

� Application-wide concerns such as transactions and security are decoupled from the objects to which they are appliedare decoupled from the objects to which they are applied


Fernandes Clara

Serves

Fernandes Clara

loose

Fernandes Clara

coupling

Fernandes Clara

application

Fernandes Clara

transactions

Fernandes Clara

security

JDBC Abstraction and DAO Module� JDBC coding involves opening of connection, processing result sets, and closing connection

� This Spring module abstracts away this code to make our code simple

� Issues such as not closing database connections etc are taken � Issues such as not closing database connections etc are taken care of

� Provides a layer of abstraction to make database errors more meaningful

� Uses AOP module to provide transaction services


Fernandes Clara

connection,

Fernandes Clara

sets,

Fernandes Clara

closing

Fernandes Clara

errors

Fernandes Clara

module

Fernandes Clara

transaction

Fernandes Clara

not

Object-Relational Mapping (ORM)

Integration Module

� Can be used as an alternative to JDBC

� Built over the DAO support for several ORM solutions, such as Hibernate, Java Persistence API, iBatis, Java Data Objects, etc


Fernandes Clara

Persistence

Fernandes Clara

ORM

Java Management Extensions (JMX)

� Allows exposing our application’s beans as JMX beans

� Allows monitoring and reconfiguring a running application


Fernandes Clara

application’s

Fernandes Clara

beans

Fernandes Clara

JMX

Fernandes Clara

monitoring

Fernandes Clara

reconfiguring

Java EE Connector API (JCA)� JCA provides a standard way of integrating Java applications with Mainframes, various databases, etc

� Spring provides a layer on top of JCA


Fernandes Clara

JCA)

Fernandes Clara

integrating

Fernandes Clara

Mainframes,

Fernandes Clara

databases,

Fernandes Clara

JCA

Fernandes Clara

layer

Fernandes Clara

top

Spring MVC Framework� Spring can either integrate with an MVC framework such as Struts, JSF etc; and has its own MVC framework


Spring Portlet MVC� Normal Web applications are request-response based

� Portlets are applications that aggregate information on to a single page, so that the request-response overhead is reduced

� Spring provides support for these kinds of applications


Fernandes Clara

request-

Fernandes Clara

response

Fernandes Clara

overhead

Fernandes Clara

aggregate

Fernandes Clara

information

Fernandes Clara

single

NetBeans package beanname

Defining Beans in Spring

NetBeans package beanname

Spring | Atul Kahate14

Usage of configuration files� In Spring, all beans need to be declared in a configuration file

� This avoids hard coding of class creation code in our applications

� This code is moved to a single location – the XML configuration file


configuration file

� Implementations can be changed without any changes to our source code

� Note: The current example will not do anything useful!

Fernandes Clara

all beans

Fernandes Clara

configuration

Fernandes Clara

single location

Fernandes Clara

without

Fernandes Clara

changed

beans3.xml<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>


<beans>

<bean id="string1" class="java.lang.String"/>

<bean name="string2" class="java.lang.String"/>

<bean class="java.lang.String"/>

</beans>

BeanNaming.javapackage com.spring.beanname;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;

public class BeanNaming {


public static void main(String[] args) {

BeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans3.xml"));

String s1 = (String)factory.getBean("string1");

String s2 = (String)factory.getBean("string2");

String s3 = (String)factory.getBean("java.lang.String");

}

}

Fernandes Clara

core.io.FileSystemResource;

BeanFatcory� The core of Spring's design is the org.springframework.beanspackage, designed for use with JavaBean components.

� The next-highest layer of abstraction is the BeanFactory interface, an implementation of the Factory design pattern that enables objects to be created and retrieved by name. BeanFactory can also manage relationships between objects.

� BeanFactory supports two object modes.


� BeanFactory supports two object modes.� Singleton mode provides a shared instance of the object with a particular name, which will be retrieved on lookup. Singleton is the default and most often used object mode. It is ideal for stateless service objects.

� Prototype mode ensures that each retrieval will result in the creation of an independent object. Prototype mode would be best used in a case where each user needed to have his or her own object.

Fernandes Clara

org.springframework.beans

Fernandes Clara

JavaBean

Fernandes Clara

BeanFactory

Fernandes Clara

interface,

Fernandes Clara

Factory

Fernandes Clara

design

Fernandes Clara

pattern

Fernandes Clara

created

Fernandes Clara

retrieved

Fernandes Clara

name.

Fernandes Clara

relationships

Fernandes Clara

modes.

Fernandes Clara

Singleton

Fernandes Clara

Prototype

Fernandes Clara

shared

Fernandes Clara

instance

Fernandes Clara

retrieved

Fernandes Clara

lookup.

Fernandes Clara

name,

Fernandes Clara

stateless

Fernandes Clara

retrieval

Fernandes Clara

each

Fernandes Clara

result

Fernandes Clara

creation

Fernandes Clara

each

Fernandes Clara

independent

Fernandes Clara

object.

Fernandes Clara

user

Fernandes Clara

own

BeanFactory Interface� org.springframework.beans.factory.BeanFactory is a simple interface that can be

implemented for a range of underlying storage methods. The most commonly used BeanFactory definition is the XmlBeanFactory, which loads beans based on definitions in an XML file

BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));

� Beans defined in XML files are lazily loaded, which means that the beans themselves will


� Beans defined in XML files are lazily loaded, which means that the beans themselves will not be instantiated until they are needed. To retrieve a bean from BeanFactory we can simply call the getBean() method passing in the name of the bean we want to retrieve:

MyBean mybean = (MyBean) factory.getBean("mybean");

� Each bean definition can be a POJO (defined by class name and JavaBean initialization properties) or a FactoryBean. The FactoryBean interface adds a level of indirection to the applications built using the Spring framework.

Fernandes Clara

underlying

Fernandes Clara

storage

Fernandes Clara

methods.

Fernandes Clara

getBean()

Fernandes Clara

retrieve

Fernandes Clara

POJO

Fernandes Clara

interface

Fernandes Clara

XmlBeanFactory,

Fernandes Clara

beans

Fernandes Clara

definitions

Fernandes Clara

XML

Fernandes Clara

level

Fernandes Clara

indirection

D:\Atul\Lectures\SICSR\Web Technologies\WT-

Hello World in Spring

D:\Atul\Lectures\SICSR\Web Technologies\WT-2\spring\Spring-examples-sicsr

Requirements� We need a service class

� This simply means the class that has our business logic

� To decouple the actual business logic from the caller, we can also have an interface that would be implemented by the service classservice class� The caller would program to the interface to create a loosely coupled logic

� We also need the tester class to test our service class

� Finally, we need an XML file for configuration


Fernandes Clara

service

Fernandes Clara

business

Fernandes Clara

business

Fernandes Clara

interface

Fernandes Clara

service

Fernandes Clara

interface

Fernandes Clara

coupled

Fernandes Clara

tester

Fernandes Clara

test

Fernandes Clara

service

Fernandes Clara

XML

Hello World Depicted

Tester class (HelloApp.java)

Service interface (GreetingService.java)

Service class (GreetingServiceImpl.java)

Configuration(hello.xml)


Hello World Depicted

Tester class (HelloApp.java)

public class HelloApp {

public static void main (String [] args) throws Exception {

BeanFactory factory = new XmlBeanFactory (new FileSystemResource ("hello.xml"));FileSystemResource ("hello.xml"));

GreetingService greetingService = (GreetingService) factory.getBean ("greetingService");

greetingService.sayGreeting();}

}

<?xml version="1.0”?>

<beans><bean id="greetingService"

class="com.spring.hello.GreetingServiceImpl">

<property name="greeting" value="Hello World!" />

</bean></beans>

Configuration (hello.xml)


Understanding Tester Class – 1� BeanFactory factory = new XmlBeanFactory (new FileSystemResource ("hello.xml"));� Tester class uses the BeanFactory, which is the Spring container� Here, we are asking the Spring container to load a file named hello.xml into the container’s memory

� The hello.xml file contains this:� The hello.xml file contains this:<bean id="greetingService" class="com.spring.hello.GreetingServiceImpl">


</bean>

� Indicates that some time later we want to (1) instantiate an object of the GreetingServiceImpl class by the name greetingService, and (2) call its setGreeting method, passing the value Hello World

� See next slide


Fernandes Clara

Spring

Fernandes Clara

container

Fernandes Clara

container’s

Fernandes Clara

memory

Understanding Tester Class – 2� Code

GreetingService greetingService = (GreetingService) factory.getBean("greetingService");

� XML file<bean id="greetingService" class="com.spring.hello.GreetingServiceImpl">

<property name="greeting" value="Hello World!" /><property name="greeting" value="Hello World!" /></bean>

� Now, these two are linked and our code obtains an instance of the GreetingServiceImpl class in the form of a greetingService object

� See next slide


Understanding Tester Class – 3� The following are thus equivalent:

<bean id="greetingService" class="com.spring.hello.GreetingServiceImpl">


</bean>

� ANDGreetingServiceImpl greetingService = new GreetingServiceImpl ();

greetingService.setGreeting (“Hello World!”);

� First is Spring-way of coding, the second is the traditional method


Understanding Tester Class – 3� greetingService.sayGreeting();

� We now call the sayGreeting method on the greetingService object


Understanding Dependency Injection

(DI)� Look at our XML file definition once again:

<bean id="greetingService" class="com.spring.hello.GreetingServiceImpl"><property name="greeting" value="Hello World!" />

</bean>

� We are injecting/feeding our bean with the desired value for the greeting propertythe greeting property� Traditionally, our bean needs to figure this out itself, not any more

� This is called as Dependency Injection (DI)� DI was originally called as Inversion of Control (IOC)

� “Acquisition of dependencies” gets inverted� Hence, IOC was renamed to DI


Fernandes Clara

injecting/

Fernandes Clara

greeting

Fernandes Clara

desired

Fernandes Clara

Injection

Why DI?� Objects are provided their dependencies at creation time by some external entity that coordinates each entity in the application

� Helps in making the application loosely coupled

� If an object knows about its dependencies by the interfaces of � If an object knows about its dependencies by the interfaces of the dependencies (not based on their implementation or on how they were created), then the dependency implementation can be changed without the depending object knowing about it


Fernandes Clara

provided

Fernandes Clara

Objects

Fernandes Clara

dependencies

Fernandes Clara

creation

Fernandes Clara

external

Fernandes Clara

coordinates

Fernandes Clara

entity

Fernandes Clara

application

Fernandes Clara

application

Fernandes Clara

loosely

Fernandes Clara

coupled

Fernandes Clara

object

Fernandes Clara

dependencies

Fernandes Clara

interfaces

GreetingService.java� /*� * To change this template, choose Tools | Templates� * and open the template in the editor.� */

� package com.spring.hello;

� /**� *� * @author atulk� */� public interface GreetingService { � void sayGreeting ();� }


GreetingServiceImpl.java� /*

� * To change this template, choose Tools | Templates

� * and open the template in the editor.

� */


� /**

� *

� * @author atulk

� */

� public class GreetingServiceImpl implements GreetingService {

�

� private String greeting;

�

� public GreetingServiceImpl () {}

�

� public GreetingServiceImpl (String greeting) {

� this.greeting = greeting;

� }

�

� public void sayGreeting () {

� System.out.println (greeting);

� }

�

� public void setGreeting (String greeting) {

� this.greeting = greeting;

� }

� }


hello.xml� <?xml version="1.0" encoding="UTF-8"?>

� 

� <beans xmlns="http://www.springframework.org/schema/beans"

� xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

� xsi:schemaLocation="http://www.springframework.org/schema/beans

� http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

�

� <bean id="greetingService" class="com.spring.hello.GreetingServiceImpl">

� <property name="greeting" value="Hello World!" />

� </bean>

� </beans>


Fernandes Clara

<beans xmlns="http://www.springframework.org/schema/beans" � xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" � xsi:schemaLocation="http://www.springframework.org/schema/beans � http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

HelloApp.java� /*



� */


� import org.springframework.beans.factory.BeanFactory;

� import org.springframework.beans.factory.xml.XmlBeanFactory;

� import org.springframework.core.io.FileSystemResource;

� /**

*� *

� * @author atulk

� */

� public class HelloApp {

�

� public static void main (String [] args) throws Exception {

�

� BeanFactory factory = new XmlBeanFactory (new FileSystemResource ("hello.xml"));

�

� GreetingService greetingService = (GreetingService) factory.getBean ("greetingService");

�

� greetingService.sayGreeting();

� }

� }


package com.spring.simpleinterestcalculator

Another Example – Simple Interest

Calculation

package com.spring.simpleinterestcalculator


SimpleInterestCalculatorBean.java� * To change this template, choose Tools | Templates


� */

� package com.spring.simpleinterestcalculator ;

� /**

� *

� * @author atulk

� */

� class SimpleInterestCalculatorBean {

� private float years;

� private float principle;

� private float rate;

� SimpleInterestCalculatorBean() {

� }

� public void setYears(float years) {

� this.years = years;


� this.years = years;

� }

� public float getYears() {

� return years;

� }

� public void setPrinciple(float principle) {

� this.principle = principle;

� }

� public float getPrinciple() {

� return principle;

� }

� public void setRate(float rate) {

� this.rate = rate;

� }

� public float calculate() {

� return (float) ((principle * rate * years) / 100);

� }

� public float getInterest() {

� return calculate();

� }

beans6.xml� <?xml version = "1.0" ?>

� <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

� <beans>

� <bean id="SimpleInterestBean" class="com.spring.simpleinterestcalculator.SimpleInterestCalculatorBean">

� <property name="principle">


� <property name="principle">

� <value>10000.00</value>

� </property>

� <property name="years">


� </property>

� <property name="rate">


� </property>

� </bean>

� </beans>

Client.java� /*



� */

� package com.spring.simpleinterestcalculator;

� /**

� *

� * @author atulk

� */

� import java.io.*;

� import org.springframework.beans.factory.*;

� import org.springframework.beans.factory.xml.*;

� import org.springframework.core.io.*;

� public class Client {


� public static void main(String args[]) throws Exception {

� try {

� System.out.println("Starting interest calculator ...");

�

� BeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans6.xml"));

�

� SimpleInterestCalculatorBean interest =

� (SimpleInterestCalculatorBean) factory.getBean("SimpleInterestBean");

�

� System.out.println(interest.getInterest());

� }

� catch(Exception e1) {

� System.out.println("" + e1);

� }

� }

� }

NetBeans: Spring-IOC-Example

Example of Traditional Coding Versus

Spring-style of Coding

NetBeans: Spring-IOC-Example


Requirement� We want to create a list of bank accounts, and then simply display the details of all of them


Version 1 of the Code� Create an Account class, which will hold information about the various accounts, such as account number, accountholder’s name, opening balance, etc

� Another class AccountMaster would create as many accounts as we require in a hashmap


we require in a hashmap

� The Tester class tests the functionality by displaying information about all accounts

Version 1� /*



� */

� package com.example.version.one;

� /**

� *

� * @author atulk

� */

� public class Account {

�

� private String accountNumber;

� private String accountName;

� private int openingBalance;

� private int currentBalance;

� public Account(String accountNumber, String accountName, int openingBalance, int currentBalance) {

� this.accountNumber = accountNumber;

� this.accountName = accountName;

� this.openingBalance = openingBalance;


� this.currentBalance = currentBalance;

� }

�

� public String toString () {

� return "Bank: " +

� " Account number -- " + accountNumber +

� " Account Name -- " + accountName +

� " Opening Balance -- " + openingBalance +

� " Current Balance -- " + currentBalance +

� ".\n";

� }

� public String getAccountName() {

� return accountName;

� }

� public void setAccountName(String accountName) {


� }

� public String getAccountNumber() {

� return accountNumber;

� }

� public void setAccountNumber(String accountNumber) {


� }

� public int getCurrentBalance() {

� return currentBalance;

� }

� public void setCurrentBalance(int currentBalance) {


� }

� public int getOpeningBalance() {

Version 1� /*



� */


� import java.util.HashMap;

� import java.util.Iterator;

� /**

� *

� * @author atulk

� */

� public class AccountMaster {

� private String bankName;

� HashMap accounts = new HashMap ();

� public AccountMaster(String bankName) {

� this.bankName = bankName;

�

� System.out.println ("Bank name set to: " + this.bankName);


�

� accounts.put ("100", new Account("1000", "test account 1", 1000, 10000));






�

� System.out.println ("Exiting the constructor of GetAccount ...");

� }

�


� return "This is for Bank: " + bankName;

� }

�

� public HashMap findAccounts () {

� return accounts;

� }

�

� public Account findAccount (String accountNumber) {

� Iterator iter = accounts.values().iterator();

�

� while (iter.hasNext()) {

� Account account = (Account) iter.next();

� if (accountNumber.equals(account.getAcco untNumber()))

� return account;

� }

�

� return null;

� }

� }

Version 1� /*



� */



� /**

� *

� * @author atulk

� */

� public class Tester {

�

� private AccountMaster findAccount;


�

� public Tester () {

� System.out.println ("1");

� findAccount = new AccountMaster ("My Bank");

� System.out.println ("2");

�

� }

�

� public void printAllAccounts () {

� System.out.println (findAccount.toString());

� Iterator iter = findAccount.findAccounts().values().iterator();



� System.out.println (account.toString());

� }

� }

�

� public static final void main (String args []) {

� Tester tester = new Tester ();

� System.out.println ("After Tester");

� tester.printAllAccounts();

� }

� }

Version 2 of the Code� Account class – No change

� AccountMaster class – Is now an interface, instead of being a concrete class

� HashMapAccountMaster class – Implements AccountMasterinterface


interface

� OldTester – New class, which takes on the functionality of the earlier Tester class

� Tester – Modified to work with OldTester and AccountMasterclasses

Version 2� /*



� */

� package com.example.version.two;

� /**

� *

� * @author atulk

� */


�











� }

�







� ".\n";

� }



� }



� }



� }



� }



� }



� }


Version 2� /*



� */




� /**

� *

� * @author atulk

� */

� public interface AccountMaster {

� HashMap getAccounts ();

� public Account getAccount (String accountNumber);

� }

Version 2� /*



� */




� /**

� *

� * @author atulk

� */

� public class HashMapAccountMaster implements AccountMaster {

�


� HashMap accounts = new HashMap ();

� public HashMapAccountMaster(String bankName) {


�


� System.out.println ("Bank name set to: " + this.bankName);

�







�

� System.out.println ("Exiting the constructor of GetAccount ...");

� }

�



� }

�

� public HashMap getAccounts () {


� }

�

� public Account getAccount (String accountNumber) {


�




� return account;

� }

�

� return null;

� }

� }

Version 2� /*



� */



� /**

� *

� * @author atulk

� */

� public class OldTester {

�

� private AccountMaster accountMaster;


�

� public OldTester () {

� }

�

� public void setAccountMaster (AccountMaster accountMaster) {

� this.accountMaster = accountMaster;

� }

�

� public AccountMaster getAccountMaster () {

� return this.accountMaster;

� }

�


� System.out.println (accountMaster.toString());

� Iterator iter = accountMaster.getAccounts().values().iterator();




� }

� }

� }

Version 2� /*



� */


� /**

� *

� * @author atulk


� */


� public static final void main(String args[]) {

� OldTester oldTester = new OldTester();

� AccountMaster accountMaster = new HashMapAccountMaster("My Bank");

� oldTester.setAccountMaster(accountMaster);

� oldTester.printAllAccounts();

� }

� }

Version 3 of the Code� Using Spring

� Account class – No change

� AccountMaster class – No change

� HashMapAccountMaster class – No change

� OldTester class – No change


� OldTester class – No change

� Tester class – Makes use of BeanFactory now

Version 3� /*



� */

� package com.example.version.three;

� /**

� *

� * @author atulk

� */


�











� }

�







� ".\n";

� }



� }



� }



� }



� }



� }



� }


Version 3� /*



� */




� /**

� *

� * @author atulk

� */

� public interface AccountMaster {

� HashMap getAccounts ();

� public Account getAccount (String accountNumber);

� }

Version 3� /*



� */




� /**

� *

� * @author atulk

� */

� public class HashMapAccountMaster implements AccountMaster {

�


� private HashMap accounts = new HashMap ();

�

� public HashMapAccountMaster (String bankName) {

� System.out.println ("inside ...");

�


� populateAccounts ();

� }

�



� }

�

� public HashMap getAccounts () {


� }

�

� public Account getAccount (String accountNumber) {


�




� return account;

� }

�

� return null;

� }

�

� public String getBankName () {

� return bankName;

� }

�

� public void setBankName (String bankName) {


� }

�

� public void populateAccounts () {

� System.out.println ("initializing hashmap");





Version 3� /*



� */



� /**

� *

� * @author atulk

*/


� */

� public class OldTester {

�

� private AccountMaster accountMaster;

�

� public OldTester () {

� }

�

� public void setAccountMaster (AccountMaster accountMaster) {

� this.accountMaster = accountMaster;

� }

�

� public AccountMaster getAccountMaster () {

� return this.accountMaster;

� }

�


� System.out.println (accountMaster.toString());

� Iterator iter = accountMaster.getAccounts().values().iterator();




Version 3� /*



� */





� /**

� *


� *

� * @author atulk

� */


� public static final void main(String args[]) {

�

� BeanFactory factory = new XmlBeanFactory (new FileSystemResource ("beans.xml"));

�

� OldTester oldTester = (OldTester) factory.getBean ("oldTester");

�

� oldTester.printAllAccounts();

� }

� }

Version 3� // Beans.xml

� <?xml version="1.0" encoding="UTF-8"?>

� 







�

� <bean id="accountMaster"

� class="com.example.version.three.HashMapAccountMaster">

� <constructor-arg><value>My Bank</value></constructor-arg>

� </bean>

�

� <bean id="oldTester"

� class="com.example.version.three.OldTester">

� <property name="accountMaster"><ref bean="accountMaster" /></property>

� </bean>

� </beans>

Package com.spring.forex

Forex Rates Example

Package com.spring.forex


ForexData.java� /*



� */

� package com.spring.forex;

� /**

� *

� * @author atulk

� */

� public class ForexData {

�

� private String fromCurrency;

� private String toCurrency;

� private float rate;

� public String getFromCurrency() {

� return fromCurrency;

� }

� public void setFromCurrency(String fromCurrency) {


� this.fromCurrency = fromCurrency;

� }

� public float getRate() {

� return rate;

� }

� public void setRate(float rate) {

� this.rate = rate;

� }

� public String getToCurrency() {

� return toCurrency;

� }

� public void setToCurrency(String toCurrency) {

� this.toCurrency = toCurrency;

� }

�

� public double getExchangeRate () {

�

� if (fromCurrency.equals ("USD") && toCurrency.equals ("INR")) {

� return 39.50;

� }

� else if (fromCurrency.equals ("INR") && toCurrency.equals ("USD")) {

� return 1 / 39.50;

� }

�

� // default

� return -99.99;

� }

� }

beans7.xml� <?xml version = "1.0" ?>


� <beans>� <bean id="ForexData" class="com.spring.forex.ForexData">


� <property name="fromCurrency">� <value>USD</value>� </property>� <property name="toCurrency">� <value>INR</value>� </property>� </bean>� </beans>

Client.java� /*



� */

� package com.spring.forex;

� /*



� */








� try {

� System.out.println("Starting interest calculator ...");

�


�

� ForexData forexData =

� (ForexData) factory.getBean("ForexData");

�

� System.out.println("Exchange rate between " + forexData.getFromCurrency() +

� " and " + forexData.getToCurrency() + " is " + forexData.getExchangeRate());

� }

� catch(Exception e1) {

� System.out.println("" + e1);

� }

� }

� }

NetBeans Spring-examples-sicsr

Department and Employee Example

NetBeans Spring-examples-sicsr

Package com.spring.deptandemp


Department.java� /*



� */

� package com.spring.deptandemp;

� /**

� *

� * @author AtulK

� */

� public class Department {

�

� String deptID;

� String deptName;

� Employee employee;

� public String getDeptID() {

� return deptID;

� }

� public void setDeptID(String deptID) {


� this.deptID = deptID;

� }

� public String getDeptName() {

� return deptName;

� }

� public void setDeptName(String deptName) {

� this.deptName = deptName;

� }

� public Employee getEmployee() {

� return employee;

� }

� public void setEmployee(Employee employee) {

� this.employee = employee;

� }

� public Department(String deptID, String deptName, Employee employee) {

� this.deptID = deptID;

� this.deptName = deptName;

� this.employee = employee;

� }

� public Department() {

� }

�

�

�

�

� }

Employee.java� /*



� */


� /**

� *

� * @author AtulK

� */

� public class Employee {

� private String empID;

� private String empName;

� private int salary;

� public String getEmpID() {

� return empID;

� }


� }

� public void setEmpID(String empID) {

� this.empID = empID;

� }

� public String getEmpName() {

� return empName;

� }

� public void setEmpName(String empName) {

� this.empName = empName;

� }

� public int getSalary() {

� return salary;

� }

� public void setSalary(int salary) {

� this.salary = salary;

� }

� public Employee() {

� }

� }

Tester.java� /*



� */


� /*



� */








� try {

� System.out.println("Starting department and employee application ...");

�


�

� Department department =

� (Department) factory.getBean("departmentBean");

�

� System.out.println("Department " + department.getDeptName()+ " has employee " +

� department.employee.getEmpName());

� }

� catch(Exception e) {

� System.out.println("Exception occurred!!! " + e);

� }

� }

� }

beans10.xml� <?xml version="1.0" encoding="UTF-8"?>





�

� <bean id="employeeBean"

� class="com.spring.deptandemp.Employee">

� <property name = "empID">

� <value>999</value>

� </property>

�

� <property name = "empName">

� <value>My Employee Name</value>

� </property>


�

� <property name = "salary">


� </property>

� </bean>

�

� <bean id="departmentBean"

� class="com.spring.deptandemp.Department">

� <property name = "deptID">


� </property>

�

� <property name = "deptName">

� <value>My Department</value>

� </property>

�

� <property name = "employee">

� <ref bean = "employeeBean"></ref>

� </property>

� </bean>

�

� </beans>

Passing one object to another as a DI

DI in detail

Passing one object to another as a DI

NetBeans package com.spring.hello.di

Real-life DI� In real-life DI, we pass the object of one class to another object of a different class as a DI

� This way, if A is passed to B, B does not need to worry about how A was created, etc

� A’s implementation can be changed freely from a simple bean � A’s implementation can be changed freely from a simple bean to an EJB to a Web service etc

� Again, this can be done by using simple configurations in an XML file


Fernandes Clara

object

Fernandes Clara

one

Fernandes Clara

another

Fernandes Clara

different

Fernandes Clara

class

Fernandes Clara

DI

Fernandes Clara

implementation

Fernandes Clara

changed

Fernandes Clara

freely

Fernandes Clara

simple

Fernandes Clara

simple

Fernandes Clara

configurations

Understanding the example

Model class (provider)

View class (renderer)

injected into

<beans><bean id="provider" class="HelloWorldModel"><constructor-arg><value>This is a configurable message</value><value>This is a configurable message</value>

</constructor-arg></bean>

<bean id="renderer" class="StandardOutView"><property name="model"><ref local="provider"/>

</property></bean>

</beans>


Our Model� Model.java (Interface)

public interface Model {public String getMessage();}

� HelloWorldModel.java (Implementation)

public class HelloWorldModel implements Model {String mess;String mess;

public HelloWorldModel(String m){mess = m;

}

public String getMessage() {return mess;

}}


Our View� View.java (Interface)

public interface View {public void render();

public void setModel(Model m);public Model getModel();

}

� StandardOutView.java (Implementation)

public class StandardOutView implements View {private Model model = null;

public void render() {if (model == null) {throw new RuntimeException(

"You must set the property model of class:"+ StandardOutView.class.getName());

}System.out.println(model.getMessage());

}

public void setModel(Model m) {this.model = m;

}

public Model getModel() {return this.model;

}

}


Fernandes Clara

� StandardOutView.java (Implementation) public class StandardOutView implements View { private Model model = null; public void render() { if (model == null) { throw new RuntimeException( "You must set the property model of class:" + StandardOutView.class.getName()); }

Fernandes Clara

public void setModel(Model m); public Model getModel();

Our XML configuration file� Beans.xml

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans><bean id="provider" class="HelloWorldModel"><constructor-arg><constructor-arg><value>This is a configurable message</value>

</constructor-arg></bean>

<bean id="renderer" class="StandardOutView"><property name="model"><ref local="provider"/>

</property></bean>

</beans>


Our Client Code� HelloWorldXmlWithDI.java

import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFactory;import org.springframework.core.io.FileSystemResource;

public class HelloWorldXmlWithDI {

public static void main(String[] args) throws Exception {public static void main(String[] args) throws Exception {BeanFactory factory = getBeanFactory();View mr = (View) factory.getBean("renderer");mr.render();

}

private static BeanFactory getBeanFactory() throws Exception {BeanFactory factory = new XmlBeanFactory(new FileSystemResource(

”beans.xml"));return factory;

}}


NetBeans package com.spring.simpleinjectbydi

Injecting by DI Example

NetBeans package com.spring.simpleinjectbydi


ClientTester.java

public class ClientTester {

private String name;private int age;…

public static void main(String[] args) {BeanFactory factory = new XmlBeanFactory(new FileSystemResource(“beans2.xml"));ClientTester simple = (ClientTester)factory.getBean("clientTester");factory.getBean("injectRef");System.out.println(simple);

}// set methods for all attributes of this class


// set methods for all attributes of this class}

beans2. xml

<bean id="clientTester" class="com.spring.simpleinjectbydi.ClientTester"><property name="name"><value>Kishore Kumar</value>

</property>…

</bean>

ClientTester.java


private String name;private int age;…

public static void main(String[] args) {BeanFactory factory = new XmlBeanFactory(new FileSystemResource(“beans2.xml"));ClientTester simple = (ClientTester)factory.getBean("clientTester");factory.getBean("injectRef");System.out.println(simple);

}// set methods for all attributes of this class


// set methods for all attributes of this class}

beans2. xml

<bean id="injectRef" class="com.spring.simpleinjectbydi.InjectRef"><property name="info"><ref local="infobyid"/>

</property></bean>

InjectRef.java

public class InjectRef {

private Info info;

public void setInfo (Info info) {this.info = info;System.out.println(info.getInfo());

}}

InfoImpl.java


public class InfoImpl implements Info {

private Encyclopedia enc;

public void setEncyclopedia(Encyclopedia enc) {this.enc = enc;

}

public String getInfo () {return "Encyclopedia's are a waste of money - use the Internet";

}

}

Info.java

public interface Info {public String getInfo ();

}

InfoImpl.java

public class InfoImpl implements Info {



}


}

}


}

public class Encyclopedia {

}

Encylopedia.java� Deliberately kept empty

public class Encyclopedia {

}


}

Info.javapublic interface Info {

public String getInfo ();

}


InfoImpl.javapublic class InfoImpl implements Info {




this.enc = enc;}


}

}

InjectRef.javapublic class InjectRef {

private Info info;

public void setInfo (Info info) {


public void setInfo (Info info) {

this.info = info;

System.out.println(info.getInfo());

}

}

ClientTester.javaimport org.springframework.beans.factory.BeanFactory;




private String name;

private int age;

private float height;

private boolean isProgrammer;


private boolean isProgrammer;

private Long ageInSeconds;

public static void main(String[] args) {

BeanFactory factory = new XmlBeanFactory(new FileSystemResource(

"beans2.xml"));

ClientTester simple = (ClientTester)factory.getBean("clientTester");

factory.getBean("injectRef");

System.out.println(simple);

}

public void setAgeInSeconds(Long ageInSeconds) {

this.ageInSeconds = ageInSeconds;

}

public void setIsProgrammer(boolean isProgrammer) {

this.isProgrammer = isProgrammer;

}

public void setAge(int age) {

this.age = age;



<beans>



<bean id="clientTester" class="com.spring.simpleinjectbydi.ClientTester">

<property name="name">

<value>Kishore Kumar</value>

</property>

<property name="age">

<value>35</value>

</property>

<property name="height">


<property name="height">

<value>67</value>

</property>

<property name="isProgrammer">

<value>true</value>

</property>

<property name="ageInSeconds">

<value>1103760000</value>

</property>

</bean>



<bean id="infobyid" name="infobyname" class="com.spring.simpleinjectbydi.InfoImpl"/>



<bean id="injectRef" class="com.spring.simpleinjectbydi.InjectRef">

<property name="info">

<ref local="infobyid"/>

</property>

</bean>



Bean Creation


Initializing and Destroying Beans


Bean initialization and destruction� It may be necessary to perform some initialization logic when a bean in instantiated

� Similarly, when a bean is to be destroyed, some clean up operations may be required

� We need to use the init-method and destroy-method parameters


� We need to use the init-method and destroy-method parameters for our bean

� They specify the methods to be called during initialization and destruction, respectively



<beans>

<bean id="simpleBean1" class="com.spring.beaninitdestroy.SimpleBean" init-method="initOurBean" destroy-method="destroyOurBean">


<value>Name overwritten!</value>

</property>


<value>999</value>


</property>

</bean>

<bean id="simpleBean2" class="com.spring.beaninitdestroy.SimpleBean" init-method="initOurBean" destroy-method="destroyOurBean">


<value>999</value>

</property>

</bean>

<bean id="simpleBean3" class="com.spring.beaninitdestroy.SimpleBean" init-method="initOurBean">


<value>Name overwritten!</value>

</property>

</bean>

</beans>

SimpleBean.java/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package com.spring.beaninitdestroy;

import org.springframework.beans.factory.BeanCreationException;

import org.springframework.beans.factory.BeanFactory;



public class SimpleBean {


public class SimpleBean {

private static final String DEFAULT_NAME = "Atul Kahate";

private String name = null;

private int age = Integer.MIN_VALUE;

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

public void initOurBean () {

System.out.println("Initializing bean");

if (name == null) {

System.out.println("Using default name");

name = DEFAULT_NAME;

NetBeans package beanhierarchy

Hierarchical Processing

NetBeans package beanhierarchy


HierarchicalBeanFactoryUsage.java� /*



� */

� package com.spring.beanhierarchy;

� /**

� *

� * @author atulk

� */






� public class HierarchicalBeanFactoryUsage {

� public static void main(String[] args) {

� BeanFactory parent = new XmlBeanFactory(new FileSystemResource(

� "parent.xml"));

� BeanFactory child = new XmlBeanFactory(new FileSystemResource(

� "beans5.xml"), parent);

� SimpleTarget target1 = (SimpleTarget) child.getBean("target1");



� System.out.println(target1.getVal());



� }

� }

beans5.xml� <?xml version="1.0" encoding="UTF-8"?>


� <beans>

� 

� <bean id="target1" class="com.spring.beanhierarchy.SimpleTarget">

� <property name="val">

� <ref bean="injectBeanParent"/>

� </property>

� </bean>

�


<property name="val">



� <ref local="injectBean"/>

� </property>

� </bean>

�



� <ref parent="injectBean"/>

� </property>

� </bean>

�

� <bean id="injectBean" class="java.lang.String">

� <constructor-arg>

� <value>Bean In Child</value>

� </constructor-arg>

� </bean>

� </beans>

SimpleTarget.java� /*



� */

� package com.spring.beanhierarchy;

� /**

� *

� * @author atulk


� */

� public class SimpleTarget {

� private String val;

�

� public void setVal(String val) {

� this.val = val;

� }

�

� public String getVal() {

� return val;

� }

� }

Specifying Bean Dependencies� The ref element is used to set the value of a property or a constructor argument to be a reference to another bean from the factory, or from a parent factory:� <ref local=“injectBean” />� <ref bean=“injectBean” />� <ref parent=“injectBean” />


� <ref parent=“injectBean” />

� local, bean, and parent are mutually exclusive and must be the ID of another bean – they specify how to locate that referenced bean� local – Referred bean must be in the same XML file – parser validates this� bean - Referred bean can be in the same XML file or in a different XML file –Spring framework validates this

� parent – Referred bean must come from a parent factory to the current one

Understanding the example – 1 � HierarchicalBeanFactoryUsage.java

� BeanFactory parent = new XmlBeanFactory(new FileSystemResource("parent.xml"));� Loads the parent.xml file

� BeanFactory child = new XmlBeanFactory(new


BeanFactory child = new XmlBeanFactory(new FileSystemResource("beans5.xml"), parent);� Loads the beans5.xml file, with parent as its parent factory

Understanding the example – 2� SimpleTarget target1 = (SimpleTarget) child.getBean("target1");

� Definition for this bean in beans5.xml is as follows:� <bean id="target1" class="com.spring.beanhierarchy.SimpleTarget">� <property name="val">� <ref bean="injectBeanParent"/>� </property>� </bean>


</bean>� Indicates that injectBeanParent should be passed to it as a parameter� Definition of injectBeanParent in parent.xml is as follows:

� <bean id="injectBeanParent" class="java.lang.String">� <constructor-arg>� <value>Bean In Parent</value>� </constructor-arg>� </bean>

� Hence, a string Bean In Parent would be passed to the target1 bean


� Definition for this bean in beans5.xml is as follows:� <bean id="target2" class="com.spring.beanhierarchy.SimpleTarget">� <property name="val">� <ref local="injectBean"/>� </property>� </bean>

� Indicates that injectBean should be passed to it as a parameter


Indicates that injectBean should be passed to it as a parameter� Definition of injectBean is defined in the same XML file:

� <bean id="injectBean" class="java.lang.String">� <constructor-arg>� <value>Bean In Child</value>� </constructor-arg>� </bean>

� Hence, a string Bean In Child would be passed to the target1 bean� Note: injectBean is also defined in parent.xml. But it would be ignored, as we

have specified injectBean also in the local file (beans5.xml) and we have used ref local in the target2 definition

Understanding the example – 4� Note: injectBean is also defined in parent.xml. But it would be ignored, as we have specified injectBean also in the local file (beans5.xml) and we have used ref local in the target2 definition� Carrying this forward, now do the following changes in beans5.xml and see if the

result changes – why?� <bean id="target2" class="com.spring.beanhierarchy.SimpleTarget">� <property name="val">� <ref bean="injectBean"/>


� <ref bean="injectBean"/>� </property>� </bean>

� AND� 


� Definition for this bean in beans5.xml is as follows:� <bean id="target3" class="com.spring.beanhierarchy.SimpleTarget">� <property name="val">� <ref parent="injectBean"/>� </property>� </bean>

� Indicates that injectBean must be obtained from parent factory – ignore local


� Indicates that injectBean must be obtained from parent factory – ignore local instance of injectBean, if exists

� Definition of injectBean from parent.xml file:� <bean id="injectBean" class="java.lang.String">� <constructor-arg>� <value>Bean In Parent</value>� </constructor-arg>� </bean>

� Hence, a string Bean In Parent would be passed to the target1 bean

Spring AOP


Need for AOP� Aspect-oriented programming (AOP) provides for simplified application of cross-cutting concerns

� Examples of cross-cutting concerns� Logging

� Transaction management


� Transaction management

� Security

� Auditing

� Locking

� Event handling

AOP Illustrated


Need for AOP – A Case Study


Account Case Study� Suppose we want to develop a class that has two methods that allow depositing and withdrawing of money to and from a bank account

� Sample implementation on next page


Account Class – Sample Implementationpublic class Account{public long deposit(long depositAmount){newAmount = existingAmount + depositAmount;currentAmount = newAmount;return currentAmount;

}


public long withdraw(long withdrawalAmount){if (withdrawalAmount <= currentAmount){currentAmount = currentAmount – withdrawalAmount;

}return currentAmount;

}}

Need to Add Security� Suppose we now want to ensure that only the administrator user can perform the deposit and withdrawal transactions

� Hence, we need to first check which user is invoking these methods and then allow/disallow based on the user type/role


type/role

� Suppose we have a User class that returns the user id, by calling the appropriate method

� We can modify our implementation as shown next

Modified Account Classpublic class Account{

public long deposit(long depositAmount){

User user = User.getUser();

if (user.getRole().equals("BankAdmin"){

newAmount = existingAccount + depositAccount;

currentAmount = newAmount;

}


}

return currentAmount;

}

public long withdraw(long withdrawalAmount){



if (withdrawalAmount <= currentAmount){

currentAmount = currentAmount – withdrawalAmount;

}

}


}

}

Need to Add Transaction and Logging

Capabilities

� Suppose now we want to add transaction support and logging support to our Account class

� Modified code shown next


Modified Account Classpublic class Account{

public long deposit(long depositAmount){

logger.info("Start of deposit method");

Transaction trasaction = Transaction.getTransaction();

transaction.begin();

try{



newAmount = existingAccount + depositAccount;

currentAmount = newAmount;

}

transaction.commit();

}catch(Exception exception){



transaction.rollback();

}

logger.info("End of deposit method");


}

public long withdraw(long withdrawalAmount){

logger.info("Start of withdraw method");

Transaction trasaction = Transaction.getTransaction();


try{



if (withdrawalAmount <= currentAmount){

currentAmount = currentAmount – withdrawalAmount;

}

}

transaction.commit();


transaction.rollback();

Observations� As we can see, as we keep on making changes to our code, it becomes more and more complex

� Involves re-testing of the entire code

� Actual business logic is very small – the other aspects consume majority of code and logic


consume majority of code and logic

� Can this be avoided?

� Let us revisit what our code is actually doing step-by-step

Steps in Our Codepublic void deposit(){

// Transaction Management

// Logging

// Checking for the Privileged User

// Actual Deposit Logic comes here

}


}

public void withdraw(){

// Transaction Management

// Logging

// Checking for the Privileged User

// Actual Withdraw Logic comes here

}

Enter AOP� In AOP terms, these aspects such as transaction management, user role checking, logging, etc should be separated into separate blocks of code

� Our actual code should just concentrate on the business logic

� See next slide


� See next slide

These are aspectspublic void businessOperation(BusinessData data){

// Logginglogger.info("Business Method Called");

// Transaction Management Begintransaction.begin();



// Do the original business operation here……

// Transaction Management Endtransaction.end();

}

Join Points – Places where we can look

for Aspectspublic void someBusinessOperation(BusinessData data){

//Method Start -> Possible aspect code here like logging.

try{

// Original Business Logic here.


// Exception -> Aspect code here when some exception is raised.


// Exception -> Aspect code here when some exception is raised.

}finally{

// Finally -> Even possible to have aspect code at this point too.

}

// Method End -> Aspect code here in the end of a method.

}

Pointcut – Join Point where an Aspect

would actually be appliedpointcut method_start_end_pointcut(){

// This point cut applies the aspects, logging and transaction, before the // beginning and the end of the method.

}


pointcut catch_and_finally_pointcut(){

// This point cut applies the aspects, logging and transaction, in the catch // block (whenever an exception raises) and the finally block.

}

Advice� We can roughly say that Aspect is the concept, which is implemented by an Advice

� Aspect is abstract, Advice is concrete

� Following Advice types are supported in Spring:� Before Advice


� Before Advice

� After Advice

� Throws Advice

� Around Advice

Before Advice� Intercepts a method before it starts execution

� The org.springframework.aop.BeforeAdvice interface is used to represent this

� Example: Authenticate the user before allowing the user to perform deposit or withdraw transaction


perform deposit or withdraw transaction

After Advice� Intercepts a method before it returns control back to the caller

� The org.springframework.aop.AfterReturningAdviceinterface is used to represent this

� Example: Delete session data before sending control back to


� Example: Delete session data before sending control back to the caller

Throws Advice� Intercepts a method when it attempts to throw an exception

� The org.springframework.aop.ThrowsAdvice interface is used to represent this



the caller

Around Advice� Provides finer control over the execution of a method

� The org.aopalliance.intercept.MethodInterceptor interface is used to represent this



the caller

NetBeans package com.spring.empwithoutaop

AOP Case Study

NetBeans package com.spring.empwithoutaop


Requirement� We need to represent the details of an employee

� We can create an Employee interface that captures the essential details of the employee and a concrete class named EmployeeImpl that implements this interface

� We can then use the standard new approach to create an


� We can then use the standard new approach to create an instance of EmployeeImpl

Employee.javapublic interface Employee {

public String getFirstName();

public void setFirstName(String FirstName);

public String getLastName();

public void setLastName(String LastName);


public String getJobTitle();

public void setJobTitle(String JobTitle);

public Float getSalary();

public void setSalary(Float Salary);

public Date getHiredate();

public void setHiredate(Date Hiredate);

}

EmployeeImpl.java/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package com.spring.empwithoutaop;

import java.util.Date;

/**

*

* @author atulk

*/




public class EmployeeImpl implements Employee {

String FirstName;

String LastName;

String JobTitle;

Float Salary;

Date Hiredate;

public EmployeeImpl() {

}

public String getFirstName() {

return FirstName;

}

public void setFirstName(String FirstName) {

this.FirstName = FirstName;

}

public String getLastName() {

Client.java� /*



� */

� package com.spring.empwithoutaop;

� /**

� *

� * @author atulk

� */


public Client() {


� public Client() {

� }


� Employee emp = new EmployeeImpl();

� return emp;

� }


� Client client = new Client();

� Employee employee = client.getEmployee();

� employee.setFirstName("Ram");

� employee.setLastName("Shastri");

� employee.setJobTitle("SALESMAN");

� employee.setSalary(new Float("5000"));

� System.out.println("The new salary for " + employee.getFirstName() + " " + employee.getLastName() + " (" + employee.getJobTitle() + ") = " + employee.getSalary());

� }

� }

New Business Rules� Now suppose there were some business rules that needed to be applied:� A Salesman may not earn more than 4000

� Ram Shastri is not an acceptable name for an employee

� If we have source code, we can make changes – even then it is


� If we have source code, we can make changes – even then it is not easy

� If we do not have source code but have just the JAR, things are worse

� AOP can help resolve this easily

Using ProxyFactory� Instead of getting hold of an EmployeeImpl object, we have a Spring ProxyFactory intervene and

wrap the EmployeeImpl in a proxy object.

� We let the proxy intercept calls to setter methods, verify their validity and throw an exception for incorrect values

� When the validation succeeds, the setter method on the EmployeeImpl object is invoked as we intended all along.

� For this, we need a class that implements the Spring MethodBeforeAdvice interface. We can inject this class into the ProxyFactory; this instructs the ProxyFactory to intercept any call to methods on the EmployeeImpl object and call the before() method on the MethodBeforeAdvice before


the EmployeeImpl object and call the before() method on the MethodBeforeAdvice before continuing with the original call to the EmployeeImpl method.

� So in short, the steps are: � Specify the Employee “domain interface” � Acquire implementation of the Employee Interface (EmployeeImpl) � Create an implementation of the MethodBeforeAdvice interface that handles Validation of Business

Rules in its before method � Have the application invoke the Spring AOP ProxyFactory to return a proxy wrapping the Employee

instance, after instructing the ProxyFactorythat the MethodBeforeAdvice should be applied to the proxy

� From the application, Invoke the getters and setters on the Employee instance - the proxiedEmployeeImpl

New Class – EmployeeValidator.java� /*



� */


� import org.springframework.aop.MethodBeforeAdvice;

� import java.lang.reflect.Method;

� public class EmployeeValidator implements MethodBeforeAdvice {

� public EmployeeValidator() {}


� public void before(Method method, Object[] args, Object target) throws Throwable {

� Employee emp = (EmployeeImpl) target;

� if (method.getName().equalsIgnoreCase("setSalary")) {

� if ("SALESMAN".equalsIgnoreCase(emp.getJobTitle())) {

� // if the job of this employee is SALESMAN, he/she may not earn more than 4000

� float newSalary = ((Float) args[0]).floatValue();

� if (newSalary > 4000) {

� throw new RuntimeException("Salary may not exceed 4000 for Salesmen such as " + emp.getFirstName() + " " + emp.getLastName());

� }

� }

� }

� if (method.getName().equalsIgnoreCase("setFirstName")) {

� if ("Ram".equalsIgnoreCase(emp.getLastName())) {

� // we do not want any employee to be called John Doe

� if ("Shastri".equalsIgnoreCase((String) args[0])) {

� throw new RuntimeException("Employees should not be called Ram Shastri. Choose another First Name please.");

� }

� }

� }

� if (method.getName().equalsIgnoreCase("setLastName")) {

� if ("Ram".equalsIgnoreCase(emp.getFirstName())) {

New Client – ClientWithAOP.java� /*



� */


� import org.springframework.aop.framework.ProxyFactory;

� public class ClientWithAOP {


� Employee emp = new EmployeeImpl();

ProxyFactory pf = new ProxyFactory();


� ProxyFactory pf = new ProxyFactory();

� pf.setTarget(emp);

� pf.setInterfaces(new Class[]{Employee.class}); // this line is required for using the JDK 1.3 proxy based Spring AOP implementation,

� //otherwise the CGLib libraries are required

� pf.addAdvice(new EmployeeValidator());

� return (Employee) pf.getProxy();

� }

� public ClientWithAOP() {

� }


� ClientWithAOP client = new ClientWithAOP();

� Employee employee = client.getEmployee();

� employee.setFirstName("Rahul");

� employee.setLastName("Dravid");

� employee.setJobTitle("SALESMAN");

� employee.setSalary(new Float("5000"));

� System.out.println("The new salary for " + employee.getFirstName() + " " + employee.getLastName() + " (" + employee.getJobTitle() + ") = " + employee.getSalary());

� }

� }

AOP Revision


AOP Joinpoint� Point in the control flow of a program

� We can identify Joinpoints and insert additional logic at those Joinpoint's

� Examples of Jointpoint's (place at which the main logic meets with aspects such as logging, transaction, security, etc)


with aspects such as logging, transaction, security, etc)� Method invocation

� Class initialization

� Object initialization

� Set of Joinpoints creates a pointcut

AOP Advice� The code that is executed at a particular joinpoint

� That is, specifies what to do at a join point� Some additional behavior that Spring injects around a method invocation, defined in a method interceptor

� Types of Advice


� Types of Advice� before advice, which executes before joinpoint

� after advice, which executes after joinpoint

� around advice, which executes around joinpoint

AOP Pointcuts� A collection of joinpoints that we use to define when advice should be executed

� By creating pointcuts, you gain fine-grained control over how we apply advice to the components

� Example


� Example� A typical joinpoint is a method invocation.

� A typical pointcut is a collection of all method invocations in a particular class

� Pointcuts can be composed in complex relationships to further constrain when advice is executed

AOP Aspect� An aspect is the combination of advice and pointcuts


AOP Weaving� Process of actually inserting aspects into the application code at the appropriate point

� Types of Weaving� Compile time weaving

� Runtime weaving


� Runtime weaving

AOP Target� An object whose execution flow is modified by some AOP process

� They are sometimes called advised object


Implementing AOP� Process by which you can modify the structure of an object by introducing additional methods or fields to it

� You use the Introduction to make any object implement a specific interface without needing the object's class to implement that interface explicitly


implement that interface explicitly

Types of AOP� Static AOP

� The weaving process forms another step in the build process for an application

� Example: In Java program, you can achieve the weaving process by modifying the actual bytecode of the application changing


by modifying the actual bytecode of the application changing and modifying code as necessary

� Dynamic AOP� The weaving process is performed dynamically at runtime

� Easy to change the weaving process without recompilation

AOP Implementation Details� Based on proxies

� When we want to create an advised instance of a class, we must use the ProxyFactory class to create a proxy of an instance of that class, first providing the ProxyFactory with all the aspects that we want to be woven into the proxy


� We typically use ProxyFactoryBean class to provide declarative proxy creation

com.spring.aophelloworld

AOP Hello World Example

com.spring.aophelloworld


IMessageWriter.java� package com.spring.aophelloworld;

� /**� *� * @author atulk


� * @author atulk� */� public interface IMessageWriter {

� public void writeMessage();� }

MessageWriter.java� package com.spring.aophelloworld;

� /**� *� * @author atulk� */


� */� public class MessageWriter implements IMessageWriter{

� public void writeMessage() {� System.out.print("World");� }

� }

MessageDecorator.java� package com.spring.aophelloworld;

� /**

� *

� * @author atulk

� */

� import org.aopalliance.intercept.MethodInterceptor;

� import org.aopalliance.intercept.MethodInvocation;


� public class MessageDecorator implements MethodInterceptor {

� public Object invoke(MethodInvocation invocation) throws Throwable {

� System.out.print("Hello ");

� Object retVal = invocation.proceed();

� System.out.println("!");

� return retVal;

� }

� }

HelloWorldAOPExample.java� package com.spring.aophelloworld;

� import org.springframework.aop.framework.ProxyFactory;

� public class HelloWorldAOPExample {


� MessageWriter target = new MessageWriter();

�

� // create the proxy

� ProxyFactory pf = new ProxyFactory();


� pf.addAdvice(new MessageDecorator());

� pf.setTarget(target);

� MessageWriter proxy = (MessageWriter) pf.getProxy();

�

� // write the messages

� target.writeMessage();

� System.out.println("");

� proxy.writeMessage();

� }

� }

Integrating JSF with Spring


Requirements for Integrating JSF with

Spring – 1� In the faces-config.xml file, we need to add the following:<application> <variable-resolver> org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>

</application>


</application>� The web.xml should have the following entry:<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>


Spring – 2� Code the Spring bean and have an interface for it (ideally):

� Example:

public interface TimeService { Date getNow ();

}


}

public class TimeServiceImpl implements TimeService { public Date getNow () {return new Date ();

}}


Spring – 3� Add an entry in the applicationContext.cml file for our Spring bean:

<bean id="timeService"

class="com.source.timeservice.TimeServiceImpl" />


Requirements for Integrating JSF with Spring – 4

… Code our JSF bean that uses the Spring bean

public class UiBean implements InitializingBean {

private TimeService timeService = null;

public String getShortDate() {

return SimpleDateFormat.getDateInstance(SimpleDateFormat.SHORT).format(

getTimeService().getNow());

}


}

public TimeService getTimeService() {

return timeService;

}

public void setTimeService(TimeService timeService) {

this.timeService = timeService;

}

}


Spring – 5 … faces-config file<managed-bean>

<managed-bean-name>userBean</managed-bean-name>

<managed-bean-class>com.source.timeservice.UserBean</managed-bean-class>

<managed-bean-scope>request</managed-bean-scope>

<managed-property>

<property-name>timeService</property-name>


<property-name>timeService</property-name>

<value>#{timeService}</value>

</managed-property>

</managed-bean>

� Note: We are passing the Spring bean to the JSF bean as a property, the way we normally do in Spring (DI feature)


Spring – 6 … time.jsp file<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %><%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %><f:view><html><head><title>jsf-spring quickstart</title>


<title>jsf-spring quickstart</title></head><body><h:outputText value="#{userBean.shortDate}"/></body></html></f:view>

JSF with Spring – Another Example


Example 1 – stockInput.jsp� <%@page contentType="text/html"%>

� <%@page pageEncoding="UTF-8"%>

� <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>

� <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

� <f:view>

� <html>

� <head>

� <title>

� Stock Input Page

</title>


� </title>

� </head>

� <body>

� <h:form id="stockForm">

�

� <h1>

� Please Enter the Stock Symbol and click the button

� </h1>

�

� <p>

� <h:inputText id="stockSymbolInput" value="#{stockBean.symbolName}"

� required="true">

� </h:inputText>

� </p>

�

� <h:commandButton id="stockSubmit" type="submit" value="Submit Symbol"

� action="#{stockBean.findStockValue}">

� </h:commandButton>

�

� </h:form>

�

� </body>

Example 1 – stockOutputSuccess.jsp� <%@page contentType="text/html"%>




� <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

� "http://www.w3.org/TR/html4/loose.dtd">

� <html>

� <head>

� <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>JSP Page</title>


� <title>JSP Page</title>

� </head>

� <body>

�

� <f:view>

� <h1>

� The Stock Value of the symbol

� <h:outputText value="#{stockBean.symbolName}"> </h:outputText>

� is

� <h:outputText value="#{stockBean.symbolValue}"> </h:outputText>

� </h1>

� </f:view>

�

� </body>

� </html>

Example 1 – stockOutputFailure.jsp� <%@page contentType="text/html"%>




� <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

� "http://www.w3.org/TR/html4/loose.dtd">

� <html>

� <head>




� <title>JSP Page</title>

� </head>

� <body>

�

� <f:view>

� <h1>

� The Stock symbol

� <h:outputText value="#{stockBean.symbolName}"> </h:outputText>

� is not found. Please check again.

� </h1>

� </f:view>

�

� </body>

� </html>

Example 1 – StockValueFetcher.java� /*



� */

� package com.source.springwithjsf;

� /**

� *

� * @author atulk

� */

� import java.util.*;


� public class StockValueFetcher {

� private Map<String, String> stockSymbolsAndValues;

� private String symbolName;

� private String symbolValue;

� public StockValueFetcher() {

� stockSymbolsAndValues = new HashMap<String, String>();

� stockSymbolsAndValues.put("ABC", "10");

� stockSymbolsAndValues.put("DEF", "20");

� stockSymbolsAndValues.put("GHI", "30");

� stockSymbolsAndValues.put("JKL", "40");

� }

� public String getSymbolName() {

� return symbolName;

� }

� public void setSymbolName(String symbolName) {

� this.symbolName = symbolName;

Example 1 – faces.config.xml� <?xml version='1.0' encoding='UTF-8'?>

� 

� <faces-config version="1.2"

� xmlns="http://java.sun.com/xml/ns/javaee"


� xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">

�

� <application>

� <variable-resolver>

� org.springframework.web.jsf.DelegatingVariableResolver

</variable-resolver>


� </variable-resolver>

� </application>

�

� <managed-bean>

� <managed-bean-name>stockBean</managed-bean-name>

� <managed-bean-class>

� com.source.springwithjsf.StockValueFetcher

� </managed-bean-class>

� <managed-bean-scope>request</managed-bean-scope>

� </managed-bean>

�

� <managed-bean>

� <managed-bean-name>accountBean</managed-bean-name>

� <managed-bean-class>

� com.source.springwithjsf.AccountBean

� </managed-bean-class>

� <managed-bean-scope>request</managed-bean-scope>

� </managed-bean>

�

�

� <navigation-rule>

� <description>Navigation from the hello page.</description>

JSF with Spring – Another Example


Example 2 – enterAccountNumber.jsp� <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

� <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

� <html>

� <head>

� <title>JSF with Spring</title>

� </head>

� <body>

� <f:view>

� <h:form>

� <table width="30%" height="30%" border="2" cellspacing="0" cellpadding="5">

� <tr>

<td colspan="2">


� <td colspan="2">

� <h:message for="accountNumber" />

� </td>

� </tr>

� <tr>

� <td>

� <h:inputText id="accountNumber" value="#{accountBean.accountNumber}"/>

� </td>

� <td><b>

� <h:outputText value="Account Number"/>

� </b></td>

� </tr>

� <tr>

� <td colspan="2">

� <h:commandButton action="#{accountBean.findAccountBalance}" value="Get Balance"/>

� </td>

� </tr>

� <tr>

� <td>

� <h:outputText value="#{accountBean.balance}"/>

� </td>

� <td><b>

Example 2 – AccountNumberBean.java� /*

� * PageBean.java

� *

� * Created on September 20, 2007, 5:28 PM

� *

� * To change this template, choose Tools | Template Manager


� */

� package com.source.springwithjsf;


� import java.util.Map;


� public class AccountBean {


� private String balance;

� private Map<String, String> accountMap;

� public AccountBean() {

� accountMap = new HashMap<String, String>();

� accountMap.put("1", "1000");







� }



� }

Education

Spring