Lecture 09Frameworks

Agenda Why frameworks? Framework patterns

– Inversion of Control and Dependency Injection– Template Method– Strategy

From problems to patterns– Game Framework

Spring framework– Bean containers– BeanFactory and ApplicationContext

Reading Dependency Injection Template Method Pattern Strategy Pattern Spring Framework (video) Article by Fowler

– Inversion of Control Containers and the Dependency Injection pattern

Resources Spring Framework homepage

– http://www.springframework.org Reference Documentation

– http://www.springframework.org/docs/reference/index.html

– Also in PDF format

Why Frameworks?

Why use Frameworks? Frameworks can increase productivity

– We can create our own framework– We can use some third party framework

Frameworks implement general functionality– We use the framework to implement our business

logic

Framework design Inheritance of framework classes Composition of framework classes Implementation of framework interfaces Dependency Injection

FrameworkYour CodeDomain ?

Using Frameworks Frameworks are concrete, not abstract

– Design patterns are conceptual, frameworks provide building blocks

Frameworks are higher-level– Built on design patterns

Frameworks are usually general or technology-specific

Good frameworks are simple to use, yet powerful

Abstractions From API to Frameworks

API Definition JEE/.NET API

API Patterns JEE/.NETPatterns

Framework Spring

Open Source Frameworks Web Frameworks

– Jakarta Struts, WebWork, Maverick, Play! Database Frameworks

– Hibernate, JDO, TopLink General Framework

– Spring, Expresso, PicoContainer, Avalon Platform Frameworks

– JEE

Where do Frameworks Come From? Who spends their time writing

frameworks? If they give them away, how can anyone

make money?

Companies that use frameworks, have their developers work on them

Give the code, sell the training and consulting

Write down the pros and cons (benefits and drawbacks) for frameworks.Use two columns, benefits on the left, drawbacks right

EXERCISE

Pros and Cons Pros

– Productivity– Well know application

models and patterns– Tested functionality– Connection of different

components– Use of open standards

Cons– Can be complicated,

learning curve– Dependant on

frameworks, difficult to change

– Difficult to debug and find bugs

– Performance problems can be difficult

– Can be bought by an evil company

Framework Patterns

Separation of Concerns One of the main challenge of frameworks is to

provide separation of concerns– Frameworks deal with generic functionality

– Layers of code

Frameworks need patterns to combine generic and domain specific functionality

Framework Patterns Useful patterns when building a

framework:– Dependency Injection: remove dependencies

by injecting them (sometimes called Inversion of Control)

– Template Method: extend a generic class and provide specific functionality

– Strategy: Implement an interface to provide specific functionality

Dependency InjectionRemoves explicit dependence on specific application code by injecting depending

classes into the framework

Objects and interfaces are injected into the classes that to the work

Two types of injection– Setter injection: using set methods– Constructor injection: using constructors

Dependency Injection Fowler’s Naive Example

– MovieLister uses a finder class

– How can we separate the finder functionality?

class MovieLister... public Movie[] moviesDirectedBy(String arg) { List allMovies = finder.findAll(); for (Iterator it = allMovies.iterator(); it.hasNext();) { Movie movie = (Movie) it.next(); if (!movie.getDirector().equals(arg)) it.remove(); } return (Movie[])allMovies.toArray(new Movie[allMovies.size()]); }

Separate what varies

REMEMBER PROGRAM TO INTERFACES PRINSIPLE?

Dependency Injection Fowler’s Naive Example

– Let’s make an interface, MovieFinder– MovieLister is still dependent on particular

MovieFinder implementationpublic interface MovieFinder { List findAll();}

class MovieLister... private MovieFinder finder; public MovieLister() { finder = new MovieFinderImpl("movies1.txt"); }

Argh!Not cool.

Dependency Injection An assembler (or container) is used to create

an implementation– Using constructor injection, the assember will

create a MovieLister and passing a MovieFinder interface in the contructor

– Using setter injection, the assembler will createMovieLister and then all the setFinder setter method to provide theMovieFinder interface

Dependency Injection Example setter injection

class MovieLister... private MovieFinder finder; public void setFinder(MovieFinder finder) { this.finder = finder; }

class MovieFinderImpl... public void setFilename(String filename) this.filename = filename; }

Dependency Injection

SEPARATED INTERFACE

Example ContentListerpublic class ContentLister{ private ContentFinder contentFinder;

public void setContentFinder(ContentFinder contentFinder) { this.contentFinder = contentFinder; }

public List<Content> find(String pattern) { return contentFinder.find(pattern); }}

Example ContentFinder interface

public interface ContentFinder{ List<Content> find(String pattern);}

Example SimpleContentFinder – implementation

public class SimpleContentFinder implements ContentFinder{ ... public List<Content> find(String pattern) { List<Content> contents = contentService.getContents(); List<Content> newList = new ArrayList<Content>();

for(Content c : contents) { if (c.getTitle().toLowerCase().contains(pattern)) { newList.add(c); } } return newList; }}

Example TestContentLister - Testcasepublic class TestContentLister extends TestCase { public void testContentLister () {ServiceFactoryserviceFactory = new ServiceFactory();ContentServicecontentService = (ContentService)serviceFactory.getService("contentService");contentService.addContent(new Content(1, "The Simpsons Movie", "", "", new Date(), ""));contentService.addContent(new Content(1, "The Bourne Ultimatum", "", "", new Date(), ""));contentService.addContent(new Content(1, "Rush Hour 3", "", "", new Date(), ""));ContentFindercontentFinder = new SimpleContentFinder(contentService);ContentListercontentLister = new ContentLister();contentLister.setContentFinder(contentFinder); List<Content>searchResults = contentLister.find("simpsons"); for (Content c : searchResults) { System.out.println(c); } }}

Magic stuff

Example

Template Method PatternCreate a template for steps of an algorithm and let

subclasses extend to provide specific functionality

We know the steps in an algorithm and the order– We don’t know specific functionality

How it works– Create an abstract superclass that can be extended

for the specific functionality– Superclass will call the abstract methods when

needed

Template Method Pattern

Template Method Patternpublic class AbstractOrderEJB{ public final Invoice placeOrder(int customerId, InvoiceItem[] items) throws NoSuchCustomerException, SpendingLimitViolation { int total = 0; for (int i=0; i < items.length; i++) { total += getItemPrice(items[i]) * items[i].getQuantity(); } if (total >getSpendingLimit(customerId)) { ... } else if (total > DISCOUNT_THRESHOLD) ... int invoiceId = placeOrder(customerId, total, items); ... }}

Template Method Pattern

AbstractOrderEJBplaceOrder ()

abstract getItemPrice()abstract getSpendingLimit()

abstract placeOrder()

MyOrderEJBgetItemPrice()

getSpendingLimit()placeOrder()

extends

Domainspecificfunctionality

Genericfunctionality

Template Method Patternpublic class MyOrderEJB extends AbstractOrderEJB{ ... int getItemPrice(int[] i) { ... }

int getSpendingLimit(int customerId) { ... }

int placeOrder(int customerId, int total, int items) { ... }}

Template Method Pattern When to Use it

– For processes where steps are know but some steps need to be changed

– Works if same team is doing the abstract and the concrete class

When Not to Use it– The concrete class is forced to inherit, limits

possibilities– Developer of the concrete class must

understand the abstract calls– If another team is doing the concrete class as

this creates too much communication load between teams

Strategy PatternCreate a template for the steps of an

algorithm and inject the specific functionality

Implement an interface to provide specific functionality– Algorithms can be selected on-the-fly at

runtime depending on conditions– Similar as Template Method but uses interface

inheritance

Strategy Pattern How it works

– Create an interface to use in the generic algorithm

– Implementation of the interface provides the specific functionality

– Framework class has reference to the interface an

– Setter method for the interface

Strategy Pattern

Strategy Pattern Interface for specific functionality

Generic class uses the interface– Set method to inject the interface

public interface DataHelper { int getItemPrice(InvoiceItem item); int getSpendingLimit(CustomerId) throws NoSuchCustomerException; int palceOrder(int customerId, int total, InvoiceItem[] items); }

private DataHelper dataHelper;

public void setDataHelper(DataHelper newDataHelper){ this.dataHelper = newDataHelper;} DEPENDENCY INJECTION

Strategy Patternpublic class OrderEJB{ public final Invoice placeOrder(int customerId, InvoiceItem[] items) throws NoSuchCustomerException, SpendingLimitViolation { int total = 0; for (int i=0; i < items.length; i++) { total += this.dataHelper.getItemPrice(items[i]) * items[i].getQuantity(); } if (total >this.dataHelper.getSpendingLimit(customerId)) {... } else if (total > DISCOUNT_THRESHOLD) ... int invoiceId = this.dataHelper.placeOrder(customerId, total, items); ... }}

We are building framework for games. It turns out that all the games are similar so we create an abstract class for basic functionality that does not change, and then extend that class for each game. What pattern is this?

A) Layered SupertypeB) Template MethodC) StrategyD) Dependency Injection

QUIZ

We are building framework for games. It turns out that all the games are similar so we create an abstract class for basic functionality that does not change, and then extend that class for each game. What pattern is this?

A) Layered SupertypeB) Template MethodC) StrategyD) Dependency Injection

QUIZ

✔

Summary Framework patterns

– Inversion of Control and Dependency Injection– Template Method– Strategy

From problems to patterns– Game Framework

Spring framework– Bean containers– BeanFactory and ApplicationContext