Tips for Protocol-Oriented Programming (POP) in Swift

1. Entrustment Model

1. Usage process

The most common usage of protocols is to pass values ​​through agents, which is the delegation pattern. Common application scenarios include: a view is customized in the controller, and a custom view is added to the view. If some functions or properties in the customized view need to be called in the controller, the delegation pattern is to specify a protocol, let the controller comply with a protocol and provide an implementation, so that the methods in the protocol can be used in the customized view.

For example, if you want to add a custom view to a controller, you can click a button in the view to change the value of a label in the controller. The simple code is as follows:

Custom views

 //SelectTabbar.swift
 @objc protocol SelectTabbarDelegate {
    func changeLabel(_ str: String)
 }

 //SelectTabbar.swift
 class SelectTabbar: UIView {
 var keywords : [String]?
 var buttons : [UIButton]?
    weak public var delegate : SelectTabbarDelegate? 
      
    init(frame: CGRect,keywords:[String]) {
        super.init(frame: frame)
        self.keywords = keywords
 renderView()
 } 
      
    required init?(coder aDecoder: NSCoder) {
        fatalError( "init(coder:) has not been implemented" )
 } 
      
    override func layoutSubviews() {
        super.layoutSubviews()
 } 
      
    private func renderView(){
        buttons = keywords?.enumerated().map({ ( index , key ) ->UIButton in  
            let buttonWidth = kScreenWidth/CGFloat((keywords?. count )!)
            let button = UIButton.init(frame: CGRect.init(x: CGFloat( index )*buttonWidth, y: 0, width: buttonWidth, height: 50))
            button.setTitle( key , for : .normal)
            button.setTitleColor(UIColor.blue, for : .normal)
            button.backgroundColor = UIColor.gray
            button.tag = index  
            button.addTarget(self, action : #selector(tapButton(sender:)), for : .touchUpInside)
            addSubview(button)
 return button
 })
 } 
      
    @objc func tapButton(sender: UIButton){
        delegate?.changeLabel(keywords![sender.tag])
 } 
      
 }

controller:

 class TestViewController: UIViewController,SelectTabbarDelegate {
    lazy var label : UILabel = {
        var label = UILabel(frame: CGRect.init(x: 50, y: 200, width: 100, height: 30))
 label.text = labelStr
        label.backgroundColor = UIColor.red
 return label
 }() 
      
    private var labelStr : String? {
 didSet{
            label.text = labelStr
 }
 } 
      
    override func viewDidLoad() {
 super.viewDidLoad()
 view .backgroundColor = .white
 view .addSubview(label)
 setupSelectTabbar()
 } 
      
 func setupSelectTabbar(){
        let selectTabbar = SelectTabbar(frame: CGRect.init(x: 0, y: kNavigationHeightAndStatuBarHeight, width: kScreenWidth, height: 50),keywords:[ "aa" , "bb" ])
        selectTabbar.delegate = self
 view .addSubview(selectTabbar)
 }
    func changeLabel(_ str: String) {
 labelStr = str
 } 
      
 }

This way, you can clearly express your logic. Otherwise, if you want to operate the content of the controller in the view, you need to operate the instance of the controller externally, which causes a problem that you cannot operate the private properties and private methods in the instance (although iOS is a dynamic language and there is no absolute privacy, but who would always use the runtime to operate).

2. Note

In ARC, for general delegates, we will specify them as weak in the declaration. When the actual object of this delegate is released, it will be reset to nil. This ensures that even if the delegate no longer exists, we will not crash due to accessing the reclaimed memory. This feature of ARC eliminates a very common crash error in Cocoa development, and it is no exaggeration to say that it has saved thousands of programmers from danger.

Of course we would want to do this in Swift. But when we try to write code like this, the compiler won’t let us pass:

 'weak' cannot be applied to non-class type

Reason: This is because Swift's protocol can be followed by types other than class. Types like struct or enum do not manage memory through reference counting, so it is impossible to modify them with ARC concepts such as weak.

Two workarounds:

1. Using @objc
2. Declare a class-specific protocol. By adding the class keyword, you can restrict the protocol to be followed only by class types, and structures or enumerations cannot follow the protocol. The class keyword must appear first in the protocol inheritance list, before other inherited protocols.

• protocol SelectTabbarDelegate : class

2. Application of AOP programming ideas

First, let us understand the meaning of AOP.

• In computing, aspect-oriented programming (AOP) is a paradigm programming that aims to increase modularity by allowing the separation of cross-cutting concerns. It does so by adding additional behavior to existing code (an advice) without modifying the code itself, instead separately specifying which code is modified via a “pointcut” specification, such as “log all function calls when the function’s name begins with ‘set’”. This allows behaviors that are not central to the business logic (such as logging) to be added to a program without cluttering the code, core to the functionality. AOP forms a basis for aspect-oriented software development.

To put it simply, in Swift, protocols are used to cut into certain codes, separating out additional functions without generating coupling, and putting those codes that are not closely related to the main logic together.

Common scenarios: logging, performance statistics, security control, transaction processing, exception handling, etc.

Continuing with the above example, we need to count once when opening TestViewController and also count when clicking two buttons. The counted content is distinguished by identifer.

Let's first create a Statistician.swift to store our statistical logic. (Simulation implementation)

Declare a StatisticianProtocal protocol and provide its default implementation.

 import Foundation
 enum LogIdentifer:String {
 case button1 = "button1"  
 case button2 = "button2"  
 case testViewController = "testViewController"  
 } 
  
 protocol StatisticianProtocal {
    func statisticianLog(fromClass:AnyObject, identifer:LogIdentifer)
    func statisticianUpload(fromClass:AnyObject, identifer:LogIdentifer)
 // Extend functionality with a trailing closure
    func statisticianExtension(fromClass:AnyObject, identifer:LogIdentifer, extra:()->())
 } 
  
 extension StatisticianProtocal{
    func statisticianLog(fromClass:AnyObject, identifer:LogIdentifer) {
        print( "statisticianLog--class:\(fromClass) from:\(identifer.rawValue)" )
 } 
      
    func statisticianUpload(fromClass:AnyObject, identifer:LogIdentifer) {
        print( "statisticianUpload--class:\(fromClass) from:\(identifer.rawValue)" )
 } 
      
    func statisticianExtension(fromClass:AnyObject, identifer:LogIdentifer, extra:()->()){
 extra()
 }
 } 
  
 class Statistician: NSObject { 
  
 }

Next, in any class that needs statistics, we make the class conform to this protocol and call the method in the protocol where needed. If the method that needs to be called in a particular class is slightly different, just rewrite the method in the protocol.

 class SelectTabbar: UIView,StatisticianProtocal {
 var keywords : [String]?
 var buttons : [UIButton]?
    weak public var delegate : SelectTabbarDelegate? 
      
    init(frame: CGRect,keywords:[String]) {
        super.init(frame: frame)
        self.keywords = keywords
 renderView()
 //Perform a statistics
        operateStatistician(identifer: .testViewController)
 } 
      
    required init?(coder aDecoder: NSCoder) {
        fatalError( "init(coder:) has not been implemented" )
 } 
      
      
    override func layoutSubviews() {
        super.layoutSubviews()
 } 
      
    private func renderView(){
        buttons = keywords?.enumerated().map({ ( index , key ) ->UIButton in  
            let buttonWidth = kScreenWidth/CGFloat((keywords?. count )!)
            let button = UIButton.init(frame: CGRect.init(x: CGFloat( index )*buttonWidth, y: 0, width: buttonWidth, height: 50))
            button.setTitle( key , for : .normal)
            button.setTitleColor(UIColor.blue, for : .normal)
            button.backgroundColor = UIColor.gray
            button.tag = index  
            button.addTarget(self, action : #selector(tapButton(sender:)), for : .touchUpInside)
            addSubview(button)
 return button
 })
 } 
      
    @objc func tapButton(sender: UIButton){
 //Perform a statistics
 switch sender.tag {
 case 0:operateStatistician(identifer: .button1)
 default :operateStatistician(identifer: .button2)
 }
        delegate?.changeLabel(keywords![sender.tag])
 } 
      
    func operateStatistician(identifer:LogIdentifer){
        statisticianLog(fromClass: self, identifer: identifer)
        statisticianUpload(fromClass: self, identifer: identifer)
        statisticianExtension(fromClass: self, identifer: identifer) {
            print( "extra: in SelectTabbar class" )
 }
 } 
      
 }

The above code implements the logic of three statistics without writing the statistical logic into the controller file, which reduces the functional coupling.

3. Used to replace extension and enhance code readability

Extensions can easily add functions to subclasses that inherit them. This brings up a problem, that is, all subclasses have this method, but the method itself may not be clear, or you only want a few subclasses to use this method. In this case, you can use protocols instead of extensions.

 // Defines a Shakable protocol. Classes that comply with this protocol can use the methods in it and provide a default implementation for the method
 // where Self:UIView indicates that only subclasses of UIView can comply with this protocol
 protocol Shakable
 func shakeView()
 } 
  
 extension Shakable where Self:UIView{
 func shakeView(){
 print(Self.self)
 }
 }

At this time, you can let a subclass comply with the protocol, such as the example above.

 class SelectTabbar: UIView,Shakable

If you do not reimplement this method in the class, you can implement the default method. This means that the subclass of the SelectTabbar class complies with the Shakable protocol, which is indirectly equal to SelectTabbar():Shakable?. In this way, we can happily let the SelectTabbar object use this method. (The Self keyword can only be used in protocols or classes, indicating the current class, and can be used as a return value).

If you don't want a subclass to use the shakeView() method, it's very simple. Just remove the Shakable protocol in class SelectTabbar: UIView,Shakable.

Other practices:

By using AOP to separate the data source and event source of the tableview, you can process the logic inside separately, making the tableview's proxy method less redundant.

Summarize

There are many other uses for protocols. The above are the most common scenarios. If you find that the protocol has better applications in other places during future development, you will update this article.