no message

Author: ydf0509

j2ee模式-业务代表模式.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 15:32
+
+"""
+业务代表模式（Business Delegate Pattern）用于对表示层和业务层解耦。它基本上是用来减少通信或对表示层代码中的业务层代码的远程查询功能。在业务层中我们有以下实体。
+
+客户端（Client） - 表示层代码可以是 JSP、servlet 或 UI java 代码。
+业务代表（Business Delegate） - 一个为客户端实体提供的入口类，它提供了对业务服务方法的访问。
+查询服务（LookUp Service） - 查找服务对象负责获取相关的业务实现，并提供业务对象对业务代表对象的访问。
+业务服务（Business Service） - 业务服务接口。实现了该业务服务的实体类，提供了实际的业务实现逻辑。
+
+从java转化来，命名规范懒得改了。
+"""
+from abc import ABCMeta, abstractmethod
+from monkey_print2 import print
+
+
+class AbstractBusinessService(metaclass=ABCMeta):
+    @abstractmethod
+    def doProcessing(self):
+        pass
+
+
+class EJBService(AbstractBusinessService):
+    def doProcessing(self):
+        print("Processing task by invoking EJB Service")
+
+
+class JMSService(AbstractBusinessService):
+    def doProcessing(self):
+        print("Processing task by invoking JMS Service")
+
+
+def getBusinessService(serviceType: str):
+    if serviceType.upper() == 'EJB':
+        return EJBService()
+    else:
+        return JMSService()
+
+
+class BusinessDelegate:
+    def __init__(self):
+        self.__businessService = None
+        self.__serviceType = None
+
+    def setServiceType(self, serviceType):
+        self.__serviceType = serviceType
+
+    def doTask(self):
+        businessService = getBusinessService(self.__serviceType)
+        businessService.doProcessing()
+
+
+class Client:
+    def __init__(self, businessService: BusinessDelegate):
+        self.businessService = businessService
+
+    def doTask(self):
+        self.businessService.doTask()
+
+
+if __name__ == '__main__':
+    businessDelegate = BusinessDelegate()
+    businessDelegate.setServiceType("EJB")
+
+    client = Client(businessDelegate)
+    client.doTask()
+
+    businessDelegate.setServiceType("JMS")
+    client.doTask()
+
+    """
+    "D:/coding2/python36patterns/j2ee模式-业务代表模式.py:25"  16:07:31  Processing task by invoking EJB Service
+    "D:/coding2/python36patterns/j2ee模式-业务代表模式.py:31"  16:07:31  Processing task by invoking JMS Service
+    """

j2ee模式-组合实体模式.py

@@ -0,0 +1,76 @@
+"""
+组合实体模式（Composite Entity Pattern）用在 EJB 持久化机制中。一个组合实体是一个 EJB 实体 bean，代表了对象的图解。当更新一个组合实体时，内部依赖对象 beans 会自动更新，因为它们是由 EJB 实体 bean 管理的。以下是组合实体 bean 的参与者。
+
+组合实体（Composite Entity） - 它是主要的实体 bean。它可以是粗粒的，或者可以包含一个粗粒度对象，用于持续生命周期。
+粗粒度对象（Coarse-Grained Object） - 该对象包含依赖对象。它有自己的生命周期，也能管理依赖对象的生命周期。
+依赖对象（Dependent Object） - 依赖对象是一个持续生命周期依赖于粗粒度对象的对象。
+策略（Strategies） - 策略表示如何实现组合实体。
+"""
+from monkey_print2 import print
+
+
+class DependentObject1:
+    def __init__(self):
+        self.__data = None
+
+    def get_data(self):
+        return self.__data
+
+    def set_data(self, data):
+        self.__data = data
+
+
+class DependentObject2:
+    def __init__(self):
+        self.__data = None
+
+    def get_data(self):
+        return self.__data
+
+    def set_data(self, data):
+        self.__data = data
+
+
+class CoarseGrainedObject:
+    def __init__(self):
+        self.do1 = DependentObject1()
+        self.do2 = DependentObject2()
+
+    def set_data(self, data1, data2):
+        self.do1.set_data(data1)
+        self.do2.set_data(data2)
+
+    def get_data(self):
+        return self.do1.get_data(), self.do2.get_data()
+
+
+class CompositeEntity:
+    def __init__(self):
+        self.cgo = CoarseGrainedObject()
+
+    def set_data(self, data1, data2):
+        self.cgo.set_data(data1, data2)
+
+    def get_data(self):
+        return self.cgo.get_data()
+
+
+class Client:
+    def __init__(self):
+        self.compositeEntity = CompositeEntity()
+
+    def print_data(self):
+        for data in self.compositeEntity.get_data():
+            print(f'Data: {data}')
+
+    def set_data(self, data1, data2):
+        self.compositeEntity.set_data(data1, data2)
+
+
+if __name__ == '__main__':
+    client = Client()
+    client.set_data("Test", "Data")
+    client.print_data()
+
+    client.set_data("Second Test", "Data2")
+    client.print_data()

行为型模式-登记模式.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 13:53
+"""
+登记模式。用这个可以兼顾单例模式的创建和管理。
+"""
+class RegistryHolder(type):
+
+    REGISTRY = {}
+
+    def __new__(cls, name, bases, attrs):
+        new_cls = type.__new__(cls, name, bases, attrs)
+        """
+            Here the name of the class is used as key but it could be any class
+            parameter.
+        """
+        cls.REGISTRY[new_cls.__name__] = new_cls
+        return new_cls
+
+    @classmethod
+    def get_registry(cls):
+        return dict(cls.REGISTRY)
+
+
+class BaseRegisteredClass(metaclass=RegistryHolder):
+    """
+    Any class that will inherits from BaseRegisteredClass will be included
+    inside the dict RegistryHolder.REGISTRY, the key being the name of the
+    class and the associated value, the class itself.
+    """
+
+
+if __name__ == "__main__":
+    print(sorted(RegistryHolder.REGISTRY))
+
+    class ClassRegistree(BaseRegisteredClass):
+        def __init__(self, *args, **kwargs):
+            pass
+
+
+    print(sorted(RegistryHolder.REGISTRY))

行为型模式-过滤器模式.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2019/10/9 0009 14:17
+"""
+过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。
+"""
+from abc import ABCMeta, abstractmethod
+from monkey_print2 import print
+
+
+class Person:
+    def __init__(self, name, sex, marital_status):
+        self.name = name
+        self.sex = sex
+        self.marital_status = marital_status
+
+    def __str__(self):
+        return f"""Person: [Name: {self.name}, Gender: {self.sex} Marital Status: {self.marital_status}]"""
+
+
+class Criteria(metaclass=ABCMeta):
+    @abstractmethod
+    def meet_criteria(self, persons) -> list:
+        pass
+
+
+class CriteriaMale(Criteria):
+    def meet_criteria(self, persons) -> list:
+        return [p for p in persons if p.sex.lower() == 'MALE'.lower()]
+
+
+class CriteriaFemale(Criteria):
+    def meet_criteria(self, persons) -> list:
+        return [p for p in persons if p.sex.lower() == 'FEMALE'.lower()]
+
+
+class CriteriaSingle(Criteria):
+    def meet_criteria(self, persons) -> list:
+        return [p for p in persons if p.sex.lower() == 'SINGLE'.lower()]
+
+
+class AndCriteria(Criteria):
+    def __init__(self, criteria: Criteria, criteria_other: Criteria):
+        self.criteria = criteria
+        self.criteria_other = criteria_other
+
+    def meet_criteria(self, persons) -> list:
+        return self.criteria_other.meet_criteria(self.criteria.meet_criteria(persons))
+
+
+class OrCriteria(Criteria):
+    def __init__(self, criteria: Criteria, criteria_other: Criteria):
+        self.criteria = criteria
+        self.criteria_other = criteria_other
+
+    def meet_criteria(self, persons) -> list:
+        persons1 = self.criteria.meet_criteria(persons)
+        persons2 = self.criteria_other.meet_criteria(persons)
+        return list(set(persons1 + persons2))
+
+
+if __name__ == '__main__':
+    def print_person_list(p_list):
+        for p in p_list:
+            print(p)
+
+
+    person_list = list()
+    person_list.append(Person("Robert", "Male", "Single"))
+    person_list.append(Person("John", "Male", "Married"))
+    person_list.append(Person("Laura", "Female", "Married"))
+    person_list.append(Person("Diana", "Female", "Single"))
+    person_list.append(Person("Mike", "Male", "Single"))
+    person_list.append(Person("Bobby", "Male", "Single"))
+
+    male = CriteriaMale()
+    female = CriteriaFemale()
+    single = CriteriaSingle()
+    singleMale = AndCriteria(single, male)
+    singleOrFemale = OrCriteria(single, female)
+
+    print("\nMales: ")
+    print_person_list(male.meet_criteria(person_list))
+
+    print("\nFemales: ")
+    print_person_list(female.meet_criteria(person_list))
+
+    print("\nSingle Males: ")
+    print_person_list(singleMale.meet_criteria(person_list))
+
+    print("\nSingle Or Females: ")
+    print_person_list(singleOrFemale.meet_criteria(person_list))