使用Plantuml绘制23种设计模式的UML图

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u010144805/article/details/82415385

使用Plantuml绘制23种设计模式的UML图

生成的图片可以在我的另一篇博客中查看：安卓每日背诵一：23种设计模式和7大设计原则

1、单例模式(Singleton pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Singleton(单例模式)" #DDDDDD {

    class Singleton
    {
    +getInstance():Singleton
    -Singleton()
    }
    note right: 单例类

    Singleton <.. Client
}
@enduml

2、生成器模式(Builder pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Builder(生成器模式)" #DDDDDD {
    abstract class Builder
    {
    +buildPartA():void
    +buildPartB():void
    +buildPartC():void
    }
    note right: 抽象Builder类

    class ConcreteBuilder
    {
    +buildPartA():void
    +buildPartB():void
    +buildPartC():void
    }
    note right: 具体Builder类

    class Director
    {
    +construct()
    }
    note right:统一组装过程

    abstract class Product
    note right:产品的抽象类

    Director o-- Builder
    Builder <|-- ConcreteBuilder
    Product <.. ConcreteBuilder:<<use>>
}
@enduml

3、原型模式(prototype pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Protype(原型模式)" #DDDDDD {
    class Protype<< (A,#FF7700) interface>>
    {
    +clone()
    }
    note right: 原型的抽象类或接口

    class ConcreteProtype
    {
    +clone()
    }
    note right: 具体的原型类

    Protype <|.. ConcreteProtype
    Client ..> Protype:<<import>>
}
@enduml

4、工厂方法模式(factorymethod pattern)

@startuml
skinparam classAttributeIconSize 0

package "class FactoryMethod(工厂方法模式)" #DDDDDD {
    abstract class Factory
    {
    +createProduct():Product
    }

    class ConcreteFactory
    {
    +createProduct():Product
    }

    abstract class Product
    {
    +method():void
    }

    class ConcreteProduct
    {
    +method():void
    }

    Product <|-- ConcreteProduct
    Factory <|-- ConcreteFactory
    ConcreteProduct <.. ConcreteFactory
}
@enduml

5、抽象工厂模式(Abstractfactory pattern)

@startuml
skinparam classAttributeIconSize 0

package "class AbstractFactory(抽象工厂模式)" #DDDDDD {
    abstract class AbstractProductA
    {
    +method():void
    }

    abstract class AbstractProductB
    {
    +method():void
    }

    class ConcreteProductA1
    {
    +method():void
    }

    class ConcreteProductA2
    {
    +method():void
    }

    class ConcreteProductB1
    {
    +method():void
    }

    class ConcreteProductB2
    {
    +method():void
    }

    abstract class AbstractFactory
    {
    +createProductA():AbstractProductA
    +createProductB():AbstractProductB
    }
    note top of AbstractFactory: 抽象工厂

    class ConcreteFactory1
    {
    +createProductA():AbstractProductA
    +createProductB():AbstractProductB
    }

    class ConcreteFactory2
    {
    +createProductA():AbstractProductA
    +createProductB():AbstractProductB
    }

    AbstractProductA <|-- ConcreteProductA1
    AbstractProductA <|-- ConcreteProductA2
    AbstractProductB <|-- ConcreteProductB1
    AbstractProductB <|-- ConcreteProductB2
    AbstractFactory <|-- ConcreteFactory1
    AbstractFactory <|-- ConcreteFactory2
    ConcreteFactory1 ..> ConcreteProductA1
    ConcreteFactory1 ..> ConcreteProductB1
    ConcreteFactory2 ..> ConcreteProductA2
    ConcreteFactory2 ..> ConcreteProductB2
}
@enduml

6、代理模式(Proxy pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Proxy(代理模式)" #DDDDDD {
    class Client

    abstract class Subject
    {
    +visit()
    }
    note right: 抽象主题类

    class RealSubject
    {
    +visit()
    }
    note right: 真实主题类

    class ProxySubject{
    -mSubject:RealSubject
    +visit()
    }
    note right: 代理类

    Subject <.. Client
    Subject <|-- RealSubject
    Subject <|-- ProxySubject
    RealSubject <-- ProxySubject
}
@enduml

7、适配器模式(Adapter pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Adapter(适配器模式)" #DDDDDD {
    class Target<< (I,#FF7700) Interface>>{
    +operation1()
    +operation2():void
    }
    note right: 目标

    class Adapter{
    + operation2()
    }
    note right: 适配器

    class Adaptee{
    + operation3()
    }
    note right: 需要适配的接口

    Target <|.. Adapter
    Adaptee <|-- Adapter
}
@enduml

8、组合模式(composite pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Composite(组合模式)" #DDDDDD {
    class Client

    abstract class Component{
    #name:String
    +Component(String):void
    +doSomething():void
    }

    class Leaf{
    +Component(String):void
    +doSomething():void
    }

    class Composite{
    -components:List<Component>
    +Component(String):void
    +doSomething():void
    +addChild(Component):void
    +getChildren(int):Component
    +removeChild(Component):void
    }

    Component <-- Client
    Component <|-- Leaf
    Component <|-- Composite
    Component <--o Composite
}
@enduml

9、装饰者模式(decorator pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Decorator(装饰模式)" #DDDDDD {

    abstract class Component
    {
    + operate():void
    }
    note top of Component: 抽象组件

    class ConcreteComponent
    {
    + operate():void
    }
    note top of ConcreteComponent: 组件具体实现类

    abstract class Decorator
    {
    - component:Component
    + Decorator(Component)
    + operate():void
    }
    note left: 抽象类装饰者

    class ConreteDecoratorA
    {
    + ConreteDecoratorA(Component)
    + operate():void
    + operateA():void
    + operateB():void
    }

    class ConreteDecoratorB
    {
    + ConreteDecoratorB(Component)
    + operate():void
    + operateA():void
    + operateB():void
    }

    Component <|-- ConcreteComponent
    Component <|-- Decorator
    Component <--o Decorator
    ConreteDecoratorA --|> Decorator
    ConreteDecoratorB --|> Decorator
}
@enduml

10、亨元模式(FlyweightPattern)

@startuml
skinparam classAttributeIconSize 0

package "class Flyweight(享元模式)" #DDDDDD {
    class FlyweightFactory{
    - mMap:HashMap
    + getFlyweight()
    }
    note right: 享元工厂

    class Flyweight{
    + dosomething()
    }
    note right: 享元对象抽象基类或者接口

    class ConcreteFlyweight{
    - intrinsicState:String
    + dosomething()
    }
    note right: 具体的享元对象

    FlyweightFactory *-- Flyweight
    Flyweight <|-- ConcreteFlyweight
}
@enduml

11、外观模式(facade pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Facade(外观模式)" #DDDDDD {
    class Facade{
    + operationA()
    + operationB():void
    + operationC():void
    }
    note right: 系统对外的统一接口

    class SystemA << (I,#FF7700) Interface>>
    class SystemB << (I,#FF7700) Interface>>
    class SystemC << (I,#FF7700) Interface>>
    Facade --> SystemA:<<use>>
    Facade --> SystemB:<<use>>
    Facade --> SystemC:<<use>>
}
@enduml

12、桥接模式(Bridge pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Bridge(桥接模式)" #DDDDDD {

    abstract class Abstraction
    Abstraction : +operation()
    note right: 抽象部分

    class RefinedAbstraction
    note top of RefinedAbstraction:优化的抽象部分

    interface Implementor
    Implementor : +operationImpl()
    note right:实现部分

    class Client
    note right : 客户端

    ConcreteImplementorA : +operationImpl()

    ConcreteImplementorB : +operationImpl()

    Client --> Abstraction
    RefinedAbstraction --|> Abstraction
    Implementor --o Abstraction
    ConcreteImplementorA ..|> Implementor
    ConcreteImplementorB ..|> Implementor
}
@enduml

13、策略模式(strategy pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Strategy(策略模式)" #DDDDDD {
    interface Strategy
    {
    +algorithm()
    }
    note right: 策略的抽象

    class ConcreteStrategyA
    {
    +algorithm()
    }

    class ConcreteStrategyB
    {
    +algorithm()
    }

    class Context
    {
    +setStrategy(Strategy)
    +algorithm()
    }
    note right:上下文环境

    Context o-- Strategy
    Strategy <|.. ConcreteStrategyA
    Strategy <|.. ConcreteStrategyB
}
@enduml

14、状态模式(State pattern)

@startuml
skinparam classAttributeIconSize 0

package "class State(状态模式)" #DDDDDD {
    interface State
    {
    +doSomething():void
    }
    note right: 抽象状态类或状态接口

    class ConcreteStateA
    {
    +doSomething():void
    }

    class ConcreteStateB
    {
    +doSomething():void
    }

    class Context
    {
    +addState(State)
    +doSomething():void
    }
    note right:环境类

    Context -- State
    State <|.. ConcreteStateA
    State <|.. ConcreteStateB
}
@enduml

15、责任链模式(Chainofresponsibility pattern)

@startuml
skinparam classAttributeIconSize 0

package "class ChainOfResponsibility(责任链模式)" #DDDDDD {
    abstract class Handler
    {
    #successor():Handler
    +handleRequest(String):void
    }
    note left: 抽象处理者

    class ConcreteHandler1
    {
    +handleRequest(String):void
    }

    class ConcreteHandler2
    {
    +handleRequest(String):void
    }

    Handler o-- Handler:0..1
    Handler <|-- ConcreteHandler1
    Handler <|-- ConcreteHandler2
    Client ..> Handler
}
@enduml

16、解释器模式(Interpreter pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Interpreter(解释器模式)" #DDDDDD {
    abstract class AbstractExpression
    {
    +interpret(context)
    }
    note top of AbstractExpression: 抽象表达式

    class TerminalExpression
    {
    +interpret(context)
    }
    note bottom of TerminalExpression: 终结符表达式

    class NonTerminalExpression
    {
    +interpret(context)
    }
    note bottom of NonTerminalExpression: 非终结符表达式

    class Context
    note top of Context: 上下文

    AbstractExpression <--o NonTerminalExpression
    AbstractExpression<|-- NonTerminalExpression
    AbstractExpression <|-- TerminalExpression
    AbstractExpression <-- Client
    Context <-- Client
}
@enduml

17、命令模式(Command pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Comand(命令模式)" #DDDDDD {
    class Invoker
    {
    -comand:Comand
    +Invoker(Comand)
    +action():void
    }
    note right: 请求者

    class Receiver
    {
    -comand:Comand
    +action():void
    }
    note right: 接收者

    class Comand<< (I,#FF7700) interface>>
    {
    +execute():void
    }
    note right: 命令

    class ConcreteComand
    {
    -receiver:Receiver
    +ConcreteComand(Comand)
    +execute():void
    }
    note right: 具体命令

    Client..>Invoker
    Client..>Receiver
    Invoker o--> Comand
    Receiver <-- ConcreteComand
    Comand <|.. ConcreteComand
}
@enduml

18、观察者模式(observer pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Observer(观察者模式)" #DDDDDD {
    class Subject<< (A,#FF7700) abstract>>
    {
    +notifyObservers(Object)
    }
    note right: 抽象主题

    class ConcreteSubject
    {
    +notifyObservers(Object)
    }
    note right: 具体主题

    class Observer<< (I,#FF7700) interface>>
    {
    +update(Object)
    }
    note right: 抽象观察者

    class ConcreteObserver
    {
    +update(Object)
    }
    note right: 具体观察者

    Subject <|-- ConcreteSubject
    Subject "1" o-- "0..*" Observer
    Observer <|.. ConcreteObserver
}
@enduml

19、备忘录模式(Memento pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Memento(备忘录模式)" #DDDDDD {

    class Originator
    {
    +restore(Memento)
    +createMemento():Memento
    }
    note right: 负责创建备忘录

    class Memento
    {
    -mState
    +setState(int)
    +getState():int
    }
    note right: 备忘录

    class Caretaker
    {
    -mMemento:Memento
    +restoreMemento():Memento
    +storeMemento(Memento):void
    }
    note right:负责存储备忘录

    Originator ..> Memento
    Memento --o Caretaker
}
@enduml

20、迭代器模式(iterator pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Iterator(迭代器模式)" #DDDDDD {
    class Iterator<< (I,#FF7700) interface>>{
    +next():Object
    +hasNext():boolean
    }
    note right: 迭代器接口

    class ConcreteIterator{
    +next():Object
    +hasNext():boolean
    }
    note right: 具体迭代器类

    class Aggregate<< (I,#FF7700) interface>>{
    +add(Object):void
    +remove(Object):void
    +iterator():Iterator
    }
    note right: 容器接口

    class ConcreteAggregate{
    +add(Object):void
    +remove(Object):void
    +iterator():Iterator
    }
    note right: 具体容器类

    Iterator <|.. ConcreteIterator
    Iterator o-- Aggregate
    Aggregate <|.. ConcreteAggregate
}
@enduml

21、模板方法模式(Template pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Template(模板方法模式)" #DDDDDD {
    class AbsTemplate<< (A,#FF7700) abstract>>{
    #stepOne():void
    #stepTwo():void
    #stepThree():void
    +execute():void
    }
    note right: 定义算法框架的抽象类

    class ConcreteImplA
    note right: 具体实现类A

    class ConcreteImplB
    note right: 具体实现类B

    AbsTemplate <|-- ConcreteImplA
    AbsTemplate <|-- ConcreteImplB
}
@enduml

22、访问者模式(visitor pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Visitor(访问者模式)" #DDDDDD {
    class Visitor<< (I,#FF7700) abstract>>
    {
    +visitElementA(ElementA):void
    +visitElementB(ElementB):void
    }
    note top of Visitor: 访问者接口或抽象类

    class ConcreteVisitorA
    {
    +visitElementA(ElementA):void
    +visitElementB(ElementB):void
    }

    class ConcreteVisitorB
    {
    +visitElementA(ElementA):void
    +visitElementB(ElementB):void
    }

    class Element<< (I,#FF7700) abstract>>
    {
    +accept(Visitor)
    }
    note top of Element: 元素接口或抽象类

    class ElementA
    {
    +accept(Visitor)
    +operationA()
    }

    class ElementB
    {
    +accept(Visitor)
    +operationB()
    }

    class ObjectStructure
    note bottom of ObjectStructure: 管理元素集合的对象结构

    class Client

    Visitor <|-- ConcreteVisitorA
    Visitor <|-- ConcreteVisitorB
    Element <|-- ElementA
    Element <|-- ElementB
    Element --o ObjectStructure
    Client ..> Visitor:<<use>>
    Client ..> ObjectStructure:<<use>>

}
@enduml

23、中介者模式(Mediator pattern)

@startuml
skinparam classAttributeIconSize 0

package "class Mediator(中介者模式)" #DDDDDD {
    abstract class Colleague
    {
    #mediator:Mediator
    +Colleague(Mediator)
    +action():void
    }
    note top of Colleague: 抽象同事类

    class ConcreteColleagueA
    {
    +ConcreteColleagueA(Mediator)
    +action():void
    }

    class ConcreteColleagueB
    {
    +ConcreteColleagueB(Mediator)
    +action():void
    }

    class ConcreteMediator
    {
    +method():void
    }
    note top of ConcreteMediator: 具体中介者

    abstract class Mediator{
    #colleagueA:ConcreteColleagueA
    #colleagueB:ConcreteColleagueB
    +method():void
    +setConcreteColleagueA(ConcreteColleagueA
    +setConcreteColleagueB(ConcreteColleagueB)
    }
    note bottom of Mediator: 抽象中介者

    Colleague <|-- ConcreteColleagueA
    Colleague <|-- ConcreteColleagueB
    ConcreteMediator <-- ConcreteColleagueA
    ConcreteMediator <-- ConcreteColleagueB
    ConcreteMediator --|> Mediator
}
@enduml