设计模式--创建型模式

最新推荐文章于 2024-04-26 14:53:11 发布

巴黎↓一整天氵

最新推荐文章于 2024-04-26 14:53:11 发布

阅读量359

点赞数

分类专栏：设计模式文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/weixin_41943050/article/details/129814951

版权

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

软件设计原则

在这里插入图片描述

1.工厂模式（Factory）

1.1 简单工厂模式

关键字new

public class CourseFactory {
    public ICourse create(String name){
        if("java".equals(name)){
            return new JavaCourse();
        }else if("python".equals(name)){
            return new PythonCourse();
        }else {
            return null;
        }
    }
}

反射 - 按类名全路径反射

public class CourseFactory {
   public ICourse create(String className){
		try {
            if (!(null == className || "".equals(className))) {
               return (ICourse) Class.forName(className).newInstance();
           }
        }catch (Exception e){
           e.printStackTrace();
        }
        return null;
    }
}

反射 - class

public class CourseFactory {
	public ICourse create(Class<? extends ICourse> clazz){
		try {
			if (null != clazz) {
				return clazz.newInstance();
			}
		} catch (Exception e) {
		    e.printStackTrace();
		}
		 return null;
	}
}

1.2工厂方法模式

在这里插入图片描述

/*定义一个接口*/
public interface ICourseFactory {
    ICourse create();
}
 
/*实现类*/
public class JavaCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new JavaCourse();
    }
}

/*实现类*/
public class PythonCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new PythonCourse();
    }
}

1.3 抽象工厂模式

在这里插入图片描述
产品族：Java、Python ……不同语言
产品等级结构：笔记、视频（每个语言都有对应的笔记、视频等共性的东西）
思路：先创建笔记、视频接口，不同语言的笔记、视频交由子类具体实现，最后将各个语言的笔记、视频整合，交由工厂统一实现。

在这里插入图片描述

public interface INote {
    void edit();
}

public class JavaNote implements INote {
    public void edit() {
        System.out.println("编写Java笔记");
    }
}

public class PythonNote implements INote {
    public void edit() {
        System.out.println("编写Python笔记");
    }
}

public interface IVideo {
    void record();
}

public class JavaVideo implements IVideo {
    public void record() {
        System.out.println("录制Java视频");
    }
}

public class PythonVideo implements IVideo {
    public void record() {
        System.out.println("录制Python视频");
    }
}

public interface CourseFactory {
    INote createNote();
    IVideo createVideo();
}

public class JavaCourseFactory implements CourseFactory {
    public INote createNote() {
        return new JavaNote();
    }
    public IVideo createVideo() {
        return new JavaVideo();
    }
}

public class PythonCourseFactory implements CourseFactory {
    public INote createNote() {
        return new PythonNote();
    }
    public IVideo createVideo() {
        return new PythonVideo();
    }
}

2.单例模式（Singleton）

确保一个类有且仅有一个实例，并全局调用。
应用场景：ServletContext、ServletContextConfig、ApplicationContext、数据库连接池

2.1 饿汉式单例

类加载时，创建单例对象

优点：
线程安全，没有任何形式的锁，执行效率高。
缺点：
类加载时就初始化，不管用不用都占用内存空间。
应用：
Spring IOC容器中ApplicationContext就是典型的饿汉式单例。

public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton(){}	// private：防止外部new获取对象实例

    public static HungrySingleton getInstance(){
        return  hungrySingleton;
    }
}

public class HungryStaticSingleton {
    
    private static final HungryStaticSingleton hungrySingleton;

    static {		//静态代码块
        hungrySingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton(){}		// private：防止外部new获取对象实例

    public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
    }
}

2.2 懒汉式单例

外部类调用时内部类才会加载

volatile + synchronized双重检查锁

public class LazyDoubleCheckSingleton {

    private volatile static LazyDoubleCheckSingleton lazy = null;	// volatile

    private LazyDoubleCheckSingleton(){}

    public static LazyDoubleCheckSingleton getInstance(){
        if(lazy == null){
            synchronized (LazyDoubleCheckSingleton.class){
                if(lazy == null){
                    lazy = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazy;
    }
}

第一个if(lazy == null)，只有在一开始lazy尚未初始化时要抢锁，lazy初始化之后，就不存在抢锁的情况，性能得以保证。
第二个if(lazy == null)，在一开始lazy尚未初始化时，会有大量线程进入第一个if(lazy == null)，并等待锁，为了保证只有第一个抢到锁的线程才能初始化lazy，所以其他线程抢到锁之后还要再判断一次。

为什么要使用volatile？

new LazyDoubleCheckSingleton()的过程包含内存分配并初始化零值、设置对象头、init方法初始化（详见JVM文档），内存分配并初始化零值时就可以将分配的内存地址赋值给lazy，然而对象可能还没有初始化，若此时另外一个线程进来，调用getInstance方法，可能获取的状态就是错的。问题的根本在于将分配的内存地址赋值给lazy和对象初始化的重排序导致，所以要依赖volatile，防止指令重排序。

静态内部类

内部类在被调用之前初始化，避免了线程安全的问题，也解决了饿汉式内存浪费的问题。

public class LazyInnerClassSingleton {
   
    private LazyInnerClassSingleton(){}

    // static 是为了使单例的空间共享
    // final保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        return LazyHolder.LAZY;
    }


    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();                                             
    }
}

2.3 反射破坏单例

构造方法private，虽然可以防止new，但如果通过反射调用构造方法，再getInstance()，还是会产生两个不同实例。在构造方法中判断，抛异常。

public class LazyInnerClassSingleton {
   
private LazyInnerClassSingleton(){
        if(LazyHolder.LAZY != null){		// 防止反射破坏单例            
	   		throw new RuntimeException("不允许创建多个实例");
        }
    }

    // static 是为了使单例的空间共享，final保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        return LazyHolder.LAZY;
    }

    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();                                             
    }
}

2.4 序列化破坏单例

当对象序列化到磁盘，下次用时再反序列时，会因为内存的重新分配而产生一个新的对象。
实现Serializable 接口，重写readResolve()。

public class SeriableSingleton implements Serializable {

    public final static SeriableSingleton INSTANCE = new SeriableSingleton();
    
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }

    private  Object readResolve(){
        return  INSTANCE;
    }
}

在ObjectInputStream类的readResolve()中，如果readResolve()重写了，则调用readResolve()。

缺陷：
其实通过源码了解到，对象实例化了两次，只不过新创建的对象没有被调用而已，所以如果需要大量的创建对象，内存开销必然很大。

2.5 枚举式单例

通过枚举的唯一标识获取实例，枚举类的源码中针对反射、序列化破坏已经做了如上处理。

public enum EnumSingleton {
    INSTANCE;
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

枚举类单例如何避免反射破坏？
反射的源码中，有针对类的类型判断，如果是枚举类，则抛异常。
枚举类单例如何避免序列化破坏？
序列化的 readObject()方法中，针对枚举类的读方法中，是基于注册式单例（类+name）保证了唯一。

2.6 容器缓存式单例

通过反射获取类对象，适用于很多实例需要创建的情况。
非线程安全。

public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> ioc = 
				new ConcurrentHashMap<String,Object>();                                          
    public static Object getInstance(String className){
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

2.7 ThreadLocal线程单例

ThreadLocal创建的对象不是全局唯一的。但能保证单个线程内唯一，线程安全。

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
	    new ThreadLocal<ThreadLocalSingleton>(){
	        @Override
	        protected ThreadLocalSingleton initialValue() {
	            return new ThreadLocalSingleton();
	        }
		};

    private ThreadLocalSingleton(){}

    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}

3.原型模式（Prototype）

拷贝对象

常用于：
1.类初始化消耗资源较多。Clone相比new的好处就在于避免了对象的初始化。
2.New 一个对象的过程非常繁琐（考虑数据、权限等）。
3.构造函数复杂
4.循环体中生产大量对象。

3.1 浅克隆

对象中引用类型clone的是地址引用，也就是说所有对象共用一个引用类型。

public interface Prototype{
    Prototype clone();
}

public class ConcretePrototypeA implements Prototype {
    private int age;
    private String name;
    private List hobbies;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List getHobbies() {
        return hobbies;
    }
    public void setHobbies(List hobbies) {
        this.hobbies = hobbies;
    }

    @Override
    public ConcretePrototypeA clone() {
        ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
        concretePrototype.setAge(this.age);
        concretePrototype.setName(this.name);
        concretePrototype.setHobbies(this.hobbies);
        return concretePrototype;
    }
}

public class Client {
    private Prototype prototype;

    public Client(Prototype prototype){
        this.prototype = prototype;
    }
    public Prototype startClone(Prototype concretePrototype){
        return (Prototype)concretePrototype.clone();
    }
}

public class PrototypeTest {
    public static void main(String[] args) {
        // 创建一个具体的需要克隆的对象
        ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
        // 填充属性，方便测试
        concretePrototype.setAge(18);
        concretePrototype.setName("prototype");
        List hobbies = new ArrayList<String>();
        concretePrototype.setHobbies(hobbies);
        System.out.println(concretePrototype);

        // 创建Client对象，准备开始克隆
        Client client = new Client(concretePrototype);
        ConcretePrototypeA concretePrototypeClone =
		       (ConcretePrototypeA) client.startClone(concretePrototype);
        System.out.println(concretePrototypeClone);

        System.out.println("克隆对象中的引用类型地址值：" + 			 					concretePrototypeClone.getHobbies());                                  
        System.out.println("原对象中的引用类型地址值：" +       				
					concretePrototype.getHobbies());                                          
        System.out.println("对象地址比较："+
	(concretePrototypeClone.getHobbies() == concretePrototype.getHobbies()));
    }
}

3.2 深克隆

通过序列化，重写引用类型。
继承Cloneable接口，重写clone()。
继承Serializable 接口，序列化。

public class QiTianDaSheng implements Cloneable,Serializable {

    public JinGuBang jinGuBang;

    public  QiTianDaSheng(){
        this.jinGuBang = new JinGuBang();
    }

    @Override
    protected Object clone() {
            return this.deepClone();
    }
    
    public Object deepClone(){
        try{
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = 
			new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

3.3 源码

scope=’prototype’   // 作用域
JSON.parseObject()

4.构造者模式（Builder）

将一个复杂对象的构建与它的表示分离，同样的构建过程可以创建不同的表示。用户只需要指定建造类型，无需了解建造的过程和细节。
适用于：
1、对象的构建需要很多步骤且顺序不固定
2、对象的构建结构非常复杂
3、将复杂对象的创建和使用分离

public class File {
   private String name;
   private String type;
   private String url;
   private String lastMotifile;

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

   public void setType(String type) {
      this.type = type;
   }

   public void setUrl(String url) {
      this.url = url;
   }

   public void setLastMotifile(String lastMotifile) {
      this.lastMotifile = lastMotifile;
   }

   @Override
   public String toString() {
      return "File{" +
            "name='" + name + '\'' +
            ", type='" + type + '\'' +
            ", url='" + url + '\'' +
            ", lastMotifile='" + lastMotifile + '\'' +
            '}';
   }
   
}

public static class FileBuilder{
   private File file = new File();

   public FileBuilder setName(String name) {
      file.setName(name);
      return this;
   }

   public FileBuilder setType(String type) {
      file.setType(type);
      return this;
   }

   public FileBuilder setUrl(String url) {
      file.setUrl(url);
      return this;
   }

   public FileBuilder setLastMotifile(String lastMotifile) {
      file.setLastMotifile(lastMotifile);
      return this;
   }

   public File build(){
      return file;
   }
}

public class Client {
   public static void main(String[] args) {
     File file = new File.FileBuilder()
             .setLastMotifile("last")
             .setName("fileName")
             .setType("doc")
             .setUrl("http://")
             .build();
     System.out.println(file);
   }
}