python之类的执行过程，面向对象--依赖注入

类的本质，执行过程：

class Foo:
    def __init__(self，name):
        self.name =123

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

#解释器解析：
#1、遇到class Foo，执行type的__init__方法
#2、Type的init的方法里面做什么呢？
obj = Foo(123)
#3、执行Type的__call__方法
#    然后执行Foo类的__new__方法
#    最后执行Foo类的__init__方法

 

 

依赖注入，案例

class Mapper:
    __mapper_relation ={}

    @staticmethod
    def register(cls,value): #把对象cls和参数value注册进去
        Mapper.__mapper_relation[cls]=value

    @staticmethod
    def exist(cls): #判断这个cls是否存在__mapper_relation中
        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):
        obj =cls.__new__(cls, *args, **kwargs)
        # print('==========')
        arg_list =list(args) #把cls的参数（元祖），转变成list对象
        if Mapper.exist(cls):
            value = Mapper.value(cls)
            arg_list.append(value)

        obj.__init__(*arg_list, **kwargs)
        return obj


class Foo(metaclass=MyType):

    def __init__(self,name):
        print('----------')
        self.name =name

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

class Bar(metaclass=MyType):

    def __init__(self, name):
        print('----------')
        self.name = name

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

Mapper.register(Foo,'123')  #这样Foo()就不需要加入参数了
Mapper.register(Bar,'456')  #这样Bar()就不需要加入参数了
f = Foo()
print(f.name)
b = Bar()
print(b.name)