设计模式之(六):原型设计模式

发表于   |   分类于 左手代码 java   |   阅读(167)   |   评论(164)

原型模式对应的内容概要

一.定义

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

二.特点

不需要知道任何创建的细节，不调用构造函数

三.使用场景

  • 类初始化消耗较多资源
  • 类产生的一个对象需要非常繁琐的过程
  • 构造函数比较复杂(如属性比较多)
  • 循环体中生产大量相同类的对象时

四、优缺点

1.优点
  • 比直接new一个对象性能高
  • 简化创建过程
2.缺点
  • 必须配备clone方法
    • 实现Cloneable接口
    • 覆盖Object类的clone方法
  • 对克隆复杂对象或克隆出的对象进行复杂改造时，容易引入风险
  • 深拷贝、浅拷贝要运用得当
    • 深拷贝 : 对引用类型的数据类型的属性也进行拷贝，而不是指向同一块内存空间
    • 浅拷贝 : 只拷贝基本数据类型对应的属性

五.实例

1.浅拷贝实例

订单状态改变，发送短信的实例

  • 短信内容实体
  1. /**
  2.  * 短信内容实体（实现Cloneable接口标识它是可克隆的）
  3.  * @author shixinke
  4.  */
  5. public class Sms implements Cloneable {
  6.     /**
  7.      * 短信ID
  8.      */
  9.     private Long id;
  10.     /**
  11.      * 接收者手机号
  12.      */
  13.     private String receiver;
  14.     /**
  15.      * 短信内容
  16.      */
  17.     private String message;
  18.     /**
  19.      * 短信模板
  20.      */
  21.     private String template;
  22.     /**
  23.      * 短信发送时间
  24.      */
  25.     private Integer createTime;
  27.     public Sms() {
  29.     }
  31.     public Sms(Long id, String receiver, String message, String template) {
  32.         this.id = id;
  33.         this.receiver = receiver;
  34.         this.message = message;
  35.         this.template = template;
  36.         this.createTime = Long.valueOf(System.currentTimeMillis() / 1000).intValue();
  37.     }
  39.     public void setId(Long id) {
  40.         this.id = id;
  41.     }
  43.     public void setReceiver(String receiver) {
  44.         this.receiver = receiver;
  45.     }
  47.     public void setMessage(String message) {
  48.         this.message = message;
  49.     }
  51.     public void setTemplate(String template) {
  52.         this.template = template;
  53.     }
  55.     public void setCreateTime(Integer createTime) {
  56.         this.createTime = createTime;
  57.     }
  59.     public Long getId() {
  60.         return id;
  61.     }
  63.     public String getReceiver() {
  64.         return receiver;
  65.     }
  67.     public String getMessage() {
  68.         return message;
  69.     }
  71.     public String getTemplate() {
  72.         return template;
  73.     }
  75.     public Integer getCreateTime() {
  76.         return createTime;
  77.     }
  79.     /*
  80.     * 重写clone方法
  81.     */
  82.     public Object clone() {
  83.         try {
  84.             return super.clone();
  85.         } catch (CloneNotSupportedException e) {
  86.             System.out.println("克隆失败");
  87.             return null;
  88.         }
  89.     }
  91.     @Override
  92.     public String toString() {
  93.         return "Sms{" +
  94.                 "id=" + id +
  95.                 ", receiver='" + receiver + '\'' +
  96.                 ", message='" + message + '\'' +
  97.                 ", template='" + template + '\'' +
  98.                 ", createTime=" + createTime +
  99.                 '}';
  100.     }
  101. }
  • 用户实体
  1. /**
  2.  * 用户实体
  3.  * @author shixinke
  4.  */
  5. public class User {
  6.     /**
  7.      * 用户ID
  8.      */
  9.     private Long userId;
  10.     /**
  11.      * 用户昵称
  12.      */
  13.     private String nickname;
  14.     /**
  15.      * 用户手机号
  16.      */
  17.     private String mobile;
  19.     public User(Long userId, String nickname, String mobile) {
  20.         this.userId = userId;
  21.         this.nickname = nickname;
  22.         this.mobile = mobile;
  23.     }
  25.     public Long getUserId() {
  26.         return userId;
  27.     }
  29.     public String getNickname() {
  30.         return nickname;
  31.     }
  33.     public String getMobile() {
  34.         return mobile;
  35.     }
  36. }
  • 短信服务
  1. import java.util.List;
  3. /**
  4.  * 发送短信服务
  5.  * @author shixinke
  6.  */
  7. public class SmsService {
  9.     /**
  10.      * 批量发送短信
  11.      * @param userList
  12.      * @param sms
  13.      */
  14.     public void send(List<User> userList, Sms sms) {
  15.         for (User user : userList) {
  16.             Sms temp = (Sms)sms.clone();
  17.             if (temp != null) {
  18.                 temp.setReceiver(user.getMobile());
  19.                 temp.setId(sms.getId() + user.getUserId());
  20.                 temp.setMessage(String.format(temp.getTemplate(), user.getNickname()));
  21.                 System.out.println("发送短信:" + temp);
  22.             }
  23.         }
  24.         System.out.println("原始短信对象:" + sms);
  25.     }
  26. }
  • 测试代码
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * 短信测试
  6.  * @author shixinke
  7.  */
  8. public class SmsTest {
  10.     public static void main(String[] args) {
  11.         Sms sms = new Sms(
  12.                 1000L,
  13.                 null,
  14.                 null,
  15.                 "尊敬的%s,您的订单已开始发货，请耐心等候"
  16.         );
  17.         SmsService smsService = new SmsService();
  18.         List<User> userList = new ArrayList<User>(5);
  19.         userList.add(new User(1L, "张三", "158xxxx6666"));
  20.         userList.add(new User(2L, "李四", "159xxxx6666"));
  21.         userList.add(new User(3L, "王五", "150xxxx6666"));
  22.         userList.add(new User(4L, "赵六", "130xxxx6666"));
  23.         userList.add(new User(5L, "周七", "131xxxx6666"));
  24.         smsService.send(userList, sms);
  25.     }
  26. }

运行结果:

  1. 发送短信:Sms{id=1001, receiver='158xxxx6666', message='尊敬的张三,您的订单已开始发货，请耐心等候', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}
  2. 发送短信:Sms{id=1002, receiver='159xxxx6666', message='尊敬的李四,您的订单已开始发货，请耐心等候', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}
  3. 发送短信:Sms{id=1003, receiver='150xxxx6666', message='尊敬的王五,您的订单已开始发货，请耐心等候', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}
  4. 发送短信:Sms{id=1004, receiver='130xxxx6666', message='尊敬的赵六,您的订单已开始发货，请耐心等候', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}
  5. 发送短信:Sms{id=1005, receiver='131xxxx6666', message='尊敬的周七,您的订单已开始发货，请耐心等候', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}
  6. 原始短信对象:Sms{id=1000, receiver='null', message='null', template='尊敬的%s,您的订单已开始发货，请耐心等候', createTime=1570090084}

以上类的UML关系图:

原型模式UML关系图

2.深拷贝实例
(1)浅拷贝
  • 原型对象
  2. /**
  3.  * 用户实体(原型对象)
  4.  * @author shixinke
  5.  */
  6. public class User implements Cloneable {
  7.     /**
  8.      * 用户ID
  9.      */
  10.     private Long userId;
  11.     /**
  12.      * 用户昵称
  13.      */
  14.     private String nickname;
  15.     /**
  16.      * 用户手机号
  17.      */
  18.     private String mobile;
  20.     /**
  21.      * 收货地址
  22.      */
  23.     private Address address;
  26.     public User(Long userId, String nickname, String mobile, Address address) {
  27.         this.userId = userId;
  28.         this.nickname = nickname;
  29.         this.mobile = mobile;
  30.         this.address = address;
  31.     }
  33.     public Long getUserId() {
  34.         return userId;
  35.     }
  37.     public void setUserId(Long userId) {
  38.         this.userId = userId;
  39.     }
  41.     public String getNickname() {
  42.         return nickname;
  43.     }
  45.     public void setNickname(String nickname) {
  46.         this.nickname = nickname;
  47.     }
  49.     public String getMobile() {
  50.         return mobile;
  51.     }
  53.     public void setMobile(String mobile) {
  54.         this.mobile = mobile;
  55.     }
  57.     public Address getAddress() {
  58.         return address;
  59.     }
  61.     public void setAddress(Address address) {
  62.         this.address = address;
  63.     }
  66.     public Object clone() {
  67.         try {
  68.             return super.clone();
  69.         } catch (CloneNotSupportedException e) {
  70.             System.out.println("克隆失败");
  71.             return null;
  72.         }
  73.     }
  74. }

注：address属性不是基本数据类型，在使用clone拷贝的时候是浅拷贝，克隆对象的address和原型对address是指向同一内存地址的

  • 引用类型对象
  1. /**
  2.  * 用户收货地址
  3.  * @author shixinke
  4.  */
  5. public class Address {
  6.     /**
  7.      * 地址ID
  8.      */
  9.     private Long addressId;
  11.     /**
  12.      * 收货详细地址
  13.      */
  14.     private String address;
  16.     public Address(Long addressId, String address) {
  17.         this.addressId = addressId;
  18.         this.address = address;
  19.     }
  21.     public Long getAddressId() {
  22.         return addressId;
  23.     }
  25.     public void setAddressId(Long addressId) {
  26.         this.addressId = addressId;
  27.     }
  29.     public String getAddress() {
  30.         return address;
  31.     }
  33.     public void setAddress(String address) {
  34.         this.address = address;
  35.     }
  36. }
  • 测试代码:
  1. /**
  2.  * 用户类测试
  3.  * @author shixinke
  4.  */
  5. public class UserTest {
  7.     public static void main(String[] args) {
  8.         Address address = new Address(100L, "浙江杭州");
  9.         User user = new User(1L, "赵六", "15878451XXX", address);
  10.         User temp = (User)user.clone();
  12.         /**
  13.          * 两个User对象(user和temp)不是同一个对象
  14.          */
  15.         System.out.println("user:" + user); //User@7adf9f5f
  16.         System.out.println("temp:" + temp); //User@85ede7b
  17.         System.out.println(user == temp); //false
  18.         /**
  19.          * user的address和temp的address是同一个对象
  20.          */
  21.         System.out.println("user.address:" + user.getAddress());//Address@5674cd4d
  22.         System.out.println("temp.address:" + temp.getAddress());//Address@5674cd4d
  24.         System.out.println(user.getAddress() == temp.getAddress()); //true
  25.     }
  26. }
(2)实现深拷贝

对引用类型(非基本类型)的数据类型的对象进行单独的拷贝(clone)

  • Address类实现Cloneable接口，并重写clone方法
  1. /**
  2.  * 用户收货地址
  3.  * @author shixinke
  4.  */
  5. public class Address implements Cloneable {
  6.     /**
  7.      * 地址ID
  8.      */
  9.     private Long addressId;
  11.     /**
  12.      * 收货详细地址
  13.      */
  14.     private String address;
  16.     public Address(Long addressId, String address) {
  17.         this.addressId = addressId;
  18.         this.address = address;
  19.     }
  21.     public Long getAddressId() {
  22.         return addressId;
  23.     }
  25.     public void setAddressId(Long addressId) {
  26.         this.addressId = addressId;
  27.     }
  29.     public String getAddress() {
  30.         return address;
  31.     }
  33.     public void setAddress(String address) {
  34.         this.address = address;
  35.     }
  37.     /**
  38.      * 重写clone方法
  39.      * @return
  40.      */
  41.     public Object clone() {
  42.         try {
  43.             return super.clone();
  44.         } catch (CloneNotSupportedException e) {
  45.             e.printStackTrace();
  46.             return null;
  47.         }
  48.     }
  49. }
  • User的clone方法，除了整体的clone，还要对非基本类型的数据进行克隆，即对address对象克隆
  1. /**
  2.  * 用户实体(原型对象)
  3.  * @author shixinke
  4.  */
  5. public class User implements Cloneable {
  6.     /**
  7.      * 用户ID
  8.      */
  9.     private Long userId;
  10.     /**
  11.      * 用户昵称
  12.      */
  13.     private String nickname;
  14.     /**
  15.      * 用户手机号
  16.      */
  17.     private String mobile;
  19.     /**
  20.      * 收货地址
  21.      */
  22.     private Address address;
  25.     public User(Long userId, String nickname, String mobile, Address address) {
  26.         this.userId = userId;
  27.         this.nickname = nickname;
  28.         this.mobile = mobile;
  29.         this.address = address;
  30.     }
  32.     public Long getUserId() {
  33.         return userId;
  34.     }
  36.     public void setUserId(Long userId) {
  37.         this.userId = userId;
  38.     }
  40.     public String getNickname() {
  41.         return nickname;
  42.     }
  44.     public void setNickname(String nickname) {
  45.         this.nickname = nickname;
  46.     }
  48.     public String getMobile() {
  49.         return mobile;
  50.     }
  52.     public void setMobile(String mobile) {
  53.         this.mobile = mobile;
  54.     }
  56.     public Address getAddress() {
  57.         return address;
  58.     }
  60.     public void setAddress(Address address) {
  61.         this.address = address;
  62.     }
  65.     public Object clone() {
  66.         try {
  67.             User user =  (User)super.clone();
  68.             //单独克隆address属性
  69.             user.address = (Address)this.address.clone();
  70.             return user;
  71.         } catch (CloneNotSupportedException e) {
  72.             System.out.println("克隆失败");
  73.             return null;
  74.         }
  75.     }
  76. }
  • 再次测试
  1. user.address:Address@5674cd4d
  2. temp.address:Address@63961c42

此时两个对象的address属性不再指向同一地址，实现了深拷贝

专题 更多...

分类 更多...

展开

标签 更多...

归档 更多...

展开