原型模式（原始模式）是指：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建更过的同类型对象，即对象.clone()。
我们都知道克隆羊多莉的故事。本模式中使用多莉来做讲解。
每一只羊都有一下几个共同属性：姓名（name）、年龄（age）、颜色（color）:
package com.charon.prototype;
/**
* @className: Sheep
* @description:
* @author: charon
* @create: 2022-03-09 23:10
*/
public class Sheep {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", color='" + color + '\'' +
'}';
}
}
传统的创建对象的模式：
package com.charon.prototype;
/**
* @className: Test
* @description: 传统创建对象
* @author: charon
* @create: 2022-03-09 23:11
*/
public class Test {
public static void main(String[] args) {
Sheep sheep = new Sheep("多莉", 1, "white");
Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
System.out.println(sheep);
System.out.println(sheep1);
System.out.println(sheep2);
System.out.println(sheep3);
System.out.println(sheep4);
System.out.println(sheep5);
}
}
对于传统的创建对象的方式的优缺点如下：
既然上面的方式有缺点，下面我们来看看使用原型模式如何改进。
原型模式有两种表现形式：第一种是简单形式，第二种是登记形式。
在java语言中，所有的javaBean都继承自java.lang.Object类，而Object类中提供了一个clone()的方法，可以将一个javaBean对象复制一份。但是这个javaBean必须实现一个标识接口Cloneable，表明这个javaBean是可以复制的。
简单原型模式的UML类图：
简单原型模式涉及的客户角色、抽象原型角色、具体原型角色三个角色：
抽象原型角色：
package com.charon.prototype.improve;
/**
* @className: Sheep
* @description: 简单原型模式-抽象原型角色
* @author: charon
* @create: 2022-03-11 22:06
*/
public interface Sheep extends Cloneable{
Sheep clone();
}
具体角色：
package com.charon.prototype.improve;
/**
* @className: CloneSheep
* @description: 克隆羊
* @author: charon
* @create: 2022-03-11 22:12
*/
public class CloneSheep implements Sheep{
private String name;
private int age;
private String color;
public CloneSheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", color='" + color + '\'' +
'}';
}
/**
* 实现克隆方法
* @return
*/
@Override
public Sheep clone() {
try {
return (Sheep) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
客户端调用：
package com.charon.prototype.improve;
/**
* @className: Client
* @description:
* @author: charon
* @create: 2022-03-11 22:15
*/
public class Client {
public static void main(String[] args) {
CloneSheep sheep = new CloneSheep("多莉", 1, "white");
Sheep sheep1 = sheep.clone();
Sheep sheep2 = sheep.clone();
Sheep sheep3 = sheep.clone();
Sheep sheep4 = sheep.clone();
Sheep sheep5 = sheep.clone();
System.out.println(sheep);
System.out.println(sheep1);
System.out.println(sheep2);
System.out.println(sheep3);
System.out.println(sheep4);
System.out.println(sheep5);
}
}
打印结果：
Sheep{name='多莉', age='1', color='white'}
Sheep{name='多莉', age='1', color='white'}
Sheep{name='多莉', age='1', color='white'}
Sheep{name='多莉', age='1', color='white'}
Sheep{name='多莉', age='1', color='white'}
Sheep{name='多莉', age='1', color='white'}
如此这般，就算Sheep类多了一个属性，也只需要改动很小的代码，其他的代码都不需要改动。
这种模式的UML类图如下：
如上图所示，本模型有客户端角色、抽象原型角色、具体原型角色、原型管理器角色以下几种角色：
具体原型角色：
package com.charon.prototype.improve;
/**
* @className: CloneSheep1
* @description:
* @author: charon
* @create: 2022-03-12 16:03
*/
public class CloneSheep1 implements Sheep{
private String name;
private int age;
private String color;
public CloneSheep1(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", color='" + color + '\'' +
'}';
}
/**
* 实现克隆方法
* @return
*/
@Override
public synchronized Sheep clone() {
try {
return (Sheep) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
原型管理器角色：作为对所有原型对象的等级，这个角色提供必要的方法，供外界增加新的原型对象和取得已经登记过的原型对象。
package com.charon.prototype.improve;
import java.util.Vector;
/**
* @className: PrototypeManager
* @description:
* @author: charon
* @create: 2022-03-12 15:43
*/
public class PrototypeManager {
private Vector objects = new Vector();
/**
* 聚集管理方法：增加一个新的对象
* @param sheep
*/
public void add(CloneSheep1 sheep){
objects.add(sheep);
}
/**
* 取出聚集中的一个对象
* @param i
* @return
*/
public CloneSheep1 get(int i){
return (CloneSheep1) objects.get(i);
}
/**
* 获取大小
* @return
*/
public int getSize(){
return objects.size();
}
}
客户端调用：
package com.charon.prototype.improve;
/**
* @className: Client1
* @description:
* @author: charon
* @create: 2022-03-12 16:10
*/
public class Client1 {
private static PrototypeManager mgr = new PrototypeManager();
private static CloneSheep1 sheep;
private static void registerSheep(){
sheep = new CloneSheep1("多莉", 1, "white");
CloneSheep1 sheep1 = (CloneSheep1) sheep.clone();
mgr.add(sheep1);
}
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
Client1.registerSheep();
}
for (int i = 0; i < Client1.mgr.getSize(); i++) {
System.out.println(Client1.mgr.get(i));
}
}
}
如果需要创建的原型对象数目比较少而且比较固定的话，可以采用第一种简单形式的原型模式，在这种情况下，原型对象的引用可以有客户端自己保存。
如果需要创建的原型对象数目不固定的话，可以采用第二种登记原型模式。在这种情况下，客户端并不保存对原型对象的引用，这个任务被交给管理员对象。在复制一个原型对象之前，客户端可以查看管理员对象是否已经有一个满足要求的原型对象，如果有，客户直接从管理员类取得这个对象的引用，如果没有，客户端就需要自行复制此原型对象。
讲到克隆，就离不开深拷贝和浅拷贝。
浅拷贝：
深拷贝：
package com.charon.prototype.improve;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @className: DeepCloneByClone
* @description: 通过重写clone方法实现深复制
* @author: charon
* @create: 2022-03-12 20:28
*/
public class DeepCloneByClone implements Cloneable{
private String name;
private Sheep sheep;
public DeepCloneByClone(String name, Sheep sheep) {
this.name = name;
this.sheep = sheep;
}
@Override
public String toString() {
return "DeepCloneByClone{" +
"name='" + name + '\'' +
", sheep=" + sheep +
" '},sheep.hashCode =" + sheep.hashCode() ;
}
/**
* 实现克隆方法
* @return
*/
@Override
public DeepCloneByClone clone() {
try {
return (DeepCloneByClone) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
/**
* 实现clone方法的深复制
* @return
*/
public DeepCloneByClone deepClone(){
try {
Object deep = null;
// 对基本数据类型和string类型的克隆
deep = super.clone();
// 对引用类型的属性，进行单独处理
DeepCloneByClone deepClone = (DeepCloneByClone) deep;
deepClone.sheep = sheep.clone();
return deepClone;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
把对象写道琉璃的过程是序列化的过程，而把对象从流中读出来的叫做反序列化。这种方式需要实现Serializable接口。
package com.charon.prototype.improve;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @className: DeepCloneByClone
* @description: 通过序列化方法实现深复制
* @author: charon
* @create: 2022-03-12 20:28
*/
public class DeepCloneByClone implements Serializable,Cloneable{
private String name;
private Sheep sheep;
public DeepCloneByClone(String name, Sheep sheep) {
this.name = name;
this.sheep = sheep;
}
@Override
public String toString() {
return "DeepCloneByClone{" +
"name='" + name + '\'' +
", sheep=" + sheep +
" '},sheep.hashCode =" + sheep.hashCode() ;
}
/**
* 实现克隆方法，浅克隆
* @return
*/
@Override
public DeepCloneByClone clone() {
try {
return (DeepCloneByClone) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
/**
* 使用序列化的方式实现深复制
* @return
*/
public DeepCloneByClone deepClone(){
// 创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
// 序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
// 以对象流的方式输出
oos.writeObject(this);
// 反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepCloneByClone deep = (DeepCloneByClone) ois.readObject();
return deep;
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
return null;
} finally {
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(oos != null){
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？ 最佳答案 通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
鉴于我有以下迁移:Sequel.migrationdoupdoalter_table:usersdoadd_column:is_admin,:default=>falseend#SequelrunsaDESCRIBEtablestatement,whenthemodelisloaded.#Atthispoint,itdoesnotknowthatusershaveais_adminflag.#Soitfails.@user=User.find(:email=>"admin@fancy-startup.example")@user.is_admin=true@user.save!ende
我将应用程序升级到Rails4，一切正常。我可以登录并转到我的编辑页面。也更新了观点。使用标准View时，用户会更新。但是当我添加例如字段:name时，它不会在表单中更新。使用devise3.1.1和gem'protected_attributes'我需要在设备或数据库上运行某种更新命令吗？我也搜索过这个地方，找到了许多不同的解决方案，但没有一个会更新我的用户字段。我没有添加任何自定义字段。 最佳答案 如果您想允许额外的参数，您可以在ApplicationController中使用beforefilter，因为Rails4将参数
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。 最佳答案 我最
目录前言滤波电路科普主要分类实际情况单位的概念常用评价参数函数型滤波器简单分析滤波电路构成低通滤波器RC低通滤波器RL低通滤波器高通滤波器RC高通滤波器RL高通滤波器部分摘自《LC滤波器设计与制作》，侵权删。前言最近需要学习放大电路和滤波电路，但是由于只在之前做音乐频谱分析仪的时候简单了解过一点点运放，所以也是相当从零开始学习了。滤波电路科普主要分类滤波器：主要是从不同频率的成分中提取出特定频率的信号。有源滤波器：由RC元件与运算放大器组成的滤波器。可滤除某一次或多次谐波，最普通易于采用的无源滤波器结构是将电感与电容串联，可对主要次谐波（3、5、7）构成低阻抗旁路。无源滤波器：无源滤波器，又称
项目介绍随着我国经济迅速发展,人们对手机的需求越来越大,各种手机软件也都在被广泛应用,但是对于手机进行数据信息管理,对于手机的各种软件也是备受用户的喜爱小学生兴趣延时班预约小程序的设计与开发被用户普遍使用,为方便用户能够可以随时进行小学生兴趣延时班预约小程序的设计与开发的数据信息管理,特开发了小程序的设计与开发的管理系统。小学生兴趣延时班预约小程序的设计与开发的开发利用现有的成熟技术参考,以源代码为模板,分析功能调整与小学生兴趣延时班预约小程序的设计与开发的实际需求相结合,讨论了小学生兴趣延时班预约小程序的设计与开发的使用。开发环境开发说明：前端使用微信微信小程序开发工具：后端使用ssm：VU
了解Rails缓存如何工作的人可以真正帮助我。这是嵌套在Rails::Initializer.runblock中的代码:config.after_initializedoSomeClass.const_set'SOME_CONST','SOME_VAL'end现在，如果我运行script/server并发出请求，一切都很好。然而，在我的Rails应用程序的第二个请求中，一切都因单元化常量错误而变得糟糕。在生产模式下，我可以成功发出第二个请求，这意味着常量仍然存在。我已通过将以上内容更改为以下内容来解决问题:config.after_initializedorequire'some_cl
我在我的项目中有一个用户和一个管理员角色。我使用Devise创建了身份验证。在我的管理员角色中，我没有任何确认。在我的用户模型中，我有以下内容:devise:database_authenticatable,:confirmable,:recoverable,:rememberable,:trackable,:validatable,:timeoutable,:registerable#Setupaccessible(orprotected)attributesforyourmodelattr_accessible:email,:username,:prename,:surname,:
我经常迷上ruby的一件事是递归模式。例如，假设我有一个数组，它可能包含无限深度的数组作为元素。所以，例如:my_array=[1,[2,3,[4,5,[6,7]]]]我想创建一个方法，可以将数组展平为[1,2,3,4,5,6,7]。我知道.flatten可以完成这项工作，但这个问题是作为我经常遇到的递归问题的一个例子-因此我试图找到一个更可重用的解决方案。简而言之-我猜这种事情有一个标准模式，但我想不出任何特别优雅的东西。任何想法表示赞赏 最佳答案 递归是一种方法，它不依赖于语言。您在编写算法时要考虑两种情况:再次调用函数的情