python 抽象類、抽象方法、接口、依賴注入、SOLIP

 

 

1、程序設計原則：SOLIP

SOLIP設計原則
　　1、單一責任原則(SRP)
　　　　一個對象對只應該為一個元素負責
　　2、開放封閉原則(OCP)
　　　　對擴展開放，修改封閉
　　3、里氏替換原則(LSP)
　　　　可以使用任何派生類替換基類
　　4、接口分離原則(ISP)
　　　　對於接口進行分類避免一個接口的方法過多
　　5、依賴倒置原則(DIP)
　　　　隔離關系，使用接口或抽象類代指
　　6、依賴注入(DI)和控制反轉原則(ICO)
　　　　使用鈎子再原來執行流程中注入其他對象

 

接口：

# =================================================以下是接口
class IorderRepository:  ##接口
    def fetch_one_by(self,nid):
        '''
        獲取單條數據的方法，所有的繼承呢當前類的類必須繼承
        :param nid:
        :return:
        '''
        # raise Exception('子類中必須包含該方法')

class OrderReposititory(IorderRepository): #類
    def fetch_one_by(self,nid):
        print(nid)
obj = OrderReposititory()
obj.fetch_one_by(1)

 

抽象類抽象方法

import abc
class Foo(metaclass=abc.ABCMeta):  ##抽象類
    def f1(self):
        print(123)

    def f2(self):
        print(456)

    @abc.abstractmethod  ##抽象方法
    def f3(self):
        '''
        ???
        :return:
        '''

class Bar(Foo):
    def f3(self):
        print(33333)

b = Bar()
b.f3()

　　

引入依賴注入

解釋器解釋類的流程

# ======================================解釋器解釋類的流程===================
#  解釋器解釋：
# class Foo:
#     def __init__(self):
#         self.name =123
#     def f1(self):
#         print(self.name)
# 1.遇到class Foo,執行type的__init__方法
# 2.type的init的方法做什么呢！不知道
# obj =Foo()
# obj.f1()
# 3.執行Type的__call__方法
# 執行Foo類的__new__方法
# 執行Foo類的__init__方法

　　

依賴注入在什么之前做什么操作

class MyType(type):
    def __call__(cls, *args, **kwargs):  ##執行Type的__call__方法，這里的cls就是<__main__.Foo object at 0x001B59F0> Foo類
        obj = cls.__new__(cls, *args, **kwargs)  ##Foo的__new__方法
        print('-------------')
        obj.__init__(*args, **kwargs)  ##在執行Foo的__init__的之前做什么操作
        return obj


class Foo(metaclass=MyType):
    def __init__(self, name):
        print('============')
        self.name = name

    def f1(self):
        print(self.name)


obj = Foo(123)
print(obj)
print(obj.name)

　　

 

 

#=================================依賴注入案例一======================================
class MyType(type):
    def __call__(cls, *args, **kwargs):  ##執行Type的__call__方法，這里的cls就是<__main__.Foo object at 0x001B59F0> Foo類
        obj = cls.__new__(cls, *args, **kwargs)  ##Foo的__new__方法
        if cls == Foo1:
            obj.__init__(Foo())
        elif cls == Foo2:
            obj.__init__(Foo1())
        return obj


class Foo(metaclass=MyType):
    def __init__(self, args):
        print('============')
        self.name = args

    def f(self):
        print(self.name)

class Foo1(metaclass=MyType):
    def __init__(self, args):
        print('============')
        self.name = args

    def f1(self):
        print(self.name)

class Foo2(metaclass=MyType):
    def __init__(self, args):
        print('============')
        self.name = args

    def f2(self):
        print(self.name)


obj = Foo2()
obj.f2()
# <__main__.Foo1 object at 0x002DA4F0>

　　

#######################依賴注入案例二====================================================

#
# class Mapper:
#     __mapper_relation = {}
#
#     @staticmethod
#     def register(cls, value):
#         Mapper.__mapper_relation[cls] = value
#
#     @staticmethod
#     def exist(cls):   ###判斷是否在里面
#         if cls in Mapper.__mapper_relation:
#             return True
#         return False
#
#     @staticmethod
#     def value(cls):
#         return Mapper.__mapper_relation[cls]
#
#
# class MyType(type):
#     def __call__(cls, *args, **kwargs):  ##執行Type的__call__方法，這里的cls就是<__main__.Foo object at 0x001B59F0> Foo類
#         obj = cls.__new__(cls, *args, **kwargs)  ##Foo的__new__方法
#         arg_list = list(args)
#         if Mapper.exist(cls):
#             value = Mapper.value(cls)
#             arg_list.append(value)
#         obj.__init__(*arg_list, **kwargs)  ##在執行Foo的__init__的之前做什么操作
#         return obj
#
#
# class Foo(metaclass=MyType):
#     def __init__(self, name):
#         self.name = name
#
#     def f1(self):
#         print(self.name)
#
#
# class Bar(metaclass=MyType):
#     def __init__(self, name):
#         self.name = name
#
#     def f1(self):
#         print(self.name)
#
#
# Mapper.register(Foo, '666')
# Mapper.register(Bar, '999')
# obj = Foo()
#
# print(obj)
# print(obj.name)
# b = Bar()
# print(b.name)

# <__main__.Foo object at 0x00583810>
# 666
# 999