To check the previous article in this Design Patterns in Swift please visit Creational Design Patterns.
Structural Design Patterns play a crucial role in organizing your code and creating flexible, efficient, and scalable systems. In this blog post, we'll explore 7 game-changing Structural Design Patterns for Swift developers, complete with detailed code examples that you can implement in your projects right away. Get ready to turbocharge your Swift code!
1. Adapter: Bridge the Gap Between Incompatible Interfaces
The Adapter pattern allows two incompatible interfaces to work together by wrapping one with an adapter that matches the other's expectations.
protocol Target {
func request()
}
class Adaptee {
func specificRequest() {
print("Specific request")
}
}
class Adapter: Target {
private let adaptee: Adaptee
init(adaptee: Adaptee) {
self.adaptee = adaptee
}
func request() {
adaptee.specificRequest()
}
}
let adaptee = Adaptee()
let adapter: Target = Adapter(adaptee: adaptee)
adapter.request()
2. Bridge: Decouple Abstractions from Implementations
The Bridge pattern decouples an abstraction from its implementation so that the two can vary independently.
protocol Renderer {
func render(shape: String)
}
class VectorRenderer: Renderer {
func render(shape: String) {
print("Drawing \(shape) as vector")
}
}
class RasterRenderer: Renderer {
func render(shape: String) {
print("Drawing \(shape) as raster")
}
}
class Shape {
let renderer: Renderer
init(renderer: Renderer) {
self.renderer = renderer
}
func draw() {
fatalError("Subclasses must implement this method")
}
}
class Circle: Shape {
func draw() {
renderer.render(shape: "circle")
}
}
let vectorRenderer: Renderer = VectorRenderer()
let circle = Circle(renderer: vectorRenderer)
circle.draw()
3. Composite: Treat a Group of Objects as a Single Object
The Composite pattern allows you to treat a group of objects as a single object. This is especially useful when you need to work with a hierarchy of objects that have the same interface.
protocol Component {
func operation()
}
class Leaf: Component {
func operation() {
print("Leaf operation")
}
}
class Composite: Component {
private var children: [Component] = []
func add(_ component: Component) {
children.append(component)
}
func remove(_ component: Component) {
children.removeAll { $0 === component }
}
func operation() {
for child in children {
child.operation()
}
}
}
let leaf1 = Leaf()
let leaf2 = Leaf()
let composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
composite.operation()
4. Decorator: Add New Behavior to Objects Without Modifying Their Classes
The Decorator pattern allows you to add new behavior to objects without modifying their classes. This is achieved by wrapping an object with a decorator that implements the same interface.
protocol Beverage {
func cost() -> Double
func description() -> String
}
class Coffee: Beverage {
func cost() -> Double {
return 1.0
}
func description() -> String {
return "Coffee"
}
}
class BeverageDecorator: Beverage {
private let beverage: Beverage
init(beverage: Beverage) {
self.beverage = beverage
}
func cost() -> Double {
return beverage.cost()
}
func description() -> String {
return beverage.description()
}
}
class Milk: BeverageDecorator {
override func cost() -> Double {
return super.cost() + 0.5
}
override func description() -> String {
return super.description() + ", Milk"
}
}
let coffee: Beverage = Coffee()
let coffeeWithMilk = Milk(beverage: coffee)
print(coffeeWithMilk.description())
print(coffeeWithMilk.cost())
5. Facade: Simplify Complex Interfaces
The Facade pattern provides a simplified interface to a complex subsystem, making it easier for clients to interact with it.
class ComplexSubsystemA {
func operationA() {
print("Operation A")
}
}
class ComplexSubsystemB {
func operationB() {
print("Operation B")
}
}
class Facade {
private let subsystemA: ComplexSubsystemA
private let subsystemB: ComplexSubsystemB
init(subsystemA: ComplexSubsystemA, subsystemB: ComplexSubsystemB) {
self.subsystemA = subsystemA
self.subsystemB = subsystemB
}
func simplifiedOperation() {
subsystemA.operationA()
subsystemB.operationB()
}
}
let subsystemA = ComplexSubsystemA()
let subsystemB = ComplexSubsystemB()
let facade = Facade(subsystemA: subsystemA, subsystemB: subsystemB)
facade.simplifiedOperation()
6. Flyweight: Minimize Memory Usage with Shared Objects
The Flyweight pattern helps minimize memory usage by sharing objects with similar state, instead of creating new ones.
class Flyweight {
private let sharedState: String
init(sharedState: String) {
self.sharedState = sharedState
}
func operation(uniqueState: String) {
print("Shared state: \(sharedState), unique state: \(uniqueState)")
}
}
class FlyweightFactory {
private var flyweights: [String: Flyweight] = [:]
func getFlyweight(for key: String) -> Flyweight {
if let existingFlyweight = flyweights[key] {
return existingFlyweight
} else {
let newFlyweight = Flyweight(sharedState: key)
flyweights[key] = newFlyweight
return newFlyweight
}
}
}
let factory = FlyweightFactory()
let flyweight1 = factory.getFlyweight(for: "shared1")
flyweight1.operation(uniqueState: "unique1")
let flyweight2 = factory.getFlyweight(for: "shared1")
flyweight2.operation(uniqueState: "unique2")
7. Proxy: Control Access to Objects with a Surrogate
The Proxy pattern provides a surrogate object that controls access to another object. This can be used for various purposes such as security, lazy loading, or remote object access.
protocol Subject {
func request()
}
class RealSubject: Subject {
func request() {
print("Real subject request")
}
}
class Proxy: Subject {
private let realSubject: RealSubject
init(realSubject: RealSubject) {
self.realSubject = realSubject
}
func request() {
if checkAccess() {
realSubject.request()
logAccess()
}
}
private func checkAccess() -> Bool {
print("Access granted")
return true
}
private func logAccess() {
print("Access logged")
}
}
let realSubject = RealSubject()
let proxy: Subject = Proxy(realSubject: realSubject)
proxy.request()
By implementing these 7 powerful Structural Design Patterns in your Swift projects, you can dramatically improve the organization and flexibility of your code. These patterns will help you create clean, efficient, and scalable systems that can adapt to changing requirements with ease.
I hope you enjoyed this article, and if you have any questions, comments, or feedback, then feel free to comment here or reach out via Twitter.
Thanks for reading!
Check the next article in this series Behavioral Design Patterns in Swift.
