python依赖注入_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)