Swift 공식 문서 정리 - 접근 제어 (Access Control)

안녕하세요. 오늘은 코드 구조화와 캡슐화에 필요한 '접근 제어(Access Control)'에 대해 알아보겠습니다. 접근 제어를 통해 코드의 어떤 부분을 외부에 노출하고, 어떤 부분을 숨길지 효과적으로 관리할 수 있습니다.

📌 접근 제어란?

접근 제어(Access Control)는 다른 소스 파일이나 모듈에서 코드에 접근하는 것을 제한하는 기능입니다. 이를 통해 코드의 구현 세부 사항을 숨기고, 코드가 사용될 수 있는 인터페이스를 명확하게 정의할 수 있습니다.

접근 제어의 주요 목적:

• 코드의 구현 세부 사항 숨기기
• 코드 사용을 위한 명확한 인터페이스 정의
• 실수로 인한 잘못된 코드 사용 방지
• 내부 구현 변경 시 외부 코드에 미치는 영향 최소화

📌 모듈, 소스 파일, 패키지의 이해

Swift의 접근 제어를 이해하기 위해서는 먼저 다음 개념을 알아야 합니다:

• 모듈(Module): 코드 배포의 단일 단위로, 애플리케이션이나 프레임워크가 여기에 해당합니다. Swift에서 import 키워드로 다른 모듈을 가져올 수 있습니다.
• 소스 파일(Source File): 모듈 내의 단일 Swift 소스 코드 파일입니다.
• 패키지(Package): 하나의 단위로 개발되는 모듈 그룹입니다. Swift Package Manager나 Xcode 설정에서 정의됩니다.

📌 Swift의 5가지 접근 수준

Swift는 코드의 접근성을 세밀하게 제어할 수 있는 5가지 접근 수준을 제공합니다:

1. Open 접근 수준

• 가장 개방적인 접근 수준
• 다른 모듈에서 접근과 서브클래싱 가능
• 다른 모듈에서 메서드 오버라이드 가능
• 클래스와 클래스 멤버에만 적용 가능
• 사용 예: 프레임워크의 기본 클래스로 확장을 고려한 설계

 

open class OpenClass {
    open func openMethod() {}
}

2. Public 접근 수준

• 다른 모듈에서 접근 가능
• 다른 모듈에서 서브클래싱이나 오버라이드 불가
• 사용 예: 프레임워크의 공개 API

 

public class PublicClass {
    public var publicProperty = 0
}

3. Internal 접근 수준

• 기본 접근 수준
• 모듈 내에서만 접근 가능
• 사용 예: 앱이나 프레임워크의 내부 구조

 

internal class InternalClass {  // 'internal'은 생략 가능
    var internalProperty = 0
}

4. File-private 접근 수준

• 정의된 소스 파일 내에서만 접근 가능
• 사용 예: 파일 내 여러 타입에서 공유하지만 외부에 노출하지 않을 기능

 

fileprivate class FilePrivateClass {
    fileprivate func filePrivateMethod() {}
}

5. Private 접근 수준

• 가장 제한적인 접근 수준
• 정의된 선언과 그 선언의 확장 내에서만 접근 가능
• 사용 예: 특정 타입 내에서만 사용되는 상세 구현

 

private class PrivateClass {
    private func privateMethod() {}
}

접근 수준 계층: Open(최소 제한) > Public > Internal > File-private > Private(최대 제한)

📌 접근 제어의 기본 원칙

Swift의 접근 제어는 중요한 기본 원칙을 따릅니다:

엔티티는 더 낮은(더 제한적인) 접근 수준을 가진 다른 엔티티로 정의될 수 없습니다.

예를 들어:

• Public 변수는 Internal, File-private, Private 타입으로 정의될 수 없습니다.
• 함수는 파라미터 타입이나 반환 타입보다 더 높은 접근 수준을 가질 수 없습니다.

이 원칙은 항상 더 제한적인 쪽으로 접근 수준이 결정됨을 의미합니다.

📌 기본 접근 수준

Swift에서 명시적으로 접근 수준을 지정하지 않으면, 대부분의 엔티티는 internal 접근 수준을 기본값으로 갖습니다.

이는 단일 모듈 앱 개발에 편리하지만, 프레임워크 개발 시에는 공개할 API를 명시적으로 public 또는 open으로 지정해야 합니다.

📌 사용자 정의 타입의 접근 제어

타입과 멤버의 관계

타입의 접근 수준은 해당 타입의 멤버(프로퍼티, 메서드, 초기화 구문, 서브스크립트)의 기본 접근 수준에 영향을 줍니다:

public class SomePublicClass {
    public var publicProperty = 0     // 명시적 public
    var internalProperty = 0          // 암시적 internal
    fileprivate func filePrivateMethod() {}  // 명시적 file-private 
    private func privateMethod() {}   // 명시적 private
}

중요: Public 타입의 멤버는 기본적으로 public이 아닌 internal입니다. 타입 멤버를 공개하려면 명시적으로 public으로 표시해야 합니다.

튜플 타입

튜플의 접근 수준은 튜플에 포함된 모든 타입 중 가장 제한적인 접근 수준으로 결정됩니다:

// (Internal, Private) 튜플의 접근 수준은 Private
internal class InternalClass {}
private class PrivateClass {}

// 이 함수는 반환 타입이 Private이므로 
// Private으로 선언해야 합니다
private func someFunction() -> (InternalClass, PrivateClass) {
    // 함수 구현
}

함수 타입

함수의 접근 수준은 파라미터 타입과 반환 타입 중 가장 제한적인 접근 수준으로 결정됩니다:

// 이 함수는 파라미터가 private이므로 
// private 이상의 접근 수준이 될 수 없습니다
private func processSomeData(data: PrivateClass) -> InternalClass {
    // 함수 구현
}

📌 특수한 경우의 접근 제어

열거형과 케이스

열거형의 각 케이스는 자동으로 열거형 자체와 동일한 접근 수준을 갖습니다:

public enum CompassPoint {
    case north // 자동으로 public
    case south // 자동으로 public
    case east  // 자동으로 public
    case west  // 자동으로 public
}

Getter와 Setter

프로퍼티나 서브스크립트의 접근 수준을 더 세밀하게 제어하기 위해 getter와 setter에 다른 접근 수준을 부여할 수 있습니다:

struct TrackedString {
    private(set) var numberOfEdits = 0  // getter는 internal, setter는 private
    var value: String = "" {
        didSet {
            numberOfEdits += 1
        }
    }
}

var stringToEdit = TrackedString()
stringToEdit.value = "This string will be tracked."
print(stringToEdit.numberOfEdits)  // 읽기 가능
// stringToEdit.numberOfEdits = 0  // 컴파일 오류: setter는 private

이 기능은 프로퍼티 값은 읽을 수 있게 하되, 수정은 제한하고 싶을 때 유용합니다.

📌 초기화 구문의 접근 제어

초기화 구문은 초기화하는 타입과 같거나 더 낮은 접근 수준을 가질 수 있습니다:

public class PublicClass {
    private let privateProperty: Int
    
    // 타입은 public이지만 초기화 구문은 internal
    init(value: Int) {
        privateProperty = value
    }
    
    // 타입과 동일한 public 접근 수준의 초기화 구문
    public init(publicValue: Int) {
        privateProperty = publicValue
    }
    
    // private 접근 수준의 초기화 구문
    private init() {
        privateProperty = 0
    }
}

기본 초기화 구문

타입이 public이고 모든 프로퍼티에 기본값이 있을 경우, 기본 초기화 구문은 internal로 간주됩니다. 이를 public으로 만들려면 명시적으로 선언해야 합니다:

public struct PublicStruct {
    public var someValue = 0
    
    // 명시적으로 public 초기화 구문 선언
    public init() {}
}

📌 프로토콜의 접근 제어

프로토콜과 요구사항

프로토콜의 접근 수준은 프로토콜 내 모든 요구사항의 접근 수준을 결정합니다:

public protocol PublicProtocol {
    // 모든 요구사항은 자동으로 public
    func publicRequiredMethod()
    var publicRequiredProperty: Int { get set }
}

중요: Public 프로토콜의 요구사항은 구현 시 public 접근 수준이어야 합니다.

프로토콜 준수성

타입이 프로토콜을 준수할 때, 프로토콜 준수성의 접근 수준은 타입과 프로토콜 중 더 제한적인 접근 수준으로 결정됩니다:

public class PublicClass: InternalProtocol {
    // 프로토콜 준수성은 internal
    // 요구사항 구현은 최소 internal이어야 함
}

📌 확장(Extension)의 접근 제어

확장을 사용할 때, 새 멤버는 확장되는 타입의 기본 접근 수준을 상속받습니다:

public class PublicClass {
    // 멤버는 internal 기본값
}

extension PublicClass {
    // 추가된 멤버도 internal 기본값
    func newMethod() {}
}

확장에 명시적으로 접근 수준을 지정할 수도 있습니다:

extension PublicClass {
    // 이 확장의 모든 멤버는 private
    private func privateMethod() {}
}

같은 파일 내 Private 멤버 접근

같은 파일 내에서는 확장과 원래 선언 사이에 private 멤버에 접근할 수 있습니다:

struct SomeStruct {
    private var privateVariable = 12
}

// 같은 파일의 확장에서 private 멤버 접근 가능
extension SomeStruct {
    func doSomething() {
        print(privateVariable) // 접근 가능
    }
}

📌 제네릭과 타입 별칭의 접근 제어

제네릭 타입

제네릭 타입이나 함수의 접근 수준은 타입 자체와 타입 제약 조건 중 가장 제한적인 접근 수준으로 결정됩니다:

// PrivateClass 제약이 있으므로 이 제네릭 함수는 
// private보다 높은 접근 수준을 가질 수 없음
private func genericFunction<T: PrivateClass>(item: T) {}

타입 별칭

타입 별칭은 원본 타입보다 같거나 더 제한적인 접근 수준을 가질 수 있지만, 더 높은 접근 수준은 가질 수 없습니다:

public class SomePublicClass {}

// 원본보다 더 제한적인 접근 수준 가능
internal typealias InternalAlias = SomePublicClass

// 원본보다 더 개방적인 접근 수준은 불가능
// public typealias PublicAlias = SomeInternalClass // 오류

📌 접근 제어 실전 활용 전략

1. 단일 타겟 앱 개발 시

단일 앱 개발 시에는 기본 접근 수준인 internal을 활용하고, 필요한 경우 구현 세부사항은 private이나 fileprivate로 숨기는 것이 좋습니다:

class ProfileViewController {
    // 다른 클래스에서 접근할 수 있는 API
    var user: User?
    func loadUserData() {}
    
    // 내부 구현 세부사항
    private func formatUserData() {}
    private func setupViews() {}
}

2. 프레임워크 개발 시

프레임워크 개발 시에는 공개 API를 public이나 open으로 명확히 지정하고, 나머지는 internal 이하로 유지하세요:

// 공개 API
open class NetworkManager {
    // 외부에서 서브클래싱하고 커스터마이징할 수 있는 메서드
    open func request(url: URL) -> Data? {}
    
    // 외부에서 사용할 수 있지만 오버라이드할 수 없는 메서드
    public func cancel() {}
    
    // 내부 구현 세부사항
    internal func parseResponse() {}
    private func setupSession() {}
}

3. 팀 개발 시

여러 개발자가 함께 작업할 때는 모듈 경계를 잘 정의하고, API 계약을 명확히 하기 위해 접근 제어를 적극 활용하세요:

// 팀의 다른 구성원이 사용할 API
public protocol UserService {
    func getUser(id: String) -> User?
    func saveUser(_ user: User)
}

// 구현 세부사항은 숨김
internal class UserServiceImpl: UserService {
    private let database: Database
    
    public func getUser(id: String) -> User? {
        return findUserInDatabase(id)
    }
    
    public func saveUser(_ user: User) {
        validateUser(user)
        saveUserToDatabase(user)
    }
    
    private func findUserInDatabase(_ id: String) -> User? {}
    private func validateUser(_ user: User) {}
    private func saveUserToDatabase(_ user: User) {}
}

📌 정리

Swift의 접근 제어 시스템은 코드의 캡슐화와 인터페이스 정의에 필수적인 도구입니다. 올바른 접근 수준을 선택함으로써:

• 코드의 내부 구현을 숨기고 견고한 API 경계를 만들 수 있습니다
• 실수로 인한 잘못된 사용을 방지할 수 있습니다
• 코드 변경 시 영향 범위를 제한할 수 있습니다
• 코드 의도를 명확히 표현할 수 있습니다