python依赖注入_python 抽象类、抽象方法、接口、依赖注入、SOLIP

SOLIP设计原则

1、单一责任原则(SRP)

一个对象对只应该为一个元素负责

2、开放封闭原则(OCP)

对扩展开放，修改封闭

3、里氏替换原则(LSP)

可以使用任何派生类替换基类

4、接口分离原则(ISP)

对于接口进行分类避免一个接口的方法过多

5、依赖倒置原则(DIP)

隔离关系，使用接口或抽象类代指

6、依赖注入(DI)和控制反转原则(ICO)

使用钩子再原来执行流程中注入其他对象

接口：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15# =================================================以下是接口

classIorderRepository:##接口

deffetch_one_by(self,nid):

'''

获取单条数据的方法，所有的继承呢当前类的类必须继承

:param nid:

:return:

'''

# raise Exception('子类中必须包含该方法')

classOrderReposititory(IorderRepository):#类

deffetch_one_by(self,nid):

print(nid)

obj=OrderReposititory()

obj.fetch_one_by(1)

抽象类抽象方法

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21importabc

classFoo(metaclass=abc.ABCMeta):##抽象类

deff1(self):

print(123)

deff2(self):

print(456)

@abc.abstractmethod##抽象方法

deff3(self):

'''

???

:return:

'''

classBar(Foo):

deff3(self):

print(33333)

b=Bar()

b.f3()

引入依赖注入

解释器解释类的流程

1

2

3

4

5

6

7

8

9

10

11

12

13

14# ======================================解释器解释类的流程===================

#  解释器解释：

# 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__方法

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20classMyType(type):

def__call__(cls,*args,**kwargs):##执行Type的__call__方法，这里的cls就是<__main__.foo object at> Foo类

obj=cls.__new__(cls,*args,**kwargs)##Foo的__new__方法

print('-------------')

obj.__init__(*args,**kwargs)##在执行Foo的__init__的之前做什么操作

returnobj

classFoo(metaclass=MyType):

def__init__(self, name):

print('============')

self.name=name

deff1(self):

print(self.name)

obj=Foo(123)

print(obj)

print(obj.name)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39#=================================依赖注入案例一======================================

classMyType(type):

def__call__(cls,*args,**kwargs):##执行Type的__call__方法，这里的cls就是<__main__.foo object at> Foo类

obj=cls.__new__(cls,*args,**kwargs)##Foo的__new__方法

ifcls==Foo1:

obj.__init__(Foo())

elifcls==Foo2:

obj.__init__(Foo1())

returnobj

classFoo(metaclass=MyType):

def__init__(self, args):

print('============')

self.name=args

deff(self):

print(self.name)

classFoo1(metaclass=MyType):

def__init__(self, args):

print('============')

self.name=args

deff1(self):

print(self.name)

classFoo2(metaclass=MyType):

def__init__(self, args):

print('============')

self.name=args

deff2(self):

print(self.name)

obj=Foo2()

obj.f2()

# <__main__.foo1 object at>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60#######################依赖注入案例二====================================================

#

# 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> 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>

# 666

# 999