GOF23种设计模式系列之创建型设计模式

怼烎@ 2022-10-22 04:08 203阅读 0赞

# GOF23种设计模式系列之创建型设计模式 #

### 目录 ###

*  GOF23种设计模式系列之创建型设计模式
 *   *  什么是创建型设计模式
     *  单例模式/原型模式 （Singleton）
     *   *  单例方式一：懒汉试双if锁
         *  单例方式二：饿汉式静态构造函数
         *  单例模式三：饿汉式静态字段
         *  调用方式
         *  如果正确使用单例模式呢？
     *  简单工厂 (Simple Factory)
     *   *  基于依赖倒置原则的简单工厂
         *  基于配置文件的简单工厂
         *  基于反射+配置文件的简单工厂
         *  关于简单工厂
     *  工厂方法（Factory Method ）
     *   *  关于工厂方法
     *  抽象工厂（Abstract Factory）
     *   *  关于抽象工厂
     *  建造者模式（Builder）
     *   *  关于建造者模式
     *  原型模式（Prototype）
     *   *  直接new
         *  序列化反序列化
         *  关于原型模式

## 什么是创建型设计模式 ##

创建型设计模式的核心套路，就是管理对象创建，没有一定之规，按需取用就好

**创建型设计模式有以下几种：**

1.  单例模式/原型模式 （Singleton Factory）
2.  简单工厂 (Simple Factory)
3.  工厂方法（Factory Method ）
4.  抽象工厂（Abstract Factory）
5.  建造者模式（Builder）
6.  原型模式（Prototype）
    
        简单工厂并没有纳入GOF23

## 单例模式/原型模式 （Singleton） ##

单例模式就是保证进程中，类型只有一个实例
     a) 构造函数私有化，防止他人实例化
     b) 对外提供一个获取实例的途径，公开的静态方法
     c) 返回共用一个静态字段

### 单例方式一：懒汉试双if锁 ###

/// <summary>
        /// 单例类：一个构造对象很耗时耗资源类型
        /// 懒汉式
        /// </summary>
        public sealed class Singleton
        { 
            /// <summary>
            /// 对象会持有资源
            /// </summary>
            private List<string> ConnList = new List<string>()
            { 
            };
    
            /// <summary>
            /// 构造函数耗时耗资源
            /// </summary>
            private Singleton()
            { 
                long lResult = 0;
                for (int i = 0; i < 10000000; i++)
                { 
                    lResult += i;
                }
                Thread.Sleep(1000);
                Console.WriteLine($"{this.GetType().Name}被构造一次");
            }
    
            private static Singleton _Singleton = null;
            private static readonly object Singleton_Lock = new object();
            public static Singleton CreateInstance()
            { 
                //开始多线程初始化---lock锁定--线程请求锁--开始判断创建
                //以上多线程都结束后---再来多个线程请求呢？--都需要等待锁
                //--拿到锁--进去判断--不为空--返回对象--。。。。
                //有点浪费，不需要等待锁，直接判断就行了
                if (_Singleton == null)
                { 
                    lock (Singleton_Lock)//可以保证任意时刻只有一个线程进入，其他线程等待
                    { 
                        if (_Singleton == null)//这个判断不能去掉，保证只初始化一次
                        { 
                            _Singleton = new Singleton();
                        }
                    }
                }
                return _Singleton;
            }
    
            public static void DoNothing()
            {  }
        }

### 单例方式二：饿汉式静态构造函数 ###

public sealed class SingletonSecond
        { 
            /// <summary>
            /// 对象会持有资源
            /// </summary>
            private List<string> ConnList = new List<string>()
            { 
            };
    
            /// <summary>
            /// 构造函数耗时耗资源
            /// </summary>
            private SingletonSecond()
            { 
                long lResult = 0;
                for (int i = 0; i < 10000000; i++)
                { 
                    lResult += i;
                }
                Thread.Sleep(1000);
                Console.WriteLine($"{this.GetType().Name}被构造一次");
            }
    
            private static SingletonSecond _SingletonSecond = null;
            /// <summary>
            /// 静态构造函数：由CLR保证，在第一次使用到这个类型之前，自动被调用且只调用一次
            /// 很多初始化都可以写在这里
            /// </summary>
            static SingletonSecond()
            { 
                _SingletonSecond = new SingletonSecond();
            }
            public static SingletonSecond CreateInstance()
            { 
                return _SingletonSecond;
            }
    
        }

### 单例模式三：饿汉式静态字段 ###

/// <summary>
    /// 饿汉式
    /// </summary>
    public sealed class SingletonThird
    {
        /// <summary>
        /// 对象会持有资源
        /// </summary>
        private List<string> ConnList = new List<string>()
        {
            "这里是数据库连接1",
            "这里是数据库连接2",
            "这里是数据库连接3",
            "这里是数据库连接4",
            "这里是数据库连接5"//一些其他资源
        };
    
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private SingletonThird()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine($"{this.GetType().Name}被构造一次");
        }
        /// <summary>
        /// 静态字段:由CLR保障，在第一次使用这个类型之前，会自动初始化且只初始化一次
        /// </summary>
        private static SingletonThird _SingletonThird = new SingletonThird();
    	public static SingletonThird CreateInstance()
        {
            return _SingletonThird;
        }
    
    }

### 调用方式 ###

Singleton singleton = Singleton.CreateInstance();
    SingletonSecond singletonSecond = SingletonSecond.CreateInstance();
    SingletonThird singletonThird = SingletonThird.CreateInstance();

### 如果正确使用单例模式呢？ ###

学完单例，就恨不得把全部类型都搞成单例，这是不对的。因为单例模式会常驻内存中用来重用对象，不会自动销毁。所以不会节省多少资源。而且单例模式并不能保证整个类中的多线程并发问题。因此**我们只需要这个对象实例化一次并且只允许实例化的时候使用单例模式**就可以了。  
例如：  
1. 数据库连接池  
2. 流水号生成器  
3. 配置文件读取  
4. IOC容器实例

## 简单工厂 (Simple Factory) ##

简单工厂设计模式：包含一组需要创建的对象，通过一个工厂类来实例化对象

### 基于依赖倒置原则的简单工厂 ###

public class Player
        { 
            public int Id {  get; set; }
            public string Name {  get; set; }
    		//一个方法代替多个方法 泛型
            //即使将来种族有新的扩展，都可以使用
            public void Play(IRace iRace)
            { 
                Console.WriteLine("******************************");
                Console.WriteLine("This is {0} Play War3.{1}", this.Name, iRace.GetType().Name);
                iRace.ShowKing();
            }
        }

public interface IRace
        { 
            void ShowKing();
        }

public enum RaceType
        { 
            Human,
            NE,
            ORC,
            Undead
        }

public class ObjectFactory
        { 
            public static IRace CreateInstance(RaceType raceType)
            { 
    
    
                IRace race = null;
                switch (raceType)
                { 
                    case RaceType.Human:
                        race = new Human();
                        break;
                    case RaceType.NE:
                        race = new NE();
                        break;
                    case RaceType.ORC:
                        race = new ORC();
                        break;
                    case RaceType.Undead:
                        race = new Undead();
                        break;
                    default:
                        throw new Exception("wrong raceType");
                }
                return race;
            }
        }

调用方式

IRace race = ObjectFactory.CreateInstance(RaceType.Human);
        player.Play(race);

### 基于配置文件的简单工厂 ###

public class ObjectFactory
        { 
    
            private static string IRaceType = ConfigurationManager.AppSettings["IRaceType"];
            public static IRace CreateInstanceConfig()
            { 
                RaceType raceType = (RaceType)Enum.Parse(typeof(RaceType), IRaceType);
                return CreateInstance(raceType);
            }
    
    
        }

调用方式

IRace race = ObjectFactory.CreateInstanceConfig();
        player.Play(race);

### 基于反射+配置文件的简单工厂 ###

public class ObjectFactory
        { 
    
            private static string IRaceTypeReflection = ConfigurationManager.AppSettings["IRaceTypeReflection"];
            public static IRace CreateInstanceConfigReflection()
            { 
                Assembly assembly = Assembly.Load(IRaceTypeReflection.Split(',')[1]);
                Type type = assembly.GetType(IRaceTypeReflection.Split(',')[0]);
                return (IRace)Activator.CreateInstance(type);
            }
        }

调用方式

IRace race = ObjectFactory.CreateInstanceConfigReflection();
        player.Play(race);

### 关于简单工厂 ###

GOF23种设计模式是不包含简单工厂的。
    简单工厂的好处就是去掉上端对细节的依赖，保证上端的稳定。但是它并没有消除矛盾，只是转移矛盾，甚至还集中了矛盾

## 工厂方法（Factory Method ） ##

包含一组需要创建的对象，通过一个工厂类来实例化对象

public interface IFactory
        { 
            IRace CreateInstance();
        }

/// <summary>
        /// 工厂类
        /// </summary>
        public class HumanFactory : IFactory
        { 
           /// <summary>
           /// 使用虚方法还可以为以后扩展做铺垫
           /// </summary>
           /// <returns></returns>
            public virtual IRace CreateInstance()
            { 
                IRace race = new Human();
                return race;
            }
        }

public interface IRace
        { 
            void ShowKing();
        }

调用方式

IFactory humanFactory = new HumanFactory();
        IRace human = humanFactory.CreateInstance();

### 关于工厂方法 ###

将创建实例的细节交给工厂类，使上端不需要主要这些细节。在拓展时只需添加新的工厂类，减少对源代码的改动，使代码更加文档。
    但将工厂方法独立以后，原本需要一句new可以解决的事情变成了两句才可以解决。所以不适合大范围使用。一般对构造复杂的类使用。

## 抽象工厂（Abstract Factory） ##

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

public interface IGroup
        { 
              void ShowGroup();
        }
         public interface IGenerals
        { 
            void ShowGenerals();
        }
        public class FactoryShu
        { 
            public IGroup CreateGroup() 
            { 
                return new GroupShu();
            }
            public IGenerals CreateGenerals()
            { 
                return new GeneralsShu();
            }
        }

public class GeneralsShu: IGenerals
        { 
            public void ShowGenerals()
            { 
                Console.WriteLine("{0} is 关羽、张飞、赵云、马超、黄忠", this.GetType().Name);
            }
        }
        public class GroupShu :IGroup
        { 
            public void ShowGroup()
            { 
                Console.WriteLine("{0} is 刘备", this.GetType().Name);
            }
        }

调用方式：

FactoryShu factoryShu = new FactoryShu();
        IGroup group = factoryShu.CreateGroup();
        IGenerals generals = factoryShu.CreateGenerals();
        group.ShowGroup();
        generals.ShowGenerals();

### 关于抽象工厂 ###

抽象工厂属于倾斜试可拓展设计，对于产品簇扩展方便，但对于工厂职责不能扩展。否则改起来很麻烦。
    不适合在产品不确定的情况使用，产品不定会导致频繁修改工厂职责，这对于这个模式来说是灾难性的
    官方参考类：DbProciderFactory

## 建造者模式（Builder） ##

建造者模式就是一步步创建一个对象，它对用户屏蔽了里面构建的细节，但却可以精细地控制对象的构造过程。

/// <summary>
        /// 工人抽象
        /// </summary>
        public abstract class AbstractBuilder
        { 
    
            public abstract void Engine();
    
            public abstract void Wheels();
    
            public abstract void Light();
    
            public abstract Car Car();
        }

/// <summary>
        /// 比亚迪工人
        /// </summary>
        public class BuilderBYD : AbstractBuilder
        { 
            private Engine _Engine = null;
            private Wheels _Wheels = null;
            private Light _Light = null;
    
            public override void Engine()
            { 
                this._Engine = new Engine()
                { 
                    Name = "_Engine"
                };
    
                Console.WriteLine("{0} build Engine", this.GetType().Name);
            }
    
            public override void Wheels()
            { 
                this._Wheels = new Wheels()
                { 
                    Name = "_Wheels"
                };
                Console.WriteLine("{0} build Wheels", this.GetType().Name);
            }
    
            public override void Light()
            { 
                this._Light = new Light()
                { 
                    Name = "_Light"
                };
                Console.WriteLine("{0} build Light", this.GetType().Name);
            }
    
            public override Car Car()
            { 
                Console.WriteLine("组装 {0} {1} {2}", this._Engine, this._Light, this._Wheels);
                Console.WriteLine("{0} build 比亚迪*唐", this.GetType().Name);
    
                return new Car(this._Engine, this._Light, this._Wheels)
                { 
                    Name = "比亚迪*唐"
                };
            }
        }

public class Director
        { 
            private AbstractBuilder _AbstractBuilder = null;
            public Director(AbstractBuilder builder)
            { 
                this._AbstractBuilder = builder;
            }
    
            public Car GetCar()
            { 
                this._AbstractBuilder.Engine();
                this._AbstractBuilder.Wheels();
                this._AbstractBuilder.Light();
    
                return this._AbstractBuilder.Car();
            }
        }

调用方式：

AbstractBuilder builder = new BuilderBYD();
        Director director = new Director(builder);
        director.GetCar();

### 关于建造者模式 ###

建造者在平常使用中并不太常见，因为一般这种模式需要创建对象过于复杂时才会使用并且创建流程不能经常变更

## 原型模式（Prototype） ##

用原型模式可以用原型实例指定创建对象的种类，它允许通过一个原型对象创建多个同类型的其他对象，而无需知道该对象的创建细节

/// <summary>
        /// 原型类
        /// </summary>
        public class StudentPrototype
        { 
            /// <summary>
            /// 1 构造函数私有化--避免随意构造
            /// </summary>
            private StudentPrototype()
            { 
                Thread.Sleep(2000);
                long lResult = 0;
                for (int i = 0; i < 1000000; i++)
                { 
                    lResult += i;
                }
                Console.WriteLine("{0}被构造..", this.GetType().Name);
            }
            /// <summary>
            /// 3 私有的静态字段--内存唯一，不会释放，且在第一次使用这个类被初始化且只初始化一次
            /// </summary>
            private static StudentPrototype _Student = new StudentPrototype()
            { 
                Id = 123,
                Name = "张三",
                Class = new Class()
                { 
                    ClassId = 1,
                    ClassName = "三年一班"
                }
            };
            /// <summary>
            /// 2 公开的静态方法来提供实例
            /// </summary>
            /// <returns></returns>
            public static StudentPrototype CreateInstance()
            { 
                StudentPrototype student = (StudentPrototype)_Student.MemberwiseClone();
                //MemberwiseClone:内存拷贝，不走构造函数，直接内存copy，所以没有性能损失；而且产生的是新对象----浅拷贝--只拷贝引用
                return student;
            }
    
            public static StudentPrototype CreateInstanceSerialize()
            { 
                return SerializeHelper.DeepClone<StudentPrototype>(_Student);
            }
    
            public int Id {  get; set; }
            public string Name {  get; set; }
            public Class Class {  get; set; }
    
            public void Study()
            { 
                Console.WriteLine("{0}在学习语文", this.Name);
            }
    
        }
        public class Class
        { 
            public int ClassId {  get; set; }
            public string ClassName {  get; set; }
        }

调用方式：

StudentPrototype student1 = StudentPrototype.CreateInstance();
            StudentPrototype student2 = StudentPrototype.CreateInstance();
            StudentPrototype student3 = StudentPrototype.CreateInstance();
            student1.Id = 234;
            student1.Name = "李四";
            student1.Class.ClassId = 2;
            student1.Class.ClassName = "四年一班";
            //因为string类型的 ="CodeMan" 等同于 new String("CodeMan"); 开辟新的空间，不影响之前的-----实际上string是不可修改的----
    
            student2.Id = 345;
            student2.Name = "王五";
            student2.Class.ClassId = 3;
            student2.Class.ClassName = "五年一班";
    
            student3.Id = 456;
            student3.Name = "赵六";
            student3.Class = new Class()
            { 
                ClassId = 4,
                ClassName = "六年一班"
            };//换了个引用
            student1.Study();
            student2.Study();
            student3.Study();
            //输出结果：334

这里会发现一个问题，因为**内存分配**的原因student中的class对象会被分配到堆内存中。而class对象又保存着值类型的引用。导致每次复制出来的对象class引用都是相同的。  
但**string**类型没有这个问题，因为在**MemberwiseClone**方法中对string做了特殊处理，等同于 new String(“李四”);属于开辟新的空间，不会影响之前的内存。（实际上string被修改也是重新分配内存地址）  
处理这种问题需要使用深度复制（deepcopy）一般有三种方法：  
1. 直接new  
2. 子类型提供原型方式  
3. 序列化反序列化

这里演示一下第一种和第三种

### 直接new ###

/// <summary>
        /// 2 公开的静态方法来提供实例
        /// </summary>
        /// <returns></returns>
        public static StudentPrototype CreateInstance()
        { 
            StudentPrototype student = (StudentPrototype)_Student.MemberwiseClone();
            student.Class = new Class()
            { 
                ClassId = student.Class.ClassId,
                ClassName = student.Class.ClassName
            };
            return student;
        }

### 序列化反序列化 ###

public class SerializeHelper
        { 
            public static string Serializable(object target)
            { 
                using (MemoryStream stream = new MemoryStream())
                { 
                    new BinaryFormatter().Serialize(stream, target);
    
                    return Convert.ToBase64String(stream.ToArray());
                }
            }
            public static T Derializable<T>(string target)
            { 
                byte[] targetArray = Convert.FromBase64String(target);
    
                using (MemoryStream stream = new MemoryStream(targetArray))
                { 
                    return (T)(new BinaryFormatter().Deserialize(stream));
                }
            }
            public static T DeepClone<T>(T t)
            { 
                return Derializable<T>(Serializable(t));
            }
        }

/// <summary>
        /// 2 公开的静态方法来提供实例
        /// </summary>
        /// <returns></returns>
        public static StudentPrototype CreateInstance()
        { 
             return SerializeHelper.DeepClone<StudentPrototype>(_Student);
        }

### 关于原型模式 ###

对于原型模式一定要特别注意内存的拷贝机制，否则就是给自己挖一个很大的坑。
    原型模式在平时使用出现也比较少，但也相当有意义。原型模式就是用利用对象copy来快速获取对象，一般使用在需要大量新对象的时候（ 如:画图（棋盘）、文档等）