关于后端:原型模式与享元模式

45次阅读

共计 6753 个字符，预计需要花费 17 分钟才能阅读完成。

原型模式与享元模式

原型模式和享元模式，前者是在创立多个实例时，对创立过程的性能进行调优；后者是用缩小创立实例的形式，来调优零碎性能。这么看，你会不会感觉两个模式有点互相矛盾呢？

其实不然，它们的应用是分场景的。在有些场景下，咱们须要反复创立多个实例，例如在循环体中赋值一个对象，此时咱们就能够采纳原型模式来优化对象的创立过程；而在有些场景下，咱们则能够防止反复创立多个实例，在内存中共享对象就好了。

明天咱们就来看看这两种模式的实用场景，看看如何应用它们来晋升零碎性能。

原型模式

原型模式是通过给出一个原型对象来指明所创立的对象的类型，而后应用本身实现的克隆接口来复制这个原型对象，该模式就是用这种形式来创立出更多同类型的对象。

应用这种形式创立新的对象的话，就无需再通过 new 实例化来创建对象了。这是因为 Object 类的 clone 办法是一个本地办法，它能够间接操作内存中的二进制流，所以性能绝对 new 实例化来说，更佳。

实现原型模式

咱们当初通过一个简略的例子来实现一个原型模式：

   // 实现 Cloneable 接口的原型抽象类 Prototype
   class Prototype implements Cloneable {
        // 重写 clone 办法
        public Prototype clone(){
            Prototype prototype = null;
            try{prototype = (Prototype)super.clone();}catch(CloneNotSupportedException e){e.printStackTrace();
            }
            return prototype;
        }
    }
    // 实现原型类
    class ConcretePrototype extends Prototype{public void show(){System.out.println("原型模式实现类");
        }
    }

    public class Client {public static void main(String[] args){ConcretePrototype cp = new ConcretePrototype();
            for(int i=0; i< 10; i++){ConcretePrototype clonecp = (ConcretePrototype)cp.clone();
                clonecp.show();}
        }
    }

要实现一个原型类，须要具备三个条件：

  • 实现 Cloneable 接口：Cloneable 接口与序列化接口的作用相似，它只是通知虚拟机能够平安地在实现了这个接口的类上应用 clone 办法。在 JVM 中，只有实现了 Cloneable 接口的类才能够被拷贝，否则会抛出 CloneNotSupportedException 异样。
  • 重写 Object 类中的 clone 办法：在 Java 中，所有类的父类都是 Object 类，而 Object 类中有一个 clone 办法，作用是返回对象的一个拷贝。
  • 在重写的 clone 办法中调用 super.clone()：默认状况下，类不具备复制对象的能力，须要调用 super.clone() 来实现。

从下面咱们能够看出，原型模式的次要特色就是应用 clone 办法复制一个对象。通常，有些人会误以为 Object a=new Object();Object b=a; 这种模式就是一种对象复制的过程，然而这种复制只是对象援用的复制，也就是 a 和 b 对象指向了同一个内存地址，如果 b 批改了，a 的值也就跟着被批改了。

咱们能够通过一个简略的例子来看看一般的对象复制问题：

class Student {
    private String name;

    public String getName() {return name;}

    public void setName(String name) {this.name= name;}

}
public class Test {public static void main(String args[]) {Student stu1 = new Student();
        stu1.setName("test1");

        Student stu2 = stu1;
        stu2.setName("test2");

        System.out.println("学生 1:" + stu1.getName());
        System.out.println("学生 2:" + stu2.getName());
    }
}

如果是复制对象，此时打印的日志应该为：

 学生 1:test1
学生 2:test2

然而，实际上是：

 学生 1:test2
学生 2:test2

通过 clone 办法复制的对象才是真正的对象复制，clone 办法赋值的对象齐全是一个独立的对象。刚刚讲过了，Object 类的 clone 办法是一个本地办法，它间接操作内存中的二进制流，特地是复制大对象时，性能的差异非常明显。咱们能够用 clone 办法再实现一遍以上例子。

// 学生类实现 Cloneable 接口
class Student implements Cloneable{
    private String name;  // 姓名

    public String getName() {return name;}

    public void setName(String name) {this.name= name;}
   // 重写 clone 办法
   public Student clone() {
        Student student = null;
        try {student = (Student) super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();
            }
            return student;
   }

}
public class Test {public static void main(String args[]) {Student stu1 = new Student();  // 创立学生 1
        stu1.setName("test1");

        Student stu2 = stu1.clone();  // 通过克隆创立学生 2
        stu2.setName("test2");

        System.out.println("学生 1:" + stu1.getName());
        System.out.println("学生 2:" + stu2.getName());
    }
}

运行后果：

 学生 1:test1
学生 2:test2

深拷贝和浅拷贝

在调用 super.clone() 办法之后，首先会查看以后对象所属的类是否反对 clone，也就是看该类是否实现了 Cloneable 接口。

如果反对，则创立以后对象所属类的一个新对象，并对该对象进行初始化，使得新对象的成员变量的值与以后对象的成员变量的值截然不同，但对于其它对象的援用以及 List 等类型的成员属性，则只能复制这些对象的援用了。所以简略调用 super.clone() 这种克隆对象形式，就是一种浅拷贝。

所以，当咱们在应用 clone() 办法实现对象的克隆时，就须要留神浅拷贝带来的问题。咱们再通过一个例子来看看浅拷贝。

// 定义学生类
class Student implements Cloneable{
    private String name; // 学生姓名
    private Teacher teacher; // 定义老师类

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public Teacher getTeacher() {return teacher;}

    public void setTeacher(Teacher teacher) {this.teacher = teacher;}
   // 重写克隆办法
   public Student clone() {
        Student student = null;
        try {student = (Student) super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();
            }
            return student;
   }

}

// 定义老师类
class Teacher implements Cloneable{
    private String name;  // 老师姓名

    public String getName() {return name;}

    public void setName(String name) {this.name= name;}

   // 重写克隆办法，对老师类进行克隆
   public Teacher clone() {
        Teacher teacher= null;
        try {teacher= (Teacher) super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();
            }
            return student;
   }

}
public class Test {public static void main(String args[]) {Teacher teacher = new Teacher (); // 定义老师 1
        teacher.setName("刘老师");
        Student stu1 = new Student();  // 定义学生 1
        stu1.setName("test1");
        stu1.setTeacher(teacher);

        Student stu2 = stu1.clone(); // 定义学生 2
        stu2.setName("test2");
        stu2.getTeacher().setName("王老师");// 批改老师
        System.out.println("学生" + stu1.getName + "的老师是:" + stu1.getTeacher().getName);
        System.out.println("学生" + stu1.getName + "的老师是:" + stu2.getTeacher().getName);
    }
}

运行后果：

 学生 test1 的老师是：王老师
学生 test2 的老师是：王老师

察看以上运行后果，咱们能够发现：在咱们给学生 2 批改老师的时候，学生 1 的老师也跟着被批改了。这就是浅拷贝带来的问题。

咱们能够通过深拷贝来解决这种问题，其实深拷贝就是基于浅拷贝来递归实现具体的每个对象，代码如下：

   public Student clone() {
        Student student = null;
        try {student = (Student) super.clone();
            Teacher teacher = this.teacher.clone();// 克隆 teacher 对象
            student.setTeacher(teacher);
            } catch (CloneNotSupportedException e) {e.printStackTrace();
            }
            return student;
   }

实用场景

后面我详述了原型模式的实现原理，那到底什么时候咱们要用它呢？

在一些反复创建对象的场景下，咱们就能够应用原型模式来进步对象的创立性能。例如，我在结尾提到的，循环体内创建对象时，咱们就能够思考用 clone 的形式来实现。

例如：

for(int i=0; i<list.size(); i++){Student stu = new Student();
  ...
}

咱们能够优化为：

Student stu = new Student();
for(int i=0; i<list.size(); i++){Student stu1 = (Student)stu.clone();
  ...
}

除此之外，原型模式在开源框架中的利用也十分宽泛。例如 Spring 中，@Service 默认都是单例的。用了公有全局变量，若不想影响下次注入或每次上下文获取 bean，就须要用到原型模式，咱们能够通过以下注解来实现，@Scope(“prototype”)。

享元模式

享元模式是使用共享技术无效地最大限度地复用细粒度对象的一种模式。该模式中，以对象的信息状态划分，能够分为外部数据和内部数据。外部数据是对象能够共享进去的信息，这些信息不会随着零碎的运行而扭转；内部数据则是在不同运行时被标记了不同的值。

享元模式个别能够分为三个角色，别离为 Flyweight（形象享元类）、ConcreteFlyweight（具体享元类）和 FlyweightFactory（享元工厂类）。形象享元类通常是一个接口或抽象类，向外界提供享元对象的外部数据或内部数据；具体享元类是指具体实现外部数据共享的类；享元工厂类则是次要用于创立和治理享元对象的工厂类。

实现享元模式

咱们还是通过一个简略的例子来实现一个享元模式：

// 形象享元类
interface Flyweight {
    // 对外状态对象
    void operation(String name);
    // 对内对象
    String getType();}

// 具体享元类
class ConcreteFlyweight implements Flyweight {
    private String type;

    public ConcreteFlyweight(String type) {this.type = type;}

    @Override
    public void operation(String name) {System.out.printf("[ 类型 ( 外在状态)] - [%s] - [名字 ( 外在状态)] - [%s]\n", type, name);
    }

    @Override
    public String getType() {return type;}
}

// 享元工厂类
class FlyweightFactory {private static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();// 享元池，用来存储享元对象

    public static Flyweight getFlyweight(String type) {if (FLYWEIGHT_MAP.containsKey(type)) {// 如果在享元池中存在对象，则间接获取
            return FLYWEIGHT_MAP.get(type);
        } else {// 在响应池不存在，则新创建对象，并放入到享元池
            ConcreteFlyweight flyweight = new ConcreteFlyweight(type);
            FLYWEIGHT_MAP.put(type, flyweight);
            return flyweight;
        }
    }
}

public class Client {public static void main(String[] args) {Flyweight fw0 = FlyweightFactory.getFlyweight("a");
        Flyweight fw1 = FlyweightFactory.getFlyweight("b");
        Flyweight fw2 = FlyweightFactory.getFlyweight("a");
        Flyweight fw3 = FlyweightFactory.getFlyweight("b");
        fw1.operation("abc");
        System.out.printf("[ 后果 ( 对象比照)] - [%s]\n", fw0 == fw2);
        System.out.printf("[ 后果 ( 外在状态)] - [%s]\n", fw1.getType());
    }
}

输入后果：

[类型 ( 外在状态)] - [b] - [名字 ( 外在状态)] - [abc]
[后果 ( 对象比照)] - [true]
[后果 ( 外在状态)] - [b]

察看以上代码运行后果，咱们能够发现：如果对象曾经存在于享元池中，则不会再创立该对象了，而是共用享元池中外部数据统一的对象。这样就缩小了对象的创立，同时也节俭了同样外部数据的对象所占用的内存空间。

实用场景

享元模式在理论开发中的利用也十分宽泛。例如 Java 的 String 字符串，在一些字符串常量中，会共享常量池中字符串对象，从而缩小反复创立雷同值对象，占用内存空间。代码如下：

 String s1 = "hello";
 String s2 = "hello";
 System.out.println(s1==s2);//true

还有，在日常开发中的利用。例如，池化技术中的线程池就是享元模式的一种实现；将商品存储在应用服务的缓存中，那么每当用户获取商品信息时，则不须要每次都从 redis 缓存或者数据库中获取商品信息，并在内存中反复创立商品信息了。

总结

原型模式和享元模式，在开源框架，和理论开发中，利用都非常宽泛。

在不得已须要反复创立大量同一对象时，咱们能够应用原型模式，通过 clone 办法复制对象，这种形式比用 new 和序列化创建对象的效率要高；在创建对象时，如果咱们能够共用对象的外部数据，那么通过享元模式共享雷同的外部数据的对象，就能够缩小对象的创立，实现零碎调优。

本文由 mdnice 多平台公布

正文完
后端
发表至： 后端
2023-05-27
 0
关于后端:MySQL-数据库索引技术原理初探
关于后端:基于-eBPF-的-Kubernetes-可观测实践
关于后端:图论算法遍历基础
关于后端:文化你所在的团队有多少人敢讲真话