BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC SƯ PHẠM KĨ THUẬT TP.HCM
KHOA CÔNG NGHỆ THÔNG TIN
BÁO CÁO 10 MẪU HÀNH VI
MÔN HỌC: MẪU THIẾT KẾ PHẦN MỀM
HỌC KỲ II – NĂM HỌC 2023-2024
Giảng viên hướng dẫn: ThS. Nguyễn Minh Đạo
Sinh viên thực hiện: Lê Tân - 21110296
Thành phố Hồ Chí Minh, Tháng 5 năm 2024
DANH SÁCH THÀNH VIÊN THAM BÁO CÁO
HỌC KỲ II, NĂM HỌC 2023 – 2024 STT Họ và tên MSSV
Tỷ lệ % hoàn thành 1 Lê Tân 21110296 100%
Điểm số: ……………
Nhận xét của giáo viên:………………………………………………….
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
………………………………………………………………………………………
……………………………………………………………………………………… LỜI CẢM ƠN
Để hoàn thành tốt đề tài và bài báo cáo này, em xin gửi lời cảm ơn chân
thành đến giảng viên Nguyễn Minh Đạo, người đã trực tiếp hỗ trợ em trong suốt
quá trình làm đề tài. Em cảm ơn thầy đã đưa ra những lời khuyên từ kinh nghiệm
thực tiễn của mình để định hướng cho em đi đúng với yêu cầu của báo cáo, luôn
giải đáp thắc mắc và đưa ra những góp ý, chỉnh sửa kịp thời giúp em khắc phục
nhược điểm và hoàn thành tốt cũng như đúng thời hạn đã đề ra.
Em cũng xin gửi lời cảm ơn chân thành các quý thầy cô trong khoa Đào tạo
Chất Lượng Cao nói chung và ngành Công Nghệ Thông Tin nói riêng đã tận tình
truyền đạt những kiến thức cần thiết giúp em có nền tảng để làm nên đề tài này, đã
tạo điều kiện để em có thể tìm hiểu và thực hiện tốt đề tài. Cùng với đó, em xin
được gửi cảm ơn đến các bạn cùng khóa đã cung cấp nhiều thông tin và kiến thức
hữu ích giúp em có thể hoàn thiện hơn đề tài của mình.
Báo cáo được em thực hiện trong khoảng thời gian ngắn, với những kiến
thức còn hạn chế cùng nhiều hạn chế khác về mặt kĩ thuật và kinh nghiệm trong
việc thực hiện một dự án phần mềm. Do đó, trong quá trình làm nên đề tài có
những thiếu sót là điều không thể tránh khỏi nên em rất mong nhận được những ý
kiến đóng góp quý báu của các quý thầy cô để kiến thức của em được hoàn thiện
hơn và em có thể làm tốt hơn nữa trong những lần sau. Em xin chân thành cảm ơn.
Cuối lời, em kính chúc quý thầy, quý cô luôn dồi dào sức khỏe và thành
công hơn nữa trong sự nghiệp trồng người. Một lần nữa em xin chân thành cảm ơn.
Tp Hồ Chí Minh ngày 5 tháng 6 năm 2024 MỤC LỤC
PHẦN I : NỘI DUNG................................................................................................................................1 1.
Mẫu Design Pattern Visitor.........................................................................................................1
Lý thuyết:...........................................................................................................................................1
Phân tích mẫu code............................................................................................................................1 2.
Mẫu Design Pattern Iterator.......................................................................................................5
Lý thuyết:...........................................................................................................................................5
Phân tích mẫu code:..........................................................................................................................5 3.
Mẫu Design Pattern Mediator.....................................................................................................9
Lý thuyết:...........................................................................................................................................9
Phân tích mẫu code............................................................................................................................9 4.
Mẫu Design Pattern Responsibility...........................................................................................12
Lý thuyết:.........................................................................................................................................12
Phân tích mẫu code..........................................................................................................................13 5.
Mẫu Design Pattern State..........................................................................................................16
Lý thuyết:.........................................................................................................................................16
Phân tích mẫu code..........................................................................................................................16 6.
Mẫu Design Pattern Memento...................................................................................................19
Lý thuyết:.........................................................................................................................................19
Phân tích mẫu code..........................................................................................................................20 7.
Mẫu Design Design Pattern Command.....................................................................................22
Lý thuyết:.........................................................................................................................................22
Phân tích mẫu code..........................................................................................................................22 9.
Mẫu Design Pattern Observer...................................................................................................26
Lý thuyết:.........................................................................................................................................26
Phân tích mẫu code..........................................................................................................................26 10.
Mẫu Design Pattern Template...............................................................................................28
Lý thuyết:.........................................................................................................................................28
Phân tích mẫu code..........................................................................................................................28
PHẦN II : KẾT LUẬN............................................................................................................................30 PHẦN I : NỘI DUNG
1. Mẫu Design Pattern Visitor Lý thuyết:
Mẫu Design Pattern Visitor là một mẫu thiết kế thuộc nhóm Behavioral
Pattern, được sử dụng để thực hiện một hoạt động hoặc một tập hợp các hoạt
động trên một tập hợp các đối tượng của một cấu trúc đối tượng, mà không
cần thay đổi cấu trúc của chúng. Mẫu này cho phép bạn thêm các hoạt động
mới mà không phải thay đổi các lớp đối tượng đã tồn tại, mà chỉ cần thêm một Visitor mới. Phân tích mẫu code
Bước 1: Xác định interface DocumentVisitor Đầu tiên ta cần tạo một đối
tượng interface DocumentVisitor để định nghĩa các phương thức mà các
đối tượng ReportVisitor và ValidationVisitor sẽ tiến triển khai để tương tác với các đối tượng. 1 package org.example;
public interface DocumentVisitor {
void visitHeading(Heading heading);
void visitParagraph(Paragraph paragraph); void visitImage(Image image); }
Bước 2: Tạo lớp Element Định nghĩa các phương thức mà các lớp
con cụ thể sẽ kế thừa và sử dụng để giao tiếp qua Visitor. package org.example;
public class ReportVisitor implements DocumentVisitor { private String report = ""; @Override
public void visitHeading(Heading heading) {
report += "ReportVisitor_Heading\n"; } @Override
public void visitParagraph(Paragraph paragraph) {
report += "ReportVisitor_Paragraph\n"; } @Override
public void visitImage(Image image) {
report += "ReportVisitor_Image\n"; } public void printReport() { System.out.println(report); } } package org.example;
public class ValidationVisitor implements DocumentVisitor { private String report = ""; @Override
public void visitHeading(Heading heading) {
report += "ValidationVisitor_Heading\n"; } @Override
public void visitParagraph(Paragraph paragraph) {
report += "ValidationVisitor_Paragraph\n"; } @Override 2
public void visitImage(Image image) {
report += "ValidationVisitor_Image\n"; } public void printReport() { System.out.println(report); } }
Bước 3: Tạo các lớp cụ thể kế thừa từ DocumentElement. Mỗi lớp
này đại diện cho một thành viên trong nhóm. package org.example;
public class Heading implements DocumentElement{ String text; public Heading(String text) { this.text = text; } public String getText() { return text; } @Override
public void accept(DocumentVisitor documentVisitor) {
documentVisitor.visitHeading(this); } } package org.example;
public class Image implements DocumentElement{ public String url; public Image(String url) { this.url = url; } public String getText() { return url; } @Override
public void accept(DocumentVisitor documentVisitor) {
documentVisitor.visitImage(this); } } 3 4 package org.example;
public class Paragraph implements DocumentElement{ String context;
public Paragraph(String context) { this.context = context; } public String getText() { return context; } @Override
public void accept(DocumentVisitor documentVisitor) {
documentVisitor.visitParagraph(this); } }
Bước 4: Thử nghiệm Tạo một lớp để thử nghiệm sự tương tác giữa
các thành viên thông qua Visitor.
Trong ví dụ này, các đối tượng Image, Heading và Paragraph gửi tin nhắn
qua Visitor, giúp giảm sự phụ thuộc lẫn nhau và làm cho mã nguồn dễ quản
lý và mở rộng hơn. Mẫu thiết kế Visitor cho phép thêm các hoạt động mới
vào các lớp mà không cần thay đổi chúng. Điều này giúp mã nguồn trở nên
linh hoạt hơn và dễ dàng mở rộng hơn. 5
2. Mẫu Design Pattern Iterator Lý thuyết:
Trong lập trình, Iterator là một design pattern (mẫu thiết kế) được sử dụng
để cung cấp một cách truy cập tuần tự qua các phần tử của một tập hợp mà
không cần tiết lộ cấu trúc nội bộ của tập hợp đó. Iterator cho phép duyệt qua
các phần tử của một tập hợp một cách tuần tự mà không cần biết chi tiết
cách tập hợp được triển khai.
Mẫu Iterator là một mẫu thiết kế hành vi trong lập trình hướng đối tượng.
Nó cho phép người dùng duyệt qua các phần tử của một tập hợp mà không
cần tiết lộ cấu trúc nền tảng của tập hợp đó (danh sách, ngăn xếp, …), Mẫu
này giúp người dùng tách biệt việc duyệt qua các tập hợp khỏi cách tập hợp
được cấu trúc, làm cho việc sử dụng các tập hợp trở nên linh hoạt và đơn giản hơn.
Phân tích mẫu code:
Bước 1: Xác định Interface Iterator Đầu tiên, ta cần tạo một lớp để
định nghĩa các phương thức mà các đối tượng ConcreteIterator sẽ
triển khai để tương tác với các đối tượng Collection. package org.example; import java.util.Iterator; import java.util.List;
public class ChannelIterator implements Iterator { private List channels; private int position;
public ChannelIterator(List channels) { this.channels = channels; this.position = 0; } @Override public boolean hasNext() {
return position < channels.size(); } @Override public Channel next() {
return channels.get(position++); } 6 public List getChannels() { return channels; } public int getPosition() { return position; }
public void setChannels(List channels) { this.channels = channels; }
public void setPosition(int position) { this.position = position; } }
Bước 2: Tạo Lớp Collection Lớp Collection định nghĩa các phương
thức mà các lớp con cụ thể sẽ kế thừa và sử dụng để giao tiếp qua Iterator. package org.example; import java.util.ArrayList; import java.util.Iterator; import java.util.List;
public class ChanneCollection { private List channels; public ChanneCollection() {
this.channels = new ArrayList<>(); }
public void addChannel(Channel channel) { channels.add(channel); }
public Iterator createIterator() {
return new ChannelIterator(channels); } public List getChannels() { return channels; } 7
public void setChannels(List channels) { this.channels = channels; } }
Bước 3: Implement ConcreteIterator Lớp ConcreteIterator sẽ triển
khai Iterator và điều phối giao tiếp giữa các Collection. Java package org.example; public class Channel { private String name; private ChannelGenre genre;
public Channel(String name, ChannelGenre genre) { this.name = name; this.genre = genre; } public String toString() {
return "Channel: " + "name='" + name +", genre=" + genre ; } }
Bước 4: Thử nghiệm Tạo một lớp để thử nghiệm sự tương tác giữa
các thành viên thông qua Iterator. package org.example; import java.util.Iterator; public class Main {
public static void main(String[] args) {
ChanneCollection channelCollection = new ChanneCollection();
channelCollection.addChannel(new Channel("ThoiSU", ChannelGenre.NEWS));
channelCollection.addChannel(new Channel("TheThao", ChannelGenre.SPORTS));
channelCollection.addChannel(new Channel("PhimViet", ChannelGenre.MOVIES));
channelCollection.addChannel(new Channel("TreEm", ChannelGenre.KIDS));
channelCollection.addChannel(new Channel("TreEm2", ChannelGenre.KIDS));
channelCollection.addChannel(new Channel("TreEm3", ChannelGenre.KIDS)); 8
Iterator iterator = channelCollection.createIterator(); while (iterator.hasNext()) {
Channel channel = iterator.next();
System.out.println(channel.toString()); } } } Bước 5: Kết quả
Trong đoạn code này, các đối tượng được duyệt qua bởi Iterator, giúp
giảm sự phụ thuộc lẫn nhau và làm cho mã nguồn dễ quản lý và mở
rộng hơn. Mẫu thiết kế Iterator cho phép truy cập tuần tự vào các phần
tử của một đối tượng phức tạp mà không cần tiết lộ cấu trúc nội bộ
của nó. Điều này giúp mã nguồn trở nên linh hoạt hơn và dễ dàng mở rộng hơn. 9
3. Mẫu Design Pattern Mediator Lý thuyết:
Mediator pattern là một trong những design pattern thuộc nhóm Behavioral
Pattern trong lập trình hướng đối tượng. Mục đích chính của nó là giảm sự
phụ thuộc giữa các đối tượng trong hệ thống bằng cách tạo ra một đối tượng
trung gian (mediator) để quản lý các thông điệp và sự giao tiếp giữa chúng. Phân tích mẫu code
Bước 1: Đầu tiên, ta cần tạo một interface Mediator để định nghĩa các
phương thức để triển khai các đối tượng package org.example; public interface Mediator {
public void handleEvent(Colleague colleague, String text); }
Bước 2: Tạo lớp abstract class Colleague định nghĩa các phương thức
mà các lớp con cụ thể sẽ kế thừa và sử dụng để giao tiếp qua Mediator. package org.example;
public abstract class Colleague { public Mediator mediator;
public Colleague(Mediator mediator){ this.mediator = mediator; }
public abstract void sendEvent(String str);
public abstract void receiveEvent(String str); }
Bước 3: Tạo các lớp cụ thể kế thừa từ Colleague. Mỗi lớp này đại
diện cho một thành viên trong nhóm. package org.example;
public class CinemaHall extends Colleague{
public CinemaHall(Mediator mediator) { super(mediator); } @Override
public void sendEvent(String text) {
System.out.println("Cinema Hall send event: " + text); 10 } @Override
public void receiveEvent(String text) {
System.out.println("Cinema Hall received event: " + text); } } package org.example;
public class PaymentService extends Colleague{
public PaymentService(Mediator mediator) { super(mediator); } @Override
public void sendEvent(String text) {
// System.out.println("Ticket " + text + " was paid");
// Colleague cinemaHall = new CinemaHall(mediator);
// mediator.handleEvent(cinemaHall, text);}
System.out.println("Payment Service send event: " + text); } @Override
public void receiveEvent(String text){
System.out.println("Payment Service received event: " + text); } } package org.example;
public class TicketCounter extends Colleague{
public TicketCounter(Mediator mediator) { super(mediator); } @Override
public void sendEvent(String text){
// System.out.println("Buy ticket name: " + text);
// Colleague paymentService = new PaymentService(mediator);
// mediator.handleEvent(paymentService, text);
System.out.println("Ticket Counter send event: " + text); } @Override
public void receiveEvent(String text){
System.out.println("Ticket Counter received event: " + text); 11 } }
Bước 4: Implement Lớp CinemaMediator sẽ triển khai Mediator và
điều phối giao tiếp giữa các đối tượng. package org.example;
public class CinemaMediator implements Mediator{
private TicketCounter ticketCounter;
private PaymentService paymentService;
private CinemaHall cinemaHall;
public CinemaMediator(TicketCounter ticketCounter,
PaymentService paymentService, CinemaHall cinemaHall) {
this.ticketCounter = ticketCounter;
this.paymentService = paymentService; this.cinemaHall = cinemaHall; } public CinemaMediator() { }
public void handleEvent(Colleague colleague, String event) { colleague.sendEvent(event); } }
Bước 5: Thử nghiệm Tạo một lớp để thử nghiệm (CinemaDemo) sự
tương tác giữa các thành viên thông qua Mediator. package org.example;
public class CinemaSystemDemo {
public static void main(String[] args) {
Mediator mediator = new CinemaMediator();
Colleague ticketCounter = new TicketCounter(mediator);
Colleague paymentService = new PaymentService(mediator); String text = "DragonBall";
ticketCounter.sendEvent(text);
ticketCounter.receiveEvent(text); String text2 = "Drink";
paymentService.sendEvent(text2);
paymentService.receiveEvent(text2); 12 } }
Trong ví dụ cụ thể này, việc sử dụng mẫu thiết kế Mediator giữa các
đối tượng Teacher và Student mang lại nhiều lợi ích đáng kể cho kiến
trúc của hệ thống. Thay vì cho phép các đối tượng này trực tiếp giao
tiếp với nhau, chúng thông qua một trung gian giúp giảm sự phụ thuộc
trực tiếp, từ đó làm cho mã nguồn trở nên dễ quản lý và mở rộng hơn.
Mediator pattern tạo ra một lớp trung gian giữa các đối tượng, nơi mà
toàn bộ giao tiếp giữa chúng được quản lý và điều phối. Điều này giúp
loại bỏ sự phức tạp của các liên kết trực tiếp giữa các lớp, thay vào đó
tạo ra một giao tiếp tập trung thông qua Mediator. Nhờ vậy, mã nguồn
trở nên linh hoạt hơn, với khả năng tái sử dụng cao hơn do các đối
tượng không còn phụ thuộc trực tiếp vào nhau.
Đặc biệt, Mediator pattern là một công cụ mạnh mẽ khi xây dựng các
hệ thống có khả năng mở rộng và bảo trì dễ dàng. Khi cần thêm mới
các tính năng hoặc đối tượng, chỉ cần chỉnh sửa Mediator mà không
cần phải thay đổi cấu trúc của các đối tượng đang tồn tại. Điều này
giúp giảm thiểu rủi ro gây ra bởi sự thay đổi và làm cho quá trình phát
triển và bảo trì mã nguồn trở nên hiệu quả hơn.
4. Mẫu Design Pattern Responsibility Lý thuyết:
Pattern Chain of Responsibility là một mẫu thiết kế phần mềm thuộc nhóm
các mẫu thiết kế hành vi (behavioral design patterns). Mục tiêu chính của nó
là giúp giảm sự ràng buộc giữa các đối tượng gửi yêu cầu và những đối tượng xử lý yêu cầu.
Trong mẫu thiết kế này, mỗi đối tượng trong chuỗi sẽ có khả năng xử lý một
yêu cầu cụ thể. Khi một yêu cầu được gửi, nó sẽ được chuyển từ đối tượng 13
này sang đối tượng khác trong chuỗi cho đến khi nó được xử lý hoặc cho
đến khi không còn đối tượng nào có khả năng xử lý nữa.
Một vài thành phần chính của mẫu thiết kế Chain of Responsibility bao gồm:
Handler (Xử lý): Đây là giao diện hoặc lớp trừu tượng định nghĩa các
phương thức chung cho việc xử lý yêu cầu. Mỗi handler sẽ biết về handler tiếp theo trong chuỗi.
ConcreteHandler (Xử lý cụ thể): Là các lớp cụ thể triển khai giao diện
Handler. Mỗi ConcreteHandler sẽ quyết định xem liệu nó có thể xử lý yêu
cầu đó không. Nếu không, nó sẽ chuyển yêu cầu cho handler tiếp theo trong chuỗi.
Client (Khách hàng): Là đối tượng gửi yêu cầu và được liên kết với handler đầu tiên trong chuỗi. Phân tích mẫu code
Bước 1: Tạo một lớp Request để đại diện cho yêu cầu với các thuộc
tính như authenticated, authorized, và data. package org.example; public class Request {
private boolean authenticated; private boolean authorized; private String data;
public Request(boolean authenticated, boolean authorized, String data) {
this.authenticated = authenticated; this.authorized = authorized; this.data = data; } public String getData() { return data; }
// Thêm các phương thức để kiểm tra trạng thái xác thực và phân quyền
public boolean isAuthenticated() { return authenticated; }
public boolean isAuthorized() { return authorized; 14 } }
Bước 2: Tạo một lớp trừu tượng Handler với phương thức để thiết lập
handler tiếp theo trong chuỗi và phương thức để xử lý yêu cầu.
Tạo các lớp con kế thừa từ Handler và triển khai phương thức xử lý yêu cầu cụ thể.
Thiết lập chuỗi xử lý yêu cầu bằng cách thiết lập handler tiếp theo cho mỗi handler. package org.example;
public abstract class Handler {
protected Handler nextHandler;
// Phương thức để thiết lập handler tiếp theo trong chuỗi
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler; }
// Phương thức để xử lý yêu cầu
public boolean handleRequest(Request request) {
boolean handled = handlerRequest(request);
if (!handled && nextHandler != null) {
handled = nextHandler.handleRequest(request); } return handled; }
// Phương thức trừu tượng để xử lý yêu cầu cụ thể
protected abstract boolean handlerRequest(Request request); }
Bước 3: Trong hàm main, tạo các đối tượng handler và thiết lập chuỗi xử lý yêu cầu.
Tạo một đối tượng Request mới.
Gọi phương thức handleRequest trên đối tượng handler đầu tiên trong
chuỗi và truyền vào đối tượng Request.. package org.example; public class Main {
public static void main(String[] args) { // Tạo các handler
Handler authenticationHandler = new AuthenticationHandler(); 15
Handler authorizationHandler = new AuthorizationHandler();
Handler loggingHandler = new LoggingHandler();
// Thiết lập chuỗi xử lý
authenticationHandler.setNextHandler(authorizationHandler);
authorizationHandler.setNextHandler(loggingHandler); // Tạo yêu cầu
Request request = new Request(true, true, "Some data"); // Xử lý yêu cầu
authenticationHandler.handleRequest(request); } }
Bước 4: Thử nghiệm package org.example; public class Main {
public static void main(String[] args) { // Tạo các handler
Handler authenticationHandler = new AuthenticationHandler();
Handler authorizationHandler = new AuthorizationHandler();
Handler loggingHandler = new LoggingHandler();
// Thiết lập chuỗi xử lý
authenticationHandler.setNextHandler(authorizationHandler);
authorizationHandler.setNextHandler(loggingHandler); // Tạo yêu cầu
Request request = new Request(true, true, "Some data"); // Xử lý yêu cầu
authenticationHandler.handleRequest(request); } } Bước 5: Kết quả 16