Bài tiểu luận KIẾN TRÚC VÀ THIẾT KẾ PHẦN MỀM FACTORY PATTERN

HỌC VIÊN CÔNG NGHỆ BƯU CHÍNH VIỄN THÔNG
***
KIẾN TRÚC VÀ THIẾT KẾ PHẦN MỀM
Sinh viên thực hiện: Nguyễn Trung Kiên
Lớp: D10CNPM2


Hà Nội,Ngày 22/2/2014
I. FACTORY PATTERN
1. Sơ đồ mẫu
2. Ý nghĩa
Factory Pattern định nghĩa một lớp (interface, abstract, class) đóng vai trò như một “nhà xưởng”
có
nhiệm vụ khởi tạo đối tượng “cụ thể” khi ứng dụng chạy. Tại thời điểm thiết kế đối tượng này
được
định nghĩa trừu tượng.
3. Ứng dụng
Thường được dùng trong bộ phát triển (toolkit) hay framework, ở đó, đoạn mã của framework cần
thiết phải tạo một đối tượng là những lớp con của ứng dụng sử dụng framework đó
4. Chương trình minh họa
Color.java
public interface color {
void draw();
}
Red.java
public class red implements color {
@Override
public void draw() {
System.out.println(" day la mau do");
}}
Blue.java

public class blue implements color{
@Override
public void draw() {
System.out.println("day la mau xanh");
}}
colorFactory.java
public class ColorFactory {
//use getShape method to get object of type shape
public color getColor(String ColorType) {
if (ColorType == null) {
return null;
}
if (ColorType.equalsIgnoreCase("red")) {
return new red();
} else if (ColorType.equalsIgnoreCase("blue")) {
return new blue();
}
return null;
}
}
FactoryPattern.java
public class Factorypattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
ColorFactory factorty=new ColorFactory();
color col=factorty.getShape("red");
col.draw();

color col1=factorty.getShape("blue");
col1.draw();
}
}
Kết quả chạy
II. Abstract Factory Pattern
1. Sơ đồ mẫu
2. Ý nghĩa
Abstract Factory cung cấp một giao diện lớp có chức năng tạo ra một tập hợp các đối tượng
liên quan hoặc phụ thuộc lẫn nhau mà không chỉ ra đó là những lớp cụ thể nào tại thời điểm
thiết kế.
3. Ứng dụng
-Phía trinh khách sẽ không phụ thuộc vào việc những sản phẩm được tạo ra như thế nào
-Ứng dụng sẽ được cấu hình với một hoặc nhiều họ sản phẩm
-Các đổi tượng cần phải được tạo ra như một tập hợp để có thể tương thích với nhau
-Cung cấp một tập các lớp và muốn thể hiện các ràng buộc các quan hệ giữa chúng mà
không phải là thực thi của chúng
4. Chương trình minh họa
Shape.class
public interface shape {
void draw();
}
Rectangle.class
public class rectangle implements shape{
@Override
public void draw() {
System.out.println("day la hinh chu nhat");
}
}
Oval.class

public class oval implements shape{
@Override
public void draw() {
System.out.println("day la hinh oval");
}
}
Color.java
public interface color {
void draw();
}
Red.java
public class red implements color {
@Override
public void draw() {
System.out.println(" day la mau do");
}}
Blue.java
public class blue implements color{
@Override
public void draw() {
System.out.println("day la mau xanh");
}}
AbstrachFactory.java
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}
FactoryProducer.java
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){

if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();
}
return null;
}
}
AbstractFactorypattern.java
public class AbstractFactorypattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
shape shape1 = shapeFactory.getShape("OVAL");
shape1.draw();
shape shape2 = shapeFactory.getShape("RECTANGLE");
shape2.draw();
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
color color1 = colorFactory.getColor("RED");
color1.draw();
color color2 = colorFactory.getColor("BLUE");
color2.draw();
}
}
Kết quả
III. Singleton pattern
1. Sơ đồ mẫu

2. Y nghĩa
Singleton Pattern đảm bảo một lớp chỉ có một thực thể (instance) duy nhất được tạo ra
và đồng thời cung cấp một truy cập toàn cục đến đối tượng được tạo ra.
3. Ứng dụng
Chúng ta nên s d ng Singleton trong tr ng h p qu n lý m t lo i d ch v nào ó, nên dùng ử ụ ườ ợ ả ộ ạ ị ụ đ
chung gi a các màn hình:ữ
4. Chương trình minh họa
SingleObject.java
public class SingleObject {
private static SingleObject instance = new SingleObject();
private SingleObject(){
public static SingleObject getInstance(){
return instance;
}
public void showMessage(){
System.out.println("This is singleton pattern!");
}
}
Singletonpattern.java
public class Singletonpattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
SingleObject object = SingleObject.getInstance();
object.showMessage();
}
}
Kết quả :
IV. Builder Pattern

1. Sơ đồ mẫu
2. Y nghĩa
Xây dựng một đối tượng phức tạp sử dụng các đối tượng đơn giản và sử dụng
phương pháp tiếp cận từng bước từng bước một
3. Ứng dụng
Mẫu thiết kế Builder là một mẫu thiết kế tạo lập cho phép client xây dựng một đối tượng
phức tạp bằng cách chỉ cần định nghĩa kiểu và nội dung. Chi tiết phần dựng được ẩn đi
hoàn toàn bên phía client. Động cơ phổ biến nhất cho việc sử dụng Builder là đơn giản
hóa phần code của client trong việc tạo ra các đối tượng phức tạp. Client vẫn có thể
điều khiển các bước được thực hiện bởi Builder mà không cần biết công việc thực sự
được thực hiện như thế nào. Builder thường đóng gói construction của các đối tượng
Composite (một mẫu thiết kế khác) vì các procedure liên quan thường lặp đi lặ lại và
phức tạp.
Một trường hợp nơi Builder có thể có ích khi xây dựng một bộ tạo code. Giả sử bạn
đang viết một ứng dụng viết các stored procedure cho các CSDL khác nhau (SQL
Server, Oracle, DB2). Đầu ra thực sự thì rất khác nhau nhưng những bước khác nhau
của việc tạo các procedure tách biệt thực thi các trạng thai CRUD (Create, Read,
Update, Delete) là tương tự nhau.
Builder là một mẫu thiết kế tạo lập tương tự như các mẫu Factory. Tuy nhiên, Builder
cho bạn nhiều sự kiểm soát hơn trong từng bước trong tiến trình xây dựng có thể được
tùy chỉnh; các mẫu Factory tạo ra các đối tượng trong 1 bước duy nhất.
4. Chương trình minh họa
Item.java
public interface Item {
public String name();
public Packing packing();
public float price();
}
Packing.java
public interface Packing {

public String pack();
}
Wrapper.java
public class Wrapper implements Packing {
@Override
public String pack() {
return "Wrapper";
}
}
Bottle.java
public class Bottle implements Packing {
@Override
public String pack() {
return "Bottle";
}
}
Burger.java
public abstract class Burger implements Item {
@Override
public Packing packing() {
return new Wrapper();
}
@Override
public abstract float price();
}
ColdDrink.java
public abstract class ColdDrink implements Item {
@Override
public Packing packing() {
return new Bottle();

}
@Override
public abstract float price();
}
VegBurger.java
public class VegBurger extends Burger {
@Override
public float price() {
return 25.0f;
}
@Override
public String name() {
return "Veg Burger";
}
}
ChickenBurger.java
public class ChickenBurger extends Burger {
@Override
public float price() {
return 50.5f;
}
@Override
public String name() {
return "Chicken Burger";
}
}
Coke.java
public class Coke extends ColdDrink {
@Override
public float price() {

return 30.0f;
}
@Override
public String name() {
return "Coke";
}
}
Pepsi.java
public class Pepsi extends ColdDrink {
@Override
public float price() {
return 35.0f;
}
@Override
public String name() {
return "Pepsi";
}
}
Meal.java
public class Meal {
private List<Item> items = new ArrayList<Item>();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;

}
public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packing().pack());
System.out.println(", Price : "+item.price());
}
}
}
MealBuilder.java
public class MealBuilder {
public Meal prepareVegMeal (){
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
public Meal prepareNonVegMeal (){
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}
BuilderPattern.java
public class BuilderPattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {

MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal();
System.out.println("Veg Meal");
vegMeal.showItems();
System.out.println("Total Cost: " +vegMeal.getCost());
Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
System.out.println("\n\nNon-Veg Meal");
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost());
}
Kết quả
}
V. Prototype Pattern
1. Sơ đồ mẫu
2. Y nghĩa
Được sử dụng khi bạn muốn tạo ra một đối tượng có kiểu đã được quy định bởi một
thực thể mẫu bằng cách sao chếp thực thể ấy để tạo thành một đối tượng mới
3. Ứng dụng
Mẫu thiết kế Prototype không được sử dụng phổ biến trong việc xây dựng các ứng
dụng nghiệp vụ (business application). Nó thường được sử dụng trong các kiểu ứng
dụng xác định như đồ họa máy tính, CAD (Computer Assisted Drawing), GIS
(Geographic Information Systems) và các trò chơi.
4. Chương trình minh họa
Shape.java
public abstract class Shape implements Cloneable {

private String id;
protected String type;

abstract void draw();

public String getType(){
return type;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
Rectangle.java
public class Rectangle extends Shape {
public Rectangle(){
type = "Rectangle";
}
@Override
public void draw() {

System.out.println("Inside Rectangle::draw() method.");
}
}
Square.java
public class Square extends Shape {
public Square(){
type = "Square";
}
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
ShapeCache.java
public class ShapeCache {
private static Hashtable<String, Shape> shapeMap
= new Hashtable<String, Shape>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// for each shape run database query and create shape
// shapeMap.put(shapeKey, shape);
// for example, we are adding three shapes
public static void loadCache() {

Square square = new Square();
square.setId("1");
shapeMap.put(square.getId(),square);
Rectangle rectangle = new Rectangle();

rectangle.setId("2");
shapeMap.put(rectangle.getId(),rectangle);
}
}
PrototypePattern.java
public class PrototypePattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());
}

}
Kết quả:
VI. Adapter Pattern
1. Sở đồ mẫu
2. Ý nghĩa
Adapter Pattern biến đổi giao diện của một lớp thành một giao diện khác mà các đối tượng
client có thể hiểu được. Lớp với giao diện được tạo ra đó gọi là Adapter. Nguyên tắc cơ bản
của Adapter Pattern nằm ở chỗ làm thế nào để các lớp với các giao diện không tương thích có
thể làm việc được với nhau.
3. Ứng dụng
Khi ta muốn chuyển đổi một lớp với một giao diện thành giao diện mà ta mong muốn.
Xậy dựng, mở rộng các phương thức của lớp có sẵn phù hợp với yêu cầu.
Tái sử dụng giao diện cũ. Giảm thiểu việc viết lại mã lệnh.

4. Chương trình minh họa
MediaPlayer.java
public interface MediaPlayer {
public void play(String audioType, String fileName);
}
AdvancedMediaPlayer.java
public interface AdvancedMediaPlayer {
public void playVlc(String fileName);
public void playMp4(String fileName);
}
VlcPlayer.java
public class VlcPlayer implements AdvancedMediaPlayer{
@Override
public void playVlc(String fileName) {
System.out.println("Playing vlc file. Name: "+ fileName);
}
@Override
public void playMp4(String fileName) {
//do nothing
}
}
Mp4Player.java
public class Mp4Player implements AdvancedMediaPlayer{
@Override
public void playVlc(String fileName) {
//do nothing
}
@Override
public void playMp4(String fileName) {
System.out.println("Playing mp4 file. Name: "+ fileName);

}
}
MediaAdapter.java
public class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMusicPlayer;
public MediaAdapter(String audioType){
if(audioType.equalsIgnoreCase("vlc") ){
advancedMusicPlayer = new VlcPlayer();
} else if (audioType.equalsIgnoreCase("mp4")){
advancedMusicPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if(audioType.equalsIgnoreCase("vlc")){
advancedMusicPlayer.playVlc(fileName);
}else if(audioType.equalsIgnoreCase("mp4")){
advancedMusicPlayer.playMp4(fileName);
}
}
}
AudioPlayer.java
public class AudioPlayer implements MediaPlayer {
MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
//inbuilt support to play mp3 music files
if(audioType.equalsIgnoreCase("mp3")){
System.out.println("Playing mp3 file. Name: "+ fileName);
}

//mediaAdapter is providing support to play other file formats
else if(audioType.equalsIgnoreCase("vlc")
|| audioType.equalsIgnoreCase("mp4")){
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
}
else{
System.out.println("Invalid media. "+
audioType + " format not supported");
}
}
}
AdapterPattern.java
public class AdapterPattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
AudioPlayer audioPlayer = new AudioPlayer();
audioPlayer.play("mp3", "beyond the horizon.mp3");
audioPlayer.play("mp4", "alone.mp4");
audioPlayer.play("vlc", "far far away.vlc");
audioPlayer.play("avi", "mind me.avi");
}

}
Kết quả :
VII. Bridge Pattern
1. Sở đồ mẫu
2. Ý nghĩa

tách rời những xử lý của một lớp ra lớp khác, từ đó có thể dễ dàng biến đổi hoặc thay thế mà
không làm ảnh hưởng đến những nơi có sử dụng lớp ban đầu
3. Ứng dụng
Mẫu thiết kế Bridge được sử dụng để tách một abstraction khỏi implementation của nó
để cả hai có thể thay đổi đôc lập nhau. Bridge là một trong những mẫu thiết kế cấu trúc
mức cao và mục tiêu chính của nó là thông qua abstraction giúp cho các lập trình viên
viết code tốt hơn. Một mẫu thiết kế Bridge được tạo ra bằng cách di chuyển một tập các
abstract operation sang một interface để cả client và dịch vụ có thể thay đổi mà không
phụ thuộc lẫn nhau.
4. Chương trình minh họa
DrawAPI.java
public interface DrawAPI {
public void drawCircle(int radius, int x, int y);
}
RedCircle.java
public class RedCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: red, radius: "
+ radius +", x: " +x+", "+ y +"]");
}
}
GreenCircle.java
public class GreenCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println("Drawing Circle[ color: green, radius: "
+ radius +", x: " +x+", "+ y +"]");
}
}

Shape.java
public abstract class Shape {
protected DrawAPI drawAPI;
protected Shape(DrawAPI drawAPI){
this.drawAPI = drawAPI;
}
public abstract void draw();
}
Circle.java
public class Circle extends Shape {
private int x, y, radius;
public Circle(int x, int y, int radius, DrawAPI drawAPI) {
super(drawAPI);
this.x = x;
this.y = y;
this.radius = radius;
}
public void draw() {
drawAPI.drawCircle(radius,x,y);
}
}
BridgePattern.java
public class BridgePattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Shape redCircle = new Circle(100,100, 10, new RedCircle());
Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
redCircle.draw();

greenCircle.draw(); // TODO code application logic here
}

}
VIII. Composite Pattern
1. Sơ đồ mẫu
2. Ý nghĩa
Một đối tượng composite được tạo thành từ một hay nhiều đối tượng tương tự nhau (hoặc có
một số chức năng tương tự nhau). Ý tưởng ở đây là có thể thao tác trên một nhóm đối tượng
theo cách như thao tác trên một đối tượng duy nhất.
3. Ứng dụng
Sử dụng để xây dựng các hệ thống phân cấp bán toàn bộ hoăc biểu diễu dự liệu dưới cấu trúc
dạng cây
4. Chương trình minh họa
Employee.java
public class Employee {
private String name;
private String dept;
private int salary;
private List<Employee> subordinates;
// constructor
public Employee(String name,String dept, int sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new ArrayList<Employee>();
}
public void add(Employee e) {
subordinates.add(e);
}

public void remove(Employee e) {
subordinates.remove(e);
}
public List<Employee> getSubordinates(){
return subordinates;
}
public String toString(){
return ("Employee :[ Name : "+ name
+", dept : "+ dept + ", salary :"
+ salary+" ]");
}
}
CompositePattern.java
/**
*
* @author
*/
public class CompositePattern {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Employee CEO = new Employee("John","CEO", 30000);
Employee headSales = new Employee("Robert","Head Sales", 20000);
Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
Employee clerk1 = new Employee("Laura","Marketing", 10000);
Employee clerk2 = new Employee("Bob","Marketing", 10000);
Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
CEO.add(headSales);

CEO.add(headMarketing);
headSales.add(salesExecutive1);
headSales.add(salesExecutive2);
headMarketing.add(clerk1);
headMarketing.add(clerk2);
//print all employees of the organization
System.out.println(CEO);
for (Employee headEmployee : CEO.getSubordinates()) {
System.out.println(headEmployee);
for (Employee employee : headEmployee.getSubordinates()) {
System.out.println(employee);
}
}
}
}
Kết quả :
IX. Decorator Pattern
1. Sơ đồ mẫu
2. Ý nghĩa
Cho phép thêm một phương thức (method) hoặc thuộc tính (field, property) vào một đối
tượng có sẵn một cách linh động.
Về bản chất, design pattern này sẽ tạo ra một lớp bao trùm lên đối tượng đã tồn tại, và khi
sử dụng lớp mới này, ta có thể truy xuất các thuộc tính của đối tượng cũ cũng như có thêm
những phương thức và thuộc tính mới ở lớp mới vừa được tạo ra.
3. Ứng dụng
Động cơ của mẫu thiết kế Decorator là cho bạn mở rộng một hành vi của đối tượng một
cách linh hoạt. Khả năng này là để gán hành vi mới một cách linh hoạt cho các đối
tượng được thực hiện bới một lớp Decorator.
Mẫu thiết kế Decorator kết hợp tính đa hình với quyền ủy thác (delegation). Đó là tính
đa hình với lớp gốc để cho các client có thể thực thi nó như lớp gốc. Trong hầu hết các

trường hợp, những lời gọi phương thức được ủy thác cho lớp gốc và sau đó các kết
quả được thực hiện bên trên, hoặc được decorate, với chức năng bổ sung. Decoration
là một kỹ thuật linh hoạt vì nó thực hiện vào lúc runtime.
4. Chương trình minh họa
Shape.java
public interface Shape {
void draw();
}
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Shape: Rectangle");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Shape: Circle");
}
}
ShapeDecorator.java
public abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape;
public ShapeDecorator(Shape decoratedShape){
this.decoratedShape = decoratedShape;
}
public void draw(){
decoratedShape.draw();

}
}
RedShapeDecorator.java
public class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) {
super(decoratedShape);
}
@Override
public void draw() {
decoratedShape.draw();
setRedBorder(decoratedShape);
}
private void setRedBorder(Shape decoratedShape){
System.out.println("Border Color: Red");
}
}
DecoratorPattern.java
public class DecoratorPattern {