原型模式与享元模式
原型模式和享元模式，前者是在创立多个实例时，对创立过程的性能进行调优；后者是用缩小创立实例的形式，来调优零碎性能。这么看，你会不会感觉两个模式有点互相矛盾呢？
其实不然，它们的应用是分场景的。在有些场景下，咱们须要反复创立多个实例，例如在循环体中赋值一个对象，此时咱们就能够采纳原型模式来优化对象的创立过程；而在有些场景下，咱们则能够防止反复创立多个实例，在内存中共享对象就好了。
明天咱们就来看看这两种模式的实用场景，看看如何应用它们来晋升零碎性能。
原型模式
原型模式是通过给出一个原型对象来指明所创立的对象的类型，而后应用本身实现的克隆接口来复制这个原型对象，该模式就是用这种形式来创立出更多同类型的对象。
应用这种形式创立新的对象的话，就无需再通过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多平台公布
发表回复