SOLID 원칙😯

객체지향언어가 가져야하는 조건인 솔리드 원칙에 대해 알아보겠드아,,

• 용어 정리
  추상 클래스:

from abc import *
 
class 추상클래스이름(metaclass=ABCMeta):
    @abstractmethod
    def 메서드이름(self):
        코드

위와 같은 구성으로 사용
아래는 예시

from abc import *
 
class StudentBase(metaclass=ABCMeta):
    @abstractmethod
    def study(self):
        pass
 
    @abstractmethod
    def go_to_school(self):
        pass
 
class Student(StudentBase):
    def study(self):
        print('공부하기')
 
    def go_to_school(self):
        print('학교가기')
 
james = Student()
james.study()
james.go_to_school()

출처
추상클래스는 실제 기능을 구현하는 클래스가 아니라 상속을 위한 클래스이다. 추상 클래스에서 해당 클래스가 꼭 가져야할 기능을 명시해놓으면 이를 상속받는 클래스는 꼭 상위클래스의 모든 기능을 구현해야한다.

인터페이스:

출처

Single Responsiblity Principle (단일 책임 원칙)

• 소프트웨어의 설계 부품(클래스, 함수 등)은 단 하나의 책임만을 가져야 한다.
  하나의 메쏘드가 여러 가지 역할을 하면 안된다는 뜻이라고 파악된다.

예시

class Human:
    """추상화 과정이 필요한 Human 클래스"""
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        
    def go_restroom(self):
        """화장실 가는 함수"""
        if(self.sex == '남자'):
            print("남자화장실로 간다.")
        elif(self.sex == '여자'):
            print("여자화장실로 간다.")
        else:
            print("성별을 지정해주세요.")
 


출처: https://doorbw.tistory.com/236 [Tigercow.Door]

위는 단일 책임원칙이 안지켜진 잘못된 예시

from abc import *
 
class HumanBase(metaclass=ABCMeta):
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def go_restroom(self):
        pass
    
class Male(HumanBase):
    def __init__(self, name):
        super().__init__(name)
        self.sex = "남자"
    
    def go_restroom(self):
        print("남자화장실로 간다.")
        
class Female(HumanBase):
    def __init__(self, name):
        super().__init__(name)
        self.sex = "여자"
        
    def go_restroom(self):
        print("여자화장실로 간다.")


출처: https://doorbw.tistory.com/236 [Tigercow.Door]

위는 단일책임원칙이 지켜진 예시

Open-Closed Principle (개방-패쇄 원칙)

• 기존의 코드를 변경하지 않고(Closed) 기능을 수정하거나 추가할 수 있도록(Open) 설계해야 한다.

• 확장에는 열려있고, 변경에는 닫혀있어야 한다.

  새로운 기능을 추가함에 있어서는 신규 기능에 대한 소스 추가만 진행해야 하고 기존의 코드를 수정해야 하는 일은 없어야 한다는 것이다.

class Message:
    """Message 추상 클래스"""
    def __init__(self, data):
        self.data = data
 
class FirstGradeMessage(Message):
    """FirstGrade에 대한 메세지 처리 클래스"""
    
class SecondGradeMessage(Message):
    """SecondGrade에 대한 메세지 처리 클래스"""
    
class ThirdGradeMessage(Message):
    """ThirdGrade에 대한 메세지 처리 클래스"""
    
class DefaultGradeMessage(Message):
    """DefaultGrade에 대한 메세지 처리 클래스"""
    
class GradeMessageClassification():
    """Grade에 따른 메세지 분류 클래스"""
    def __init__(self, data):
        self.data = data
        
    def classification(self):
        if(self.data['grade'] == 1):
            return FirstGrade(self.data)
        elif(self.data['grade'] == 2):
            return SecondGrade(self.data)
        elif(self.data['grade'] == 3):
            return ThirdGrade(self.data)
        else:
            return DefaultGrade(self.data)


출처: https://doorbw.tistory.com/237 [Tigercow.Door]

Message라는 추상클래스를 각 학년 클래스가 상속받는 형식

GradeclassificationMessage에서 data를 받아서 각 학년을 구분하고 해당 학년의 클래스를 이용해서 데이터 반환

여기서 문제점은 grade가 늘어날 경우 GradeclassificationMessage의 함수를 바꿔야 한다.

OCP가 지켜지지 않았다는 것이다.

class Message:
   """Message 추상 클래스"""
   def __init__(self, data):
       self.data = data
       
   @staticmethod
   def is_collect_grade_message(data: dict):
       return False

class FirstGradeMessage(Message):
   """FirstGrade에 대한 메세지 처리 클래스"""
   @staticmethod
   def is_collect_grade_message(data: dict):
       return data['grade'] == 1
   
class SecondGradeMessage(Message):
   """SecondGrade에 대한 메세지 처리 클래스"""
   @staticmethod
   def is_collect_grade_message(data: dict):
       return data['grade'] == 2
   
class ThirdGradeMessage(Message):
   """ThirdGrade에 대한 메세지 처리 클래스"""
   @staticmethod
   def is_collect_grade_message(data: dict):
       return data['grade'] == 3
   
class DefaultGradeMessage(Message):
   """DefaultGrade에 대한 메세지 처리 클래스"""
   
class GradeMessageClassification():
   """Grade에 따른 메세지 분류 클래스"""
   def __init__(self, data):
       self.data = data
       
   def classification(self):
       for grade_message_cls in Message.__subclasses__():
           try:
               if grade_message_cls.is_collect_grade_message(self.data):
                   return grade_message_cls(self.data)
           except KeyError:
               continue
               
           return DefaultGradeMessage(self.data)


출처: https://doorbw.tistory.com/237 [Tigercow.Door]

• 우선 추상클래스인 Message가 있고, 각 학년 클래스는 Message를 상속받는다.

• 각 학년 클래스는 받은 데이터가 해당 학년 것인지 True/False 로 알려주는 is_collect_grade_message 메쏘드가 있다.

• Message의 모든 하위클래스의 is_collect_grade_message를 실행해서 True인 메쏘드의 데이터 반환!

Liskov Substitution Principle (리스코프 치환 원칙)

• 자식 클래스는 부모클래스에서 가능한 행위를 수행할 수 있어야 한다.
  부모 클래스가 가지는 속성은 자식 클래스는 모두 가지고 있어야 한다는 의미로 파악된다.

Interface Segregation Principle (인터페이스 분리 원칙)

• 한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 말아야 한다. 하나의 일반적인 인터페이스보다는, 여러 개의 구체적인 인터페이스가 낫다.

Dependency Inversion Principle (의존 역전 원칙)

• 의존 관계를 맺을 때, 변화하기 쉬운것 보단 변화하기 어려운 것에 의존해야 한다는 원칙이다.

# DIP를 지키지 못한 예제
from abc import *
 
class EventStreamer():
    def __init__(self, parsed_data: str, client: Syslog):
        self.parsed_data = parsed_data
        assert client is Syslog, "Client is not Syslog"
        self.client = client
        
    def stream(self):
        self.client.send(self.parsed_data)    
        
class Syslog():
    def send(data: str):
        print(f"Syslog send: {data}")
        pass
    
class OtherClient():
    def send(data: str):
        print(f"OtherClient send: {data}")
        pass
 
 
streamer1 = EventStreamer("for Syslog data!", Syslog)
streamer1.stream()
streamer2 = EventStreamer("for OtherClient data!", OtherClient)
streamer2.stream()


출처: https://doorbw.tistory.com/240 [Tigercow.Door]

상위 클래스인 EventStreamer에서 Syslog를 정의를 해버리면 안된다.

EventStreamer() 라는 고수준의 모듈이 직접 Syslog를 참조함으로써, Syslog에 대해 의존하고 있다.

# DIP를 적용한 예제
from abc import *
 
class EventStreamer():
    def __init__(self, parsed_data: str, client):
        self.parsed_data = parsed_data
        assert client in DataTargetClient.__subclasses__(), "Client is not DataTargetClient"
        self.client = client
        
    def stream(self):
        self.client.send(self.parsed_data)
 
class DataTargetClient(metaclass=ABCMeta):
    """Interface: DataTargetClient class"""
    @abstractmethod
    def send(self, data: str):
        pass            
        
class Syslog(DataTargetClient):
    def send(data: str):
        print(f"Syslog send: {data}")
        pass
    
class OtherClient(DataTargetClient):
    def send(data: str):
        print(f"OtherClient send: {data}")
        pass
 
 
streamer1 = EventStreamer("for Syslog data!", Syslog)
streamer1.stream()
streamer2 = EventStreamer("for OtherClient data!", OtherClient)
streamer2.stream()


출처: https://doorbw.tistory.com/240 [Tigercow.Door]