Structural on Aurora

Composite Pattern in Design Pattern

Wed, 17 Jun 2020 18:08:39 +0000

组合模式

Overview

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。

组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

主要解决

它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

何时使用

您想表示对象的部分-整体层次结构（树形结构）
您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象

应用实例

算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数

优点

高层模块调用简单
节点自由增加

实现

Employee

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


package individual.cy.learn.pattern.structural.composite;

import java.util.ArrayList;
import java.util.List;

/**
 * @author mystic
 */
public class Employee {
 private final int id;
 private String name;
 private String dept;
 private int salary;
 private final List<Employee> subordinateList;

 public Employee(int id, String name, String dept, int salary) {
 this.id = id;
 this.name = name;
 this.dept = dept;
 this.salary = salary;
 this.subordinateList = new ArrayList<>();
 }

 public void add(Employee employee) {
 subordinateList.add(employee);
 }

 public void remove(Employee employee) {
 subordinateList.remove(employee);
 }

 public int getId() {
 return id;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public String getDept() {
 return dept;
 }

 public void setDept(String dept) {
 this.dept = dept;
 }

 public int getSalary() {
 return salary;
 }

 public void setSalary(int salary) {
 this.salary = salary;
 }

 public List<Employee> getSubordinateList() {
 return subordinateList;
 }

 @Override
 public String toString() {
 return "Employee{" +
 "id=" + id +
 ", name='" + name + '\'' +
 ", dept='" + dept + '\'' +
 ", salary=" + salary +
 '}';
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


package individual.cy.learn.pattern.structural.composite;

/**
 * @author mystic
 */
public class CompositePatternTester {
 public static void main(String[] args) {
 Employee ceo = new Employee(10000, "Adam", "CEO", 70000);

 Employee headSales = new Employee(20000, "Robert", "Head Sales", 20000);
 Employee headMarketing = new Employee(30000, "Michel", "Head Marketing", 20000);

 Employee salesExecutive1 = new Employee(20001, "Richard", "Sales", 10000);
 Employee salesExecutive2 = new Employee(20002, "Rob", "Sales", 10000);

 Employee clerk1 = new Employee(30001, "Laura", "Marketing", 10000);
 Employee clerk2 = new Employee(30002, "Bob", "Marketing", 10000);

 ceo.add(headSales);
 ceo.add(headMarketing);

 headSales.add(salesExecutive1);
 headSales.add(salesExecutive2);

 headMarketing.add(clerk1);
 headMarketing.add(clerk2);

 System.out.println("ceo = " + ceo);

 System.out.println();

 // print ceo immediate subordinate
 ceo.getSubordinateList().forEach(System.out::println);

 System.out.println();

 // print ceo immediate subordinate's immediate subordinate
 ceo.getSubordinateList().stream()
 .flatMap(ceoSubordinate -> ceoSubordinate.getSubordinateList().stream())
 .forEach(System.out::println);
 }
}

1
2
3
4
5
6
7
8
9


ceo = Employee{id=10000, name='Adam', dept='CEO', salary=70000}

Employee{id=20000, name='Robert', dept='Head Sales', salary=20000}
Employee{id=30000, name='Michel', dept='Head Marketing', salary=20000}

Employee{id=20001, name='Richard', dept='Sales', salary=10000}
Employee{id=20002, name='Rob', dept='Sales', salary=10000}
Employee{id=30001, name='Laura', dept='Marketing', salary=10000}
Employee{id=30002, name='Bob', dept='Marketing', salary=10000}

Bridge Pattern in Design Pattern

Wed, 10 Jun 2020 18:24:49 +0000

桥接模式

Overview

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。

这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。

这两种类型的类可被结构化改变而互不影响。

主要解决

在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活

何时使用

实现系统可能有多个角度分类，每一种角度都可能变化

应用实例

墙上的开关，可以看到的开关是抽象的，不用管里面具体怎么实现的

优点

抽象和实现的分离
优秀的扩展能力
实现细节对客户透明

实现

DrawApi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public interface DrawApi {
 /**
 * To draw a circle
 * @param radius radius
 * @param x Abscissa, X-axis
 * @param y ordinate, Y-axis
 */
 void drawCircle(int radius, int x, int y);
}

RedCircle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public class RedCircle implements DrawApi {
 @Override
 public void drawCircle(int radius, int x, int y) {
 System.out.println("[Draw a red circle] radius = " + radius + ", x = " + x + ", y = " + y);
 }
}

PurpleCircle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public class PurpleCircle implements DrawApi {
 @Override
 public void drawCircle(int radius, int x, int y) {
 System.out.println("[Draw a purple circle] radius = " + radius + ", x = " + x + ", y = " + y);
 }
}

BaseShape

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public abstract class BaseShape {
 protected DrawApi drawApi;

 protected BaseShape(DrawApi drawApi) {
 this.drawApi = drawApi;
 }

 /**
 * To draw a geometric shape
 */
 public abstract void draw();
}

Circle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public class Circle extends BaseShape {
 private final int x;
 private final int y;
 private final int radius;

 public Circle(DrawApi drawApi, int x, int y, int radius) {
 super(drawApi);
 this.x = x;
 this.y = y;
 this.radius = radius;
 }

 @Override
 public void draw() {
 drawApi.drawCircle(radius, x, y);
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package individual.cy.learn.pattern.structural.bridge;

/**
 * @author mystic
 */
public class BridgePatternTester {
 public static void main(String[] args) {
 BaseShape redCircle = new Circle(new RedCircle(), 0, 0, 3);
 BaseShape purpleCircle = new Circle(new PurpleCircle(), 0, 6, 3);

 redCircle.draw();
 purpleCircle.draw();
 }
}

1
2


[Draw a red circle] radius = 3, x = 0, y = 0
[Draw a purple circle] radius = 3, x = 0, y = 6

Adapter Pattern in Design Pattern

Sat, 06 Jun 2020 20:58:54 +0000

适配器模式

Overview

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。

这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。

主要解决

主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

何时使用

系统需要使用现有的类，而此类的接口不符合系统的需要。
想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。
通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

应用实例

美国电器 110V，中国 220V，就要有一个适配器将 110V 转化为 220V
在 LINUX 上运行 WINDOWS 程序
Java中JDBC

优点

可以让任何两个没有关联的类一起运行
提高了类的复用
增加了类的透明度
灵活性好

实现

Player Interface

Media Player

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public interface MediaPlayer {
 /**
 * play a media resource
 * @param audioType audio type
 * @param filename file name
 */
 void play(String audioType, String filename);
}

Advanced Media Player

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public interface AdvancedMediaPlayer {
 /**
 * play a vlc resource
 *
 * @param filename file name
 */
 void playVlc(String filename);

 /**
 * play a mp4 resource
 *
 * @param filename file name
 */
 void playMp4(String filename);
}

Player Implementation

MP4 Player

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public class Mp4Player implements AdvancedMediaPlayer {
 @Override
 public void playVlc(String filename) {

 }

 @Override
 public void playMp4(String filename) {
 System.out.println("Mp4Player.playMp4");
 }
}

VLC Player

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public class VlcPlayer implements AdvancedMediaPlayer {
 @Override
 public void playVlc(String filename) {
 System.out.println("VlcPlayer.playVlc");
 }

 @Override
 public void playMp4(String filename) {

 }
}

Adapter

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public class MediaAdapter implements MediaPlayer {

 public AdvancedMediaPlayer advancedMediaPlayer;

 public MediaAdapter(String audioType) {
 audioType = audioType.toLowerCase();
 switch (audioType) {
 case "vlc":
 advancedMediaPlayer = new VlcPlayer();
 break;
 case "mp4":
 advancedMediaPlayer = new Mp4Player();
 break;
 default:
 break;
 }
 }

 @Override
 public void play(String audioType, String filename) {
 audioType = audioType.toLowerCase();
 switch (audioType) {
 case "vlc":
 advancedMediaPlayer.playVlc(filename);
 break;
 case "mp4":
 advancedMediaPlayer.playMp4(filename);
 break;
 default:
 break;
 }
 }
}

Audio Player

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public class AudioPlayer implements MediaPlayer {

 public MediaPlayer mediaAdapter;

 @Override
 public void play(String audioType, String filename) {
 audioType = audioType.toLowerCase();
 switch (audioType) {
 case "mp3":
 System.out.println("AudioPlayer.play: MP3 is playing.");
 break;
 case "vlc":
 case "mp4":
 mediaAdapter = new MediaAdapter(audioType);
 mediaAdapter.play(audioType, filename);
 break;
 default:
 System.out.println("AudioPlayer.play: Invalid Media [ " + audioType + " ], the format is not supported.");
 break;
 }
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.structural.adapter;

/**
 * @author mystic
 */
public class AdapterPatternTester {
 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");

 }
}

1
2
3
4


AudioPlayer.play: MP3 is playing.
Mp4Player.playMp4
VlcPlayer.playVlc
AudioPlayer.play: Invalid Media [ avi ], the format is not supported.

Decorator Pattern in Design Pattern

Sun, 24 May 2020 21:12:03 +0000

装饰器模式

Overview

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。

这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

主要解决

一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用

在不想增加很多子类的情况下扩展类。

应用实例

给画，添加上画框

优点

装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

实现

Shape

Shape Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public interface Shape {
 /**
 * to draw a geometric shape
 */
 void draw();
}

Circle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public class Circle implements Shape {
 @Override
 public void draw() {
 System.out.println("Circle.draw");
 }
}

Rectangle

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public class Rectangle implements Shape {
 @Override
 public void draw() {
 System.out.println("Rectangle.draw");
 }
}

Decorator

AbstractShapeDecorator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public abstract class AbstractShapeDecorator implements Shape {
 protected Shape decoratedShape;

 public AbstractShapeDecorator(Shape decoratedShape) {
 this.decoratedShape = decoratedShape;
 }

 @Override
 public void draw() {
 decoratedShape.draw();
 }
}

RedShapeDecorator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public class RedShapeDecorator extends AbstractShapeDecorator {
 public RedShapeDecorator(Shape decoratedShape) {
 super(decoratedShape);
 }

 @Override
 public void draw() {
 super.draw();
 setRedBorder(decoratedShape);
 }

 private void setRedBorder(Shape decoratedShape) {
 System.out.println("RedShapeDecorator.setRedBorder");
 }
}

VioletShapeDecorator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public class VioletShapeDecorator extends AbstractShapeDecorator {
 public VioletShapeDecorator(Shape decoratedShape) {
 super(decoratedShape);
 }

 @Override
 public void draw() {
 super.draw();
 setVioletBorder(decoratedShape);
 }

 public void setVioletBorder(Shape decoratedShape) {
 System.out.println("VioletShapeDecorator.setVioletBorder");
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


package individual.cy.learn.pattern.structural.decorator;

/**
 * @author mystic
 */
public class DecoratorPatternTester {
 public static void main(String[] args) {
 Shape circle = new Circle();
 Shape redCircle = new RedShapeDecorator(new Circle());
 Shape redRectangle = new RedShapeDecorator(new Rectangle());
 Shape violetCircle = new VioletShapeDecorator(new Circle());
 Shape violetRectangle = new VioletShapeDecorator(new Rectangle());
// Shape redCircle = new RedShapeDecorator(Circle::new);
// Shape redRectangle = new RedShapeDecorator(Rectangle::new);
// Shape violetCircle = new VioletShapeDecorator(Circle::new);
// Shape violetRectangle = new VioletShapeDecorator(Rectangle::new);
 circle.draw();
 redCircle.draw();
 redRectangle.draw();
 violetCircle.draw();
 violetRectangle.draw();
 }
}

1
2
3
4
5
6
7
8
9


Circle.draw
Circle.draw
RedShapeDecorator.setRedBorder
Rectangle.draw
RedShapeDecorator.setRedBorder
Circle.draw
VioletShapeDecorator.setVioletBorder
Rectangle.draw
VioletShapeDecorator.setVioletBorder

如果执行注释的代码,即使用::new创建对象,则输出

1
2
3
4
5


Circle.draw
RedShapeDecorator.setRedBorder
RedShapeDecorator.setRedBorder
VioletShapeDecorator.setVioletBorder
VioletShapeDecorator.setVioletBorder

Proxy Pattern in Design Pattern

Tue, 19 May 2020 15:42:27 +0000

代理模式

Overview

代理模式(Design Pattern)，就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。

它使得客户不能直接与真正的目标对象通信。

代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。

代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。

主要解决

在直接访问对象时带来的问题。

比如说：要访问的对象在远程的机器上。

在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用

想在访问一个类时，进行一些控制

应用实例

买火车票，不一定要去火车站，也可以去代售点
Spring AOP

优点

职责清晰
高扩展性
智能化

实现

Designer Interface

1
2
3
4
5
6
7
8


public interface IDesigner {
 /**
 * some demands needed to be implemented
 *
 * @param demandName demand name
 */
 void implementsDemand(String demandName);
}

Java Designer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class JavaDesigner implements IDesigner {
 private final String name;

 public JavaDesigner(String name) {
 this.name = name;
 }

 @Override
 public void implementsDemand(String demandName) {
 System.out.println("A Java Designer [ " + name + " ] implemented demand: {{ " + demandName + " }} in JAVA!");
 }
}

静态代理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class DesignerProxy implements IDesigner {
 private final IDesigner programmer;

 public DesignerProxy(IDesigner programmer) {
 this.programmer = programmer;
 }

 @Override
 public void implementsDemand(String demandName) {
 programmer.implementsDemand(demandName);
 }
}

1
2
3
4
5
6
7


public class Customer {
 public static void main(String[] args) {
 IDesigner designer = new JavaDesigner("cc");
 IDesigner proxy = new DesignerProxy(designer);
 proxy.implementsDemand("Add User Management");
 }
}

动态代理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class DesignerDynamicProxy implements InvocationHandler {
 private final IDesigner designer;

 public DesignerDynamicProxy(IDesigner designer) {
 this.designer = designer;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 return method.invoke(designer, args);
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public class Customer {

 public static void main(String[] args) {
 // 被代理的真实对象
 IDesigner designer = new JavaDesigner("cc");
 // 创建中介类实例
 InvocationHandler handler = new DesignerDynamicProxy(designer);
 // 动态产生一个代理类
 IDesigner proxy = (IDesigner) Proxy.newProxyInstance(
 designer.getClass().getClassLoader(),
 designer.getClass().getInterfaces(),
 handler);
 // 通过代理类,执行doSomething()方法
 proxy.implementsDemand("Modify User Management");
 }

}

Structural on Aurora

Composite Pattern in Design Pattern

组合模式

Overview

主要解决

何时使用

应用实例

优点

实现

Employee

Tester

相关文章

Bridge Pattern in Design Pattern

桥接模式

Overview

主要解决

何时使用

应用实例

优点

实现

DrawApi

RedCircle

PurpleCircle

BaseShape

Circle

Tester

相关文章

Adapter Pattern in Design Pattern

适配器模式

Overview

主要解决

何时使用

应用实例

优点

实现

Player Interface

Media Player

Advanced Media Player

Player Implementation

MP4 Player

VLC Player

Adapter

Audio Player

Tester

相关文章

Decorator Pattern in Design Pattern

装饰器模式

Overview

主要解决

何时使用

应用实例

优点

实现

Shape

Shape Interface

Circle

Rectangle

Decorator

AbstractShapeDecorator

RedShapeDecorator

VioletShapeDecorator

Tester

相关文章

Proxy Pattern in Design Pattern

代理模式

Overview

主要解决

何时使用

应用实例

优点

实现

Designer Interface

Java Designer

静态代理

动态代理

相关文章