Rammar eru almennar aðgerðir og aðferðir sem nota má til að búa til sértækan hugbúnað. Með römmum má endurnýta kóða sem alltaf er eins eða nánast alltaf er eins. Það sem er sérhæft eru ákveðin viðfangsefni en útfærsla á þeim notar rammann. Við skilgreinum ramma og skoðum kosti og galla. Við skoðum einnig létta gáma eða lightweight containers sem eru forrit sem sjá um lífshlaup (live-cycle) hluta og umhverfi þeirra (context). Þá skoðum við munstrið Dependency Injection sem er mjög hentugt í römmum. Einnig skoðum við Template Method og Strategy munstrin.

1. Lecture 09
Frameworks

2. 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

3. Reading
 Dependency Injection
 Template Method Pattern
 Strategy Pattern
 Spring Framework (video)
 Article by Fowler
– Inversion of Control Containers and the Dependency
Injection pattern

4. Resources
 Spring Framework homepage
– http://www.springframework.org
 Reference Documentation
– http://www.springframework.org/docs/reference/index.
html
– Also in PDF format

5. Why Frameworks?

6. 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

7. Framework design
 Inheritance of framework classes
 Composition of framework classes
 Implementation of framework interfaces
 Dependency Injection
Framework
Your Code
Domain ?

8. 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

9. Abstractions
 From API to Frameworks
Framework Spring
API Patterns JEE/.NET
Patterns
API Definition JEE/.NET API

10. Open Source Frameworks
 Web Frameworks
– Jakarta Struts, WebWork, Maverick, Play!
 Database Frameworks
– Hibernate, JDO, TopLink
 General Framework
– Spring, Expresso, PicoContainer, Avalon
 Platform Frameworks
– JEE

11. 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

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

13. 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

14. Framework Patterns

15. 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

16. 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

17. Dependency Injection
Removes 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

18. Dependency Injection
 Fowler’s Naive Example
– MovieLister uses a finder class
class MovieLister...
Separate what varies
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()]);
}
– How can we separate the finder functionality?
REMEMBER PROGRAM TO INTERFACES PRINSIPLE?

19. Dependency Injection
 Fowler’s Naive Example
– Let’s make an interface, MovieFinder
– MovieLister is still dependent on particular
MovieFinder implementation
public interface MovieFinder {
List findAll();
}
class MovieLister...
private MovieFinder finder;
public MovieLister() {
finder = new MovieFinderImpl("movies1.txt");
}
Argh!
Not cool.

20. 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 create
MovieLister and then all the setFinder setter
method to provide the
MovieFinder interface

21. 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;
}

22. Dependency Injection
SEPARATED INTERFACE

23. Example
 ContentLister
public class ContentLister
{
private ContentFinder contentFinder;
public void setContentFinder(ContentFinder contentFinder)
{
this.contentFinder = contentFinder;
}
public List<Content> find(String pattern)
{
return contentFinder.find(pattern);
}
}

24. Example
 ContentFinder interface
public interface ContentFinder
{
List<Content> find(String pattern);
}

25. 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;
}
}

26. Example
 TestContentLister - Testcase
public 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

27. Example

28. Template Method Pattern
Create 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

29. Template Method Pattern

30. Template Method Pattern
public 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);
...
}
}

31. Template Method Pattern
AbstractOrderEJB
placeOrder ()
abstract getItemPrice()
abstract getSpendingLimit()
abstract placeOrder()
MyOrderEJB
getItemPrice()
getSpendingLimit()
placeOrder()
extends
Generic
functionality
Domain
specific
functionality

32. Template Method Pattern
public class MyOrderEJB extends AbstractOrderEJB
{
...
int getItemPrice(int[] i)
{
...
}
int getSpendingLimit(int customerId)
{
...
}
int placeOrder(int customerId, int total, int items)
{
...
}
}

33. 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

34. Strategy Pattern
Create 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

35. 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

36. Strategy Pattern

37. Strategy Pattern
 Interface for specific functionality
public interface DataHelper
{
int getItemPrice(InvoiceItem item);
int getSpendingLimit(CustomerId) throws NoSuchCustomerException;
int palceOrder(int customerId, int total, InvoiceItem[] items);
 Generic class uses the interface
– Set method to inject the interface
}
private DataHelper dataHelper;
public void setDataHelper(DataHelper newDataHelper)
{
this.dataHelper = newDataHelper;
} DEPENDENCY INJECTION

38. Strategy Pattern
public 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);
...
}
}

39. 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 Supertype
B) Template Method
C) Strategy
D) Dependency Injection

40. 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 Supertype
B) Template Method
C) Strategy
D) Dependency Injection
✔

41. 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