第四百一十三节，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')