第四百一十三節，python面向對象，組合、類建立的本質、依賴注入

組合

 

組合舉例
組合就是多個類，或者若干類聯合起來完成一個任務
下面舉例兩個類聯合起來完成一個任務
爲了下降代碼的耦合度，咱們通常不會在一個類裏實例化另一個類，都是將一個類在外面實例化後傳參到另一個來
這樣就帶來了一個問題，若是有不少類相互繼承，咱們就須要在外面實例化不少類
最好能動態實例化類並傳參（依賴注入），後面講到

 

 

組合舉例
# 組合就是多個類，或者若干類聯合起來完成一個任務
# 下面舉例兩個類聯合起來完成一個任務
# 爲了下降代碼的耦合度，咱們通常不會在一個類裏實例化另一個類，都是將一個類在外面實例化後傳參到另一個來
# 這樣就帶來了一個問題，若是有不少類相互繼承，咱們就須要在外面實例化不少類
# 最好能動態實例化類並傳參（依賴注入），後面講到

class shujukulianjie:
    """
    鏈接數據庫類
    """
    def __init__(self, host):
        self.host = host

    def lianjie(self):
        """
        鏈接數據庫
        """
        print("鏈接數據庫{host}".format(host=self.host))

    def guanbi(self):
        """
        關閉數據庫
        """
        print("鏈接數據庫{host}".format(host=self.host))


class yhucaozuo:
    """
    用戶操做類
    """
    def __init__(self, shujuk):
        self.shujuk = shujuk

    def yhdlu(self, user):
        """
        用戶登陸
        """
        self.shujuk.lianjie()
        print("用戶{user}登陸成功！".format(user=user))

obj_shujukulianjie = shujukulianjie("127.0.0.1")

obj_yhucaozuo = yhucaozuo(obj_shujukulianjie)
obj_yhucaozuo.yhdlu("abcde")

 

 

建立類的本質

 

class shujukulianjie:
    def __init__(self, host):
        self.host = host

    def lianjie(self):
        """
        鏈接數據庫
        """
        print("鏈接數據庫{host}".format(host=self.host))

obj_shujukulianjie = shujukulianjie("127.0.0.1")

# 類建立的本質
# 類是由Type建立的
# 當實例化一個對象時，都通過了哪些
# 1.執行Type的__call__方法
    # 在__call__方法裏執行shujukulianjie類的__new__方法
    # 在__call__方法裏執行shujukulianjie類的__init__方法

 

講依賴注入前咱們需瞭解一下類建立的本質

 

類建立的本質
類是由Type建立的
當實例化一個對象時，都通過了哪些
1.執行Type的__call__方法
    在__call__方法裏執行shujukulianjie類的__new__方法
    在__call__方法裏執行shujukulianjie類的__init__方法

 

 

 

能夠看到執行Type的__call__方法是隱形的

 

 

自定義type類
繼承自定義type類的類，會由自定義type類建立

 

自定義type類
class MyType(type):
    print('執行__call__')

    def __call__(cls, *args, **kwargs):
        print('執行__new__')
        obj = cls.__new__(cls, *args, **kwargs)

        print('執行__init__')
        obj.__init__("127.0.0.1")

        return obj


# 繼承type類，此類就會由自定義type類建立
class shujukulianjie(metaclass=MyType):
    def __init__(self, host):
        self.host = host

    def lianjie(self):
        """
        鏈接數據庫
        """
        print("鏈接數據庫{host}".format(host=self.host))

obj_shujukulianjie = shujukulianjie()
obj_shujukulianjie.lianjie()
# 類建立的本質
# 類是由Type建立的
# 當實例化一個對象時，都通過了哪些
# 1.執行Type的__call__方法
    # 在__call__方法裏執行shujukulianjie類的__new__方法
    # 在__call__方法裏執行shujukulianjie類的__init__方法

 

 

叫賣錄音網
錄音網站

 

依賴關係注入

 

依賴關係注入，就是將類與類之間的依賴關係，經過建立類時的__call__方法，在執行__init__方法以前，注入到__init__方法裏
若是一個來須要繼承另一個類。名稱爲子類的名稱，值爲實例化父類，這樣父類將注入到子類的__init__方法裏，這樣就完成了繼承

 

依賴關係注入類
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]


# 自定義type類
class MyType(type):
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls, *args, **kwargs)
        arg_list = list(args)
        if Mapper.exist(cls):
            value = Mapper.value(cls)
            arg_list.append(value)
        obj.__init__(*arg_list, **kwargs)

        return obj


# 繼承type類，此類就會由自定義type類建立
class shujukulianjie(metaclass=MyType):
    def __init__(self, name):
        self.name = name

    def lianjie(self):
        """
        鏈接數據庫
        """
        print("鏈接數據庫{name}".format(name=self.name))


class yhucaozuo(metaclass=MyType):
    """
    用戶操做類
    """
    def __init__(self, name):
        self.name = name

    def yhdlu(self, user):
        """
        用戶登陸
        """
        self.name.lianjie()
        print("用戶{user}登陸成功！".format(user=user))

# 依賴關係注入，就是將類與類之間的依賴關係，經過建立類時的__call__方法，在執行__init__方法以前，注入到__init__方法裏
# 依賴關係注入，register()
# 第一個參數依賴關係名稱
# 第二個參數依賴關係值
# 若是一個來須要繼承另一個類。名稱爲子類的名稱，值爲實例化父類，這樣父類將注入到子類的__init__方法裏，這樣就完成了繼承
Mapper.register(shujukulianjie,'127.0.0.1')
Mapper.register(yhucaozuo,shujukulianjie())


obj = yhucaozuo()
obj.yhdlu('adc')