Национальный исследовательский институт

Московский Энергетический Институт(Технический Университет)

Институт автоматики и вычислительной техники

Кафедра Прикладной математики

Лабораторная работа №6

по дисциплине:

Проектирование крупных распределенных программных систем и баз данных

тема: «Реализация cтруктурного шаблона проектирования»

Выполнил:

Бычков А.С.

Москва

2012 г.

Шаблон “ADAPTER”

Категория

Структурный

Описание

Приводит интерфейс объекта к требуемому виду.

Уместность применения

1)Существующий объект (адаптируемый) предоставляет необходимые функции но не поддерживает нужного интерфейса

2) Формат входных или выходных данных метода не совпадает с требуемым.

Преимущества

1) Позволяет избежать дублирования кода

2) Полезен если реализации адаптируемого класса неизвестна

Недостатки

1) не обнаружены

Реализация

public interface IPlayer

{

void play(String aSong);

void stop();

}

public class PlayerAdapter : IPlayer

{

private SealedPlayer mPlayer;

public PlayerAdapter(SealedPlayer aPlayer)

{

mPlayer = aPlayer;

}

public void stop()

{

mPlayer.stop();

}

public void play(String aSong)

{

mPlayer.setSong(aSong);

mPlayer.playSong();

}

}

public sealed class SealedPlayer

{

private String mSong;

private String mPlayerState;

public SealedPlayer()

{

mPlayerState = "STOPPED";

}

public void setSong(String aSong)

{

mSong = aSong;

}

public void stop()

{

if(!mPlayerState.Equals("STOPPED"))

{

mPlayerState = "STOPPED";

Console.Out.WriteLine("SONG " + mSong + " IS STOPPED");

}

}

public void playSong()

{

if (mSong != null && !mPlayerState.Equals("IN_PLAY"))

{

stop();

mPlayerState = "IN_PLAY";

Console.Out.WriteLine("SONG "+mSong+" IS NOW PLAYING");

}

}

}

static void Main(string[] args)

{

IPlayer player = new PlayerAdapter(new SealedPlayer());

player.play("SUPER_SONG");

player.stop();

Console.ReadLine();

}

Шаблон “BRIDGE”

Категория

Структурный

Описание

Отделяет абстракцию от реализации так, чтобы и то и другое можно было изменять независимо.

Уместность применения

1) необходимо избежать постоянной привязки абстракции к реализации.

2) изменения в реализации не должны приводить к перекомпиляции

Преимущества

1) повышает масштабируемость

2) упрощает тестирование

Недостатки

1) не обнаружены

Реализация

public abstract class AbstractAlarm

{

protected IRinger mRinger;

public AbstractAlarm(IRinger aRinger)

{

mRinger = aRinger;

}

public abstract void watchForTheAlarm();

}

public class BeepRinger : IRinger

{

public void activateSiren()

{

Console.Beep(15000, 1000);

}

}

public class BombAlarm : AbstractAlarm

{

private int mDelay;

public BombAlarm(IRinger aRinger, int aDelay)

: base(aRinger)

{

mDelay = aDelay;

}

public override void watchForTheAlarm()

{

if (mDelay > 0)

{

System.Threading.Thread.Sleep(mDelay);

mRinger.activateSiren();

}

}

}

public class ConsoleRinger : IRinger

{

public void activateSiren()

{

Console.Out.WriteLine(">>>>>>>>>>ALARM!<<<<<<<<<");

}

}

public interface IRinger

{

void activateSiren();

}

public class ManualAlarm : AbstractAlarm

{

private Boolean mIsArmed = false;

public ManualAlarm(IRinger aRinger)

: base(aRinger)

{

}

public void activate()

{

if (mIsArmed)

{

mRinger.activateSiren();

}

}

public override void watchForTheAlarm()

{

mIsArmed = true;

}

}

static void Main(string[] args)

{

IRinger cringer = new ConsoleRinger();

IRinger bringer = new BeepRinger();

ManualAlarm manAlarm = new ManualAlarm(cringer);

manAlarm.activate();

manAlarm.watchForTheAlarm();

manAlarm.activate();

manAlarm = new ManualAlarm(bringer);

manAlarm.activate();

manAlarm.watchForTheAlarm();

manAlarm.activate();

BombAlarm bombAlarm = new BombAlarm(bringer, 2000);

bombAlarm.watchForTheAlarm();

bombAlarm = new BombAlarm(cringer, 2000);

bombAlarm.watchForTheAlarm();

Console.ReadLine();

}

Шаблон “DECORATOR”

Категория

Структурный

Описание

Динамически добавляет объекту новые обязанности.

Уместность применения

1) Если необходимо динамически добавлять обязанности объектам

2) Если расширение путем порождения подклассов затруднено или невозможно

Преимущества

1) Удобно динамически как назначать, так и снимать обязанности с объекта

2) Позволяет избежать классов, перегруженных функциями на верхних уровнях иерархии

Недостатки

1) Возможно большое число мелких объектов.

2) Декоратор и его компонент не идентичны.

Реализация

public abstract class AbstractAction

{

public abstract void doAction();

}

public class AnotherHelloWorldAction : AbstractAction

{

public override void doAction()

{

Console.Out.WriteLine("ANOTHER HELLO WORLD");

}

}

public class BeepActionDecorator : AbstractAction

{

AbstractAction mAction;

public BeepActionDecorator(AbstractAction aAction)

{

mAction = aAction;

}

public override void doAction()

{

Console.Beep();

mAction.doAction();

}

}

public class HelloWorldAction : AbstractAction

{

public override void doAction()

{

Console.Out.WriteLine("HELLO WORLD");

}

}

static void Main(string[] args)

{

AbstractAction action = new HelloWorldAction();

action.doAction();

action = new BeepActionDecorator(action);

action.doAction();

action = new AnotherHelloWorldAction();

action.doAction();

action = new BeepActionDecorator(action);

action.doAction();

Console.ReadLine();

}

Шаблон “FACADE”

Категория

Структурный

Описание

Предоставляет унифицированный интерфейс вместо набора интерфейсов не-

которой подсистемы.

Уместность применения

1) Если необходим простой интерфейс к сложной системе.

2) Если необходимо отделить систему как от клиентов так и от других подсистем.

Преимущества

1) Изолирует клиентов от компонентов подсистемы.

2) Не препятствует напрямую обращаться к классам при необходимости.

Недостатки

1) Не обнаружены.

Реализация

public class Audio

{

public void playMusic()

{

Console.Out.WriteLine("MUSIC IS NOW PLAYING");

}

public void stopMusic()

{

Console.Out.WriteLine("MUSIC IS STOPPED");

}

}

public class Computer

{

public void boot()

{

Console.Out.WriteLine("COMPUTER IS NOW BOOTING");

}

public void shutdown()

{

Console.Out.WriteLine("COMPUTER IS SHUTTING DOWN");

}

}

public class HeatSystem

{

public void initialize()

{

Console.Out.WriteLine("HEAT SYSTEM INITALIZATION");

}

}

public class Lights

{

public void turnOn()

{

Console.Out.WriteLine("LIGHTS is ON");

}

public void turnOff()

{

Console.Out.WriteLine("LIGHTS is off");

}

}

public class SmartHouseSystem

{

private Audio mAudio;

private Computer mComputer;

private HeatSystem mHeatSystem;

private Lights mLights;

public void initializeSystem()

{

mLights = new Lights();

mLights.turnOn();

mHeatSystem = new HeatSystem();

mHeatSystem.initialize();

mAudio = new Audio();

mAudio.playMusic();

mComputer = new Computer();

mComputer.boot();

}

public void shutdownSystem()

{

if (mAudio != null)

mAudio.stopMusic();

if (mComputer != null)

mComputer.shutdown();

if (mLights != null)

mLights.turnOff();

}

}

static void Main(string[] args)

{

SmartHouseSystem system = new SmartHouseSystem();

system.initializeSystem();

System.Threading.Thread.Sleep(2000);

Console.Out.WriteLine();

system.shutdownSystem();

Console.ReadLine();

}

Шаблон “PROXY”

Категория

Структурный

Описание

Является суррогатом другого объекта и контролирует доступ к нему.

Уместность применения

1) Для представления удаленных объектов локально

2) Для отложенной инициализации ресурсов

3) Контроль доступа к объекту

Преимущества

1) Экономия ресурсов

2) Безопасность системы

3) RMI

Недостатки

1) В случае, например , удаленного вызова возможен таймаут.

2) резкое увеличение времени отклика.

Реализация

public interface IUserData

{

String getRecord();

}

public class PasswordUserDataProxy : IUserData

{

private IUserData mData;

private String mPassord;

public PasswordUserDataProxy(IUserData aData, String aPassword)

{

mData = aData;

mPassord = aPassword;

}

public String getRecord()

{

Console.Out.WriteLine("PLS ENTER PASSOWORD");

String enter = Console.ReadLine();

if (!enter.Equals(mPassord))

{

Console.Out.WriteLine("INCORRECT PASS. WILL RETURN \"\"");

return "";

}

else

{

Console.Out.WriteLine("PASS CORRECT!");

return mData.getRecord();

}

}

}

public class UserDataImpl : IUserData

{

private String mRecord;

public UserDataImpl(String aRecord)

{

mRecord = aRecord;

}

public String getRecord()

{

return mRecord;

}

}

static void Main(string[] args)

{

SmartHouseSystem system = new SmartHouseSystem();

system.initializeSystem();

System.Threading.Thread.Sleep(2000);

Console.Out.WriteLine();

system.shutdownSystem();

Console.ReadLine();

}

Шаблон “COMPOSITE”

Категория

Структурный

Описание

Компонует объекты в древовидные структуры для представления иерархий

часть-целое.

Уместность применения

1) есть необходимость представить иерархию объектов вида часть-целое;

2) есть необходимость трактовать составные и простые объекты как единое целое

Преимущества

1) Упрощение архитектуры клиента

2) Легкость добавления новых компонентов

3) RMI

Недостатки

1) максимизация интерфейса класса Component.

Реализация

public abstract class Component

{

protected string name;

// Constructor

public Component(string name)

{

this.name = name;

}

public abstract void Add(Component c);

public abstract void Remove(Component c);

public abstract void Display(int depth);

}

public class Composite : Component

{

private ArrayList children = new ArrayList();

public Composite(string name)

: base(name)

{

}

public override void Add(Component component)

{

children.Add(component);

}

public override void Remove(Component component)

{

children.Remove(component);

}

public override void Display(int depth)

{

Console.WriteLine(new String('-', depth) + name);

foreach (Component component in children)

{

component.Display(depth + 2);

}

}

}

public class Leaf : Component

{

public Leaf(string name)

: base(name)

{

}

public override void Add(Component c)

{

Console.WriteLine("Cannot add to a leaf");

}

public override void Remove(Component c)

{

Console.WriteLine("Cannot remove from a leaf");

}

public override void Display(int depth)

{

Console.WriteLine(new String('-', depth) + name);

}

}

static void Main()

{

// Create a tree structure

Component root = new Composite("root");

root.Add(new Leaf("Leaf A"));

root.Add(new Leaf("Leaf B"));

Component comp = new Composite("Composite X");

comp.Add(new Leaf("Leaf XA"));

comp.Add(new Leaf("Leaf XB"));

root.Add(comp);

root.Add(new Leaf("Leaf C"));

Leaf leaf = new Leaf("Leaf D");

root.Add(leaf);

root.Remove(leaf);

root.Display(1);

Console.Read();

}

Шаблон “LIGHTWEIGHT”

Категория

Структурный

Описание

Использует разделение для эффективной поддержки множества мелких

объектов.

Уместность применения

1) в приложении используется большое число объектов и из-за этого затраты на хранение высоки;

2) большую часть состояния объектов можно вынести вовне;

3) многие группы объектов можно заменить относительно небольшим количе-

ством разделяемых объектов, поскольку внешнее состояние вынесено;

Преимущества

1) уменьшение общего числа экземпляров;

2) сокращение объема памяти, необходимого для хранения внутреннего состо-

яния;

3) вычисление, а не хранение внешнего состояния ;

Недостатки

1) не обнаружены.

Реализация

public class Car : ISimpleGraphObject

{

private CarType mCarType;

public Car(CarType aCarType)

{

mCarType = aCarType;

}

public void draw(DrawContext aContext)

{

Console.Out.WriteLine("DRAWING CAR WITH TYPE " + mCarType + " at " + aContext.x + " " + aContext.y);

}

}

public enum CarType { BUS, SEDAN, TRUCK };

}

public class DrawContext

{

public readonly int x;

public readonly int y;

public DrawContext(int x, int y)

{

this.x = x;

this.y = y;

}

}

public interface ISimpleGraphObject

{

void draw(DrawContext aContext);

}

public class SimpleGraphObjectFactory

{

private Dictionary mCars = new Dictionary();

private Tree mTree;

public Car getCar(CarType aType)

{

if (!mCars.Keys.Contains((int)aType))

{

mCars[(int)aType] = new Car(aType);

}

return mCars[(int)aType];

}

public Tree getTree()

{

if (mTree == null)

{

mTree = new Tree();

}

return mTree;

}

}

public class Tree : ISimpleGraphObject

{

public void draw(DrawContext aContext)

{

Console.Out.WriteLine("DRAWING TREE AT "+ aContext.x + " " +aContext.y);

}

}

static void Main(string[] args)

{

SimpleGraphObjectFactory factory = new SimpleGraphObjectFactory();

DrawContext carCont = new DrawContext(0, 0);

DrawContext topTree = new DrawContext(100, -200);

DrawContext bottomTree = new DrawContext(100, 200);

factory.getCar(CarType.TRUCK).draw(carCont);

factory.getTree().draw(topTree);

factory.getTree().draw(bottomTree);

Console.ReadLine();

}