美文网首页Android开发Android开发经验谈
28 Java设计模式系列-原型模式

28 Java设计模式系列-原型模式

作者: 凤邪摩羯 | 来源:发表于2021-01-23 15:43 被阅读0次

    原型模式

    原型模式是非常常见的设计模式之一,写个笔记,记录一下我的学习过程和心得。

    首先了解一些原型模式的定义。

    用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

    又是一个看了让人一脸懵逼的定义,不过没关系,我们看下面的描述的非常清楚啦。

    首先我们定义一个Person类

        public class Person{
            private String name;
            private int age;
            private double height;
            private double weight;
            public Person(){
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
            public double getHeight() {
                return height;
            }
            public void setHeight(double height) {
                this.height = height;
            }
            public double getWeight() {
                return weight;
            }
            public void setWeight(double weight) {
                this.weight = weight;
            }
            @Override
            public String toString() {
                return "Person{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        ", height=" + height +
                        ", weight=" + weight +
                        '}';
            }
        }
    
    

    要实现原型模式,只需要按照下面的几个步骤去实现即可。

    • 实现Cloneable接口
    public class Person implements Cloneable{
     } 
    
    
    • 重写Object的clone方法
    @Override
    public Object clone(){
      return null;
    }
    
    
    • 实现clone方法中的拷贝逻辑
        @Override
        public Object clone(){
            Person person=null;
            try {
                person=(Person)super.clone();
                person.name=this.name;
                person.weight=this.weight;
                person.height=this.height;
                person.age=this.age;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return person;
        }
    
    

    测试一下

        public class Main {
            public static void main(String [] args){
                Person p=new Person();
                p.setAge(18);
                p.setName("张三");
                p.setHeight(178);
                p.setWeight(65);
                System.out.println(p);
                Person p1= (Person) p.clone();
                System.out.println(p1);
                p1.setName("李四");
                System.out.println(p);
                System.out.println(p1);
            }
        }
    
    

    输出结果如下

    Person{name=’张三’, age=18, height=178.0, weight=65.0}
    Person{name=’张三’, age=18, height=178.0, weight=65.0}
    Person{name=’张三’, age=18, height=178.0, weight=65.0}
    Person{name=’李四’, age=18, height=178.0, weight=65.0}

    试想一下,两个不同的人,除了姓名不一样,其他三个属性都一样,用原型模式进行拷贝就会显得异常简单,这也是原型模式的应用场景之一。

    一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用,即保护性拷贝。

    但是假设Person类里还有一个属性叫兴趣爱好,是一个List集合,就像这样子

        private ArrayList<String> hobbies=new ArrayList<String>();
        public ArrayList<String> getHobbies() {
            return hobbies;
        }
        public void setHobbies(ArrayList<String> hobbies) {
            this.hobbies = hobbies;
        }
    
    

    在进行拷贝的时候要格外注意,如果你直接按之前的代码那样拷贝

        @Override
        public Object clone(){
            Person person=null;
            try {
                person=(Person)super.clone();
                person.name=this.name;
                person.weight=this.weight;
                person.height=this.height;
                person.age=this.age;
                person.hobbies=this.hobbies;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return person;
        }
    
    

    会带来一个问题

    使用测试代码进行测试

        public class Main {
            public static void main(String [] args){
                Person p=new Person();
                p.setAge(18);
                p.setName("张三");
                p.setHeight(178);
                p.setWeight(65);
                ArrayList <String> hobbies=new ArrayList<String>();
                hobbies.add("篮球");
                hobbies.add("编程");
                hobbies.add("长跑");
                p.setHobbies(hobbies);
                System.out.println(p);
                Person p1= (Person) p.clone();
                System.out.println(p1);
                p1.setName("李四");
                p1.getHobbies().add("游泳");
                System.out.println(p);
                System.out.println(p1);
            }
        }
    
    

    我们拷贝了一个对象,并添加了一个兴趣爱好进去,看下打印结果

    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}
    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}
    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑, 游泳]}
    Person{name=’李四’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑, 游泳]}

    你会发现原来的对象的hobby也发生了变换。

    其实导致这个问题的本质原因是我们只进行了浅拷贝,也就是只拷贝了引用,最终两个对象指向的引用是同一个,一个发生变化另一个也会发生变换,显然解决方法就是使用深拷贝。

        @Override
        public Object clone(){
            Person person=null;
            try {
                person=(Person)super.clone();
                person.name=this.name;
                person.weight=this.weight;
                person.height=this.height;
                person.age=this.age;
                person.hobbies=(ArrayList<String>)this.hobbies.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return person;
        }
    
    

    注意person.hobbies=(ArrayList)this.hobbies.clone();,不再是直接引用而是进行了一份拷贝。再运行一下,就会发现原来的对象不会再发生变化了。

    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}
    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}
    Person{name=’张三’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑]}
    Person{name=’李四’, age=18, height=178.0, weight=65.0, hobbies=[篮球, 编程, 长跑, 游泳]}

    其实有时候我们会更多的看到原型模式的另一种写法。

    • 在clone函数里调用构造函数,构造函数的入参是该类对象。
    @Override
    public Object clone(){
      return new Person(this);
    }
    
    
    • 在构造函数中完成拷贝逻辑
        public Person(Person person){
            this.name=person.name;
            this.weight=person.weight;
            this.height=person.height;
            this.age=person.age;
            this.hobbies= new ArrayList<String>(hobbies);
        }
    
    

    其实都差不多,只是写法不一样。

    广泛应用

    现在来挖挖android中的原型模式。

    先看Bundle类,该类实现了Cloneable接口

        public Object clone() {
            return new Bundle(this);
        }
        public Bundle(Bundle b) {
            super(b);
            mHasFds = b.mHasFds;
            mFdsKnown = b.mFdsKnown;
        }
    
    

    然后是Intent类,该类也实现了Cloneable接口

        @Override
        public Object clone() {
            return new Intent(this);
        }
        public Intent(Intent o) {
            this.mAction = o.mAction;
            this.mData = o.mData;
            this.mType = o.mType;
            this.mPackage = o.mPackage;
            this.mComponent = o.mComponent;
            this.mFlags = o.mFlags;
            this.mContentUserHint = o.mContentUserHint;
            if (o.mCategories != null) {
                this.mCategories = new ArraySet<String>(o.mCategories);
            }
            if (o.mExtras != null) {
                this.mExtras = new Bundle(o.mExtras);
            }
            if (o.mSourceBounds != null) {
                this.mSourceBounds = new Rect(o.mSourceBounds);
            }
            if (o.mSelector != null) {
                this.mSelector = new Intent(o.mSelector);
            }
            if (o.mClipData != null) {
                this.mClipData = new ClipData(o.mClipData);
            }
        }
    
    

    用法也显得十分简单,一旦我们要用的Intent与现有的一个Intent很多东西都是一样的,那我们就可以直接拷贝现有的Intent,再修改不同的地方,便可以直接使用。

    Uri uri = Uri.parse("smsto:10086");    
    Intent shareIntent = new Intent(Intent.ACTION_SENDTO, uri);    
    shareIntent.putExtra("sms_body", "hello");    
     Intent intent = (Intent)shareIntent.clone() ;
    startActivity(intent);
    
    

    网络请求中一个最常见的开源库OkHttp中,也应用了原型模式。它就在OkHttpClient这个类中,它实现了Cloneable接口

        /** Returns a shallow copy of this OkHttpClient. */
        @Override
        public OkHttpClient clone() {
            return new OkHttpClient(this);
        }
        private OkHttpClient(OkHttpClient okHttpClient) {
            this.routeDatabase = okHttpClient.routeDatabase;
            this.dispatcher = okHttpClient.dispatcher;
            this.proxy = okHttpClient.proxy;
            this.protocols = okHttpClient.protocols;
            this.connectionSpecs = okHttpClient.connectionSpecs;
            this.interceptors.addAll(okHttpClient.interceptors);
            this.networkInterceptors.addAll(okHttpClient.networkInterceptors);
            this.proxySelector = okHttpClient.proxySelector;
            this.cookieHandler = okHttpClient.cookieHandler;
            this.cache = okHttpClient.cache;
            this.internalCache = cache != null ? cache.internalCache : okHttpClient.internalCache;
            this.socketFactory = okHttpClient.socketFactory;
            this.sslSocketFactory = okHttpClient.sslSocketFactory;
            this.hostnameVerifier = okHttpClient.hostnameVerifier;
            this.certificatePinner = okHttpClient.certificatePinner;
            this.authenticator = okHttpClient.authenticator;
            this.connectionPool = okHttpClient.connectionPool;
            this.network = okHttpClient.network;
            this.followSslRedirects = okHttpClient.followSslRedirects;
            this.followRedirects = okHttpClient.followRedirects;
            this.retryOnConnectionFailure = okHttpClient.retryOnConnectionFailure;
            this.connectTimeout = okHttpClient.connectTimeout;
            this.readTimeout = okHttpClient.readTimeout;
            this.writeTimeout = okHttpClient.writeTimeout;
        }
    
    

    正如开头的注释Returns a shallow copy of this OkHttpClient,该clone方法返回了一个当前对象的浅拷贝对象。

    至于其他框架中的原型模式,请读者自行发现。

    总结

    总结一下观察者模式的有确定及应用场景。

    优点

    1. 使用原型模型创建一个对象比直接new一个对象更有效率,因为它直接操作内存中的二进制流,特别是复制大对象时,性能的差别非常明显。
    2. 隐藏了制造新实例的复杂性,使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

    缺点

    1. 由于使用原型模式复制对象时不会调用类的构造方法,所以原型模式无法和单例模式组合使用,因为原型类需要将clone方法的作用域修改为public类型,那么单例模式的条件就无法满足了。
    2. 使用原型模式时不能有final对象。
    3. Object类的clone方法只会拷贝对象中的基本数据类型,对于数组,引用对象等只能另行拷贝。这里涉及到深拷贝和浅拷贝的概念。

    相关文章

      网友评论

        本文标题:28 Java设计模式系列-原型模式

        本文链接:https://www.haomeiwen.com/subject/oemzoktx.html