设计模式的艺术之道--原型模式

设计模式的艺术之道–原型模式

声明：本系列为刘伟老师博客内容总结(http://blog.csdn.net/lovelion)，博客中有完整的设计模式的相关博文，以及作者的出版书籍推荐

本系列内容思路分析借鉴了刘伟老师的博文内容，同时改用C#代码进行代码的演示和分析(Java资料过多 C#表示默哀).

本系列全部源码均在文末地址给出。

---

本系列开始讲解创建型模式，顾名思义，这类模式主要是为了解决类的创建问题。

• 创建型模式(Creational Pattern)关注对象的创建过程。分析你怎么来的
• 创建型模式对类的实例化过程进行了抽象，对用户隐藏了类的实例的创建细节。客户不知道你怎么来的
• 创建型模式描述如何将对象的创建和使用分离，让用户在使用对象时无须关心对象的创建细节。你用就行，别管我怎么来的。
• 创建型模式关注点 创建什么(What) 由谁创建(Who) 何时创建(When)
  6种常见的创建型模式

原型模式

孙悟空可以用猴毛根据自己的形象，复制（又称“克隆”或“拷贝”）出很多跟自己长得一模一样的“身外身”来。在设计模式中也存在一个类似的模式，可以通过一个原型对象克隆出多个一模一样的对象，该模式称之为原型模式。

1.1定义

• 原型模式 (Prototype Pattern)：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。
• 通过一个原型来量产其他的产品，抄作业的上学时代，小红做了一份数学作业，张三李四王五都抄了一份，内容都一模一样。
• 将一个原型对象传给要客户端对象，通过请求原型对象复制自己来实现创建过程
• 克隆所创建的对象是全新的对象，它们在内存中拥有新的地址，每一个克隆对象都是独立的

1.2情景实例

问题描述

• 工作周报系统设计
  菜鸟软件公司规模越来越大，职工也越来越多，公司规定每周必须完成周报，但是有些岗位的工作内容比较存在重复性，工作周报内容都大同小异，员工对反复创建和编写工作周报产生了抱怨。周报在在线填写模式，填写完毕直接上传到服务器，不可上传本地文件。现行系统每周默认创建的周报都是空白报表，用户只能通过重新输入或不断复制粘贴来填写重复的周报内容，极大降低了工作效率。如何快速创建相同或者相似的工作周报，成为Sunny公司OA开发人员面临的一个新问题。

初步思路

对工作周报模块进行重新设计和实现：
(1)除了允许用户创建新周报外，还允许用户将创建好的周报保存为模板；
(2)用户在再次创建周报时，可以创建全新的周报，还可以选择合适的模板复制生成一份相同的周报，然后对新生成的周报根据实际情况进行修改，产生新的周报。

UML类图

关键源代码

namespace Prototype
{
    class WeeklyLog:ICloneable
    {
        private String name;
        private String date;
        private String content;
        public void setName(String name)
        {
            this.name = name;
        }
        public void setDate(String date)
        {
            this.date = date;
        }
        public void setContent(String content)
        {
            this.content = content;
        }
        public String getName()
        {
            return (this.name);
        }
        public String getDate()
        {
            return (this.date);
        }
        public String getContent()
        {
            return (this.content);
        }
        //克隆方法clone()，此处使用C#语言提供的克隆机制

        public Object Clone()
        {
            WeeklyLog obj = new Prototype.WeeklyLog ();
            try
            {

                obj.name = this.name;
                obj.date = this.date;
                obj.content = this.content;
                return (Object)obj;
            }
            catch
            {
                Console.WriteLine("不支持复制！");
                return null;
            }
        }
    }
     class Program
    {
        static void Main(string[] args)
        {
            WeeklyLog log_previous = new WeeklyLog();  //创建原型对象
            log_previous.setName("张无忌");
            log_previous.setDate("第12周");
            log_previous.setContent("这周工作很忙，每天加班！");

            Console.WriteLine("****周报****");
            Console.WriteLine("周次：" + log_previous.getDate());
            Console.WriteLine("姓名：" + log_previous.getName());
            Console.WriteLine("内容：" + log_previous.getContent());
            Console.WriteLine("--------------------------------");

            WeeklyLog log_new;
            log_new = (WeeklyLog)log_previous.Clone(); //调用克隆方法创建克隆对象
            log_new.setDate("第13周");
            Console.WriteLine("****周报****");
            Console.WriteLine("周次：" + log_new.getDate());
            Console.WriteLine("姓名：" + log_new.getName());
            Console.WriteLine("内容：" + log_new.getContent());
        }
    }
}

现有缺点（未来变化）

• 工作进行，发现需要有附件的加载，但是上诉实现并不能实现附件的复制

• 如何才能实现周报和附件的同时复制呢？继续探讨。

  深克隆与浅克隆

  首先看一下两种克隆方式
  浅克隆(Shallow Clone)：当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制(房子起名字 同一个房子 可以叫茅草屋 也可以叫狗窝 也可以叫皇宫 这几个名字都指向这个房子)
  深克隆(Deep Clone)：除了对象本身被复制外，对象所包含的所有成员变量也将被复制（细胞复制，工厂批量盖房子 新的对象与原有对象有相同的的内容 同时占据新的空间）

新的需求UML类图

浅克隆分析

在C#语言中，通过覆盖Object类的MemberwiseClone()方法可以实现浅克隆(也可以自己重新写一个)，。我们首先使用浅克隆来实现工作周报和附件类的复制，来感受二者的不同区别。

实例关键代码

namespace ShallowClone
{
    class Attachment
    {
        private string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public void Download()
        {
            Console.WriteLine("下载附件，文件名为{0}。", name);
        }
    }
    class WeeklyLog:ICloneable
    {
        private Attachment attachment;
        private string name;
        private string date;
        private string content;

        public Attachment Attachment
        {
            get { return attachment; }
            set { attachment = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public string Date
        {
            get { return date; }
            set { date = value; }
        }
        public string Content
        {
            get { return content; }
            set { content = value; }
        }
        public object Clone()
        {
            return this.MemberwiseClone(); //客户端进行类型转换
        }
        //使用MemberwiseClone()方法实现浅克隆
        //public WeeklyLog Clone()
        //{
        //     return this.MemberwiseClone() as WeeklyLog;
        //}
    }
     class Program
    {
        static void Main(string[] args)
        {
            WeeklyLog log_previous, log_new;
            log_previous = new WeeklyLog();
            Attachment attachment = new Attachment();
            log_previous.Attachment = attachment;
            log_new = (WeeklyLog)log_previous.Clone();
            Console.WriteLine("周报是否相同？{0}", (log_previous == log_new) ? "是" : "否");
            Console.WriteLine("附件是否相同？{0}", (log_previous.Attachment == log_new.Attachment) ? "是" : "否");
            Console.Read();
        }
    }
}

输出结果

值类型进行了复制，但是引用类型只是传递了引用

深克隆分析(序列化方式)

深克隆常见的有序列号方式 C#自身还可以用反射进行
序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

实例关键代码

 Clone不同 其他相同 需要复制的内容添加序列化标签
  //使用序列化方式实现深克隆
        public Object Clone()
        {
            Object clone = null;
            FileStream fs = new FileStream("Temp.dat", FileMode.Create);
            BinaryFormatter formatter = new BinaryFormatter();
            try
            {
                formatter.Serialize(fs, this);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
            finally
            {
                fs.Close();
            }

            FileStream fs1 = new FileStream("Temp.dat", FileMode.Open);
            BinaryFormatter formatter1 = new BinaryFormatter();
            try
            {
                clone = (WeeklyLog)formatter1.Deserialize(fs1);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
                throw;
            }
            finally
            {
                fs.Close();
            }
            return clone;
        }

输出结果

深克隆分析(序列化方式)

利用反射 通过反射拿到引用类型的类型并创建一个实例，将原来的数据赋值给信创建的实例。
纯反射实现，无需实现任何接口，哦对，需要实体类有个无参的构造方法，简单使用强大。

实例关键代码

public Object Copy(object obj)
{
    if (obj == null)
    {
        return null;
    }
    Object targetDeepCopyObj;
    Type targetType = obj.GetType();
    //值类型  
    if (targetType.IsValueType == true)
    {
        targetDeepCopyObj = obj;
    }
    //引用类型   
    else
    {
        targetDeepCopyObj = System.Activator.CreateInstance(targetType);   //创建引用对象   
        System.Reflection.MemberInfo[] memberCollection = obj.GetType().GetMembers();

        foreach (System.Reflection.MemberInfo member in memberCollection)
        {
            //拷贝字段
            if (member.MemberType == System.Reflection.MemberTypes.Field)
            {
                System.Reflection.FieldInfo field = (System.Reflection.FieldInfo)member;
                Object fieldValue = field.GetValue(obj);
                if (fieldValue is ICloneable)
                {
                    field.SetValue(targetDeepCopyObj, (fieldValue as ICloneable).Clone());
                }
                else
                {
                    field.SetValue(targetDeepCopyObj, Copy(fieldValue));
                }

            }
            //拷贝属性
            else if (member.MemberType == System.Reflection.MemberTypes.Property)
            {
                System.Reflection.PropertyInfo myProperty = (System.Reflection.PropertyInfo)member;

                MethodInfo info = myProperty.GetSetMethod(false);
                if (info != null)
                {
                    try
                    {
                        object propertyValue = myProperty.GetValue(obj, null);
                        if (propertyValue is ICloneable)
                        {
                            myProperty.SetValue(targetDeepCopyObj, (propertyValue as ICloneable).Clone(), null);
                        }
                        else
                        {
                            myProperty.SetValue(targetDeepCopyObj, Copy(propertyValue), null);
                        }
                    }
                    catch (System.Exception ex)
                    {

                    }
                }
            }
        }
    }
    return targetDeepCopyObj;
}

public object Clone()
{
    Object obj = Copy(this);
    return obj;
}

1.3模式分析

动机和意图

• 如何根据自己的形状复制（克隆）出多个身外身？
• 怎样通过复制一个原型对象得到多个与原型对象一模一样的新对象？

一般结构

• 原型模式包含三个角色：
• Prototype（抽象原型类） 提供公有的属性和Clone()方法
• ConcretePrototype（具体原型类） 继承抽象原型类 使其可以自身复制
• Client（客户类） 调用原型类进行克隆复制

改进的优点

• 简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率
• 扩展性较好，原型改变，克隆对象也直接改变
• 可以使用深克隆的方式保存对象的状态，增加撤销功能

现存的缺点

• 需要为每一个类配备一个克隆方法，当对已有的类进行改造时，需要修改源代码，违背了开闭原则
• 在实现深克隆时需要编写较为复杂的代码

优化空间

• 原型较多时，比较难以进行管理分辨，可以引入一个原型管理类
• 原型管理器将多个原型对象存储在一个集合中供客户端使用，可以通过复制集合中对应的原型对象来获得
• 圆形管理器需要使用单例模式，对象集合通常使用HashTable

适用场景
(1)创建新对象成本较大，新对象可以通过复制已有对象来获得，如果是相似对象，则可以对其成员变量稍作修改
(2) 系统要保存对象的状态，而对象的状态变化很小。
举例:金拱门汉堡 同样的配方同样的味道 煤老板小王去买车，进门看着奥拓86不错 直接大手一挥，给我来一打这个一模一样的。
实例源代码
GitHub地址
百度云地址:链接: https://pan.baidu.com/s/1jIw2Umq 密码: 24zr