Lecture 10Using Frameworks

Agenda From Problem to Patterns

– Implementing a simple game Template Method Strategy Dependency Injection

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

– Inversion of Control Containers and the Dependency Injection pattern

From Problem to Patterns

Framework design Inheritance of framework classes

Template Method – class Inheritance Composition of framework classes

Strategy – interface InheritanceDependency Injection

FrameworkYour CodeDomain ?

From Problem to PatternWe need to design game software

Common turn-based board games like monopoly, chess, backgammon, yatzy etc.

You must propose a design

From Problem to PatternLet’s make a Game Framework

What patterns can we use?

Patterns Template Method

– Template of an algorithm– Based on class inheritance

Strategy– Composition of an strategy– Based on interface inheritance

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

What is the game algorithm?

initialize

while more playsmake one turn

print winnner

void initializeGame();

boolean endOfGame();

void makePlay(int player);

void printWinner();

Game Template

Specific Game

extends

This is the generictemplate of the game play

This is the specific detailsfor this specific game

Design

interface Game

void initializeGamevoid makePlay (int player)boolean endOfGamevoid printWinner

AbstractGame

playOneGame (int playerCount)

imp

lem

ents

Chess

void initializeGamevoid makePlay(int player)boolean endOfGamevoid printWinner

implements

Interface for game algorithm

package is.ru.honn.game.framework;

public interface Game{ public void initializeGame(); public void makePlay(int player); public boolean endOfGame(); public void printWinner();}

The Templatepackage is.ru.honn.game.framework;

public abstract class AbstractGame implements Game{ protected int playersCount;

public final void playOneGame(int playersCount) { this.playersCount = playersCount;

initializeGame(); int j = 0; while (!endOfGame()) { makePlay(j); j = (j + 1) % playersCount; } printWinner(); }}

The Specific Gameclass Chess extends AbstractGame{ public void initializeGame() { // Initialize players, put the pieces on the board } public void makePlay(int player) { // Process a turn for the player } public boolean endOfGame() { // Return true if in Checkmate or stalemate return true; } public void printWinner() { // Display the winning player }}

Design

interface Game

void initializeGamevoid makePlay (int player)boolean endOfGamevoid printWinner

AbstractGame

playOneGame (int playerCount)

imp

lem

ents

Chess

void initializeGamevoid makePlay(int player)boolean endOfGamevoid printWinner

implements

RedesignLet’s use Strategy instead

Why would we do that?

Strategy PatternCreate a template for the steps of an

algorithm and inject the specific functionality

(strategy)

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

Game Strategy

Specific Game

implements

This is the genericstrategy of the game play

This is the specific detailsfor this specific game

Design

interfaceGameStrategy

void initializeGamevoid makePlay (int player)boolean endOfGamevoid printWinner

GamePlay

GamaStrategy strategy

playOneGame (int playerCount)

ChessStrategy

void initializeGamevoid makePlay(int player)boolean endOfGamevoid printWinner

implements

uses

The ChessStrategywill be injected into the game (context)

Assember

The Strategy

package is.ru.honn.game.framework;

public interface GameStrategy{ public void initializeGame(); public void makePlay(int player); public boolean endOfGame(); public void printWinner();}

The Specific Strategyclass ChessStrategy implements GameStrategy{ public void initializeGame() { // Initialize players, put the pieces on the board } public void makePlay(int player) { // Process a turn for the player } public boolean endOfGame() { // Return true if in Checkmate or stalemate return true; } public void printWinner() { // Display the winning player }}

The Contextpublic class GamePlay{ GameStrategy strategy; protected int playersCount; public void setStrategy(GameStrategy strategy) { this.strategy = strategy; } public final void playOneGame(int playersCount) { this.playersCount = playersCount; this.strategy.initializeGame(); int j = 0; while (!this.strategy.endOfGame()) { this.strategy.makePlay(j); j = (j + 1) % playersCount; } this.strategy.printWinner(); }}

Polymorphism

The Assembler

GamePlay play = new GamePlay(); // Assign the right strategyplay.setStrategy(new ChessStrategy());

What design pattern is used when the strategy is assigned to the context?

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 InjectionAssembler

GamePlay play = new GamePlay() play.setStrategy(new ChessStrategy())

ChessStrategy

initializeGame…

interface GameStrategy

initializeGame();makePlay(int player);endOfGame();printWinner();

GamePlay

setStrategy(GameStrategy strategy)

playOneGame(int playersCount) … this.strategy.initializeGame();

createimplements

uses

Framework

create

Spring Framework

Lightweight Containers Assemble components from different

projects into a cohesive application– Wiring is done with “Inversion of Control”– Provide life-cycle management of objects– Provide context

Overview

Spring 1 – Introduction

Lightweight Containers Manage objects Provide context

Spring Containers Lightweight containers

– Provides life-cycle management and other services BeanFactory

– Simple factory interface for creating beans ApplicationContext

– Extends BeanFactory and adds some functionality for application context

Packages– org.springframework.beans– org.springframework.context– Refer to Spring 3

Spring Containers The concept

– Building applications from POJOs

Using BeanFactory

BeanFactory

<beans> <bean id="person" class="Person"> <property name="name"> <value>Olafur Andri</value> </property> <property name="email"> <value>andri@ru.is</value> </property> </bean></beans>

read, parse

create

PersonThe Bean Factory usessetter injection to create theperson object

FileSystemXmlApplicationContext Loads the context from an XML file

Application contexts are intended as central registries– Support of hierarchical contexts (nested)

public class AppTest{ public static void main(String[] args) { ApplicationContext ctx = new FileSystemXmlApplicationContext("app.xml"); }}

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