设计模式-创建型

设计模式类型

1、创建型设计模式：主要解决对象的创建问题，封装复杂的创建过程，解耦对象的创建和使用。
2、创建型包括：单例模式、简单工厂模式、抽象工厂模式、原型模式、构造者模式。

原理与实现

单例模式

1、原理

实现单例模式的关键在于限制类的实例化次数

2、实现
单例模式可以通过私有构造函数和静态方法等方式来实现

2.1 饿汉模式
该实现方式的优点是简单、线程安全，不存在线程安全问题和性能问题。但是，该实现方式的缺点是不能延迟加载，即使在不需要使用 Singleton 实例的情况下也会被创建，这会浪费一定的系统资源。

//饿汉模式
public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

2.2 饱汉模式
该示例中的 Singleton 类是懒汉式单例模式的经典实现方式。该实现方式的缺点是在多线程环境下会存在线程安全问题，可以通过使用 synchronized 关键字或者其他方式来解决。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在 Spring Framework 中，ApplicationContext 的实现采用了单例模式来管理和缓存 bean 实例。其核心代码在 org.springframework.context.support.AbstractApplicationContext 类中。

工厂模式

1、原理

用来创建不同但类型相关的对象，由不同的参数决定创建的对象实例。将对象的创建和使用分离，由工厂负责创建对象并返回，创建即抽象

2、不同
将工厂模式和其他创建型模式进行比较。工厂模式和抽象工厂模式、建造者模式、原型模式等创建型模式都有相似之处，但是它们的关注点不同。例如，抽象工厂模式关注创建一组相关的对象，而工厂模式关注创建单个对象。（抽象对象-具体对象，抽象工厂-具体工厂）

3、实现

//抽象对象
public interface IRuleConfigParser {
    void parser();
}
//具体对象
public class JsonRuleConfigParser implements IRuleConfigParser {
    @Override
    public void parser() {
        System.out.println("JsonRuleConfigParser");
    }
}
//具体对象
public class XmlRuleConfigParser implements IRuleConfigParser {
    @Override
    public void parser() {
        System.out.println("XmlRuleConfigParser");
    }
}

//简单工厂simpleFactory
public static IRuleConfigParser createParser(String configFormat) {
        IRuleConfigParser parser = null;
        if ("json".equalsIgnoreCase(configFormat)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equalsIgnoreCase(configFormat)) {
            // parser = new XmlRuleConfigParser();
        } else if ("yaml".equalsIgnoreCase(configFormat)) {
            //parser = new YamlRuleConfigParser();
        } else if ("properties".equalsIgnoreCase(configFormat)) {
            //parser = new PropertiesRuleConfigParser();
        }
        return parser;
    }

//抽象工厂
public interface IGUIFactory {
    Button createbutton();
    TextField createTextField();
}
//具体工厂
public class WindowsFactory implements IGUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }
    public TextField createTextField() {
        return new WindowsTextField();
    }
}
//具体工厂
public class MacFactory implements IGUIFactory {
    public Button createButton() {
        return new MacButton();
    }
    public TextField createTextField() {
        return new MacTextField();
    }
}

//抽象工厂模式
public static void main(String[] args) {
        GUIFactory factory = new WindowsFactory();
        Button button = factory.createButton();
        TextField textField = factory.createTextField();
        // use button, textField

        factory = new MacFactory();
        button = factory.createButton();
        textField = factory.createTextField();
        window = factory.createWindow();
        // use button, textField
    }

4、Spring Framework 中使用了工厂模式的地方比较多，下面列举几个主要的应用：

4.1 BeanFactory 和 ApplicationContext 接口是 Spring 中最常用的工厂模式的实现。这些接口的实现类负责创建和管理 Spring 容器中的 bean 实例，并在需要时将其提供给其他组件使用。

4.2 Spring AOP 中的切面（Aspect）和增强（Advice）也是通过工厂模式创建的。Spring 使用 AspectJ 和动态代理等技术来实现 AOP，通过配置文件或注解等方式来声明切面和增强，Spring 根据声明的信息创建相应的对象。

4.3 Spring MVC 中的处理器映射器（HandlerMapping）也是通过工厂模式实现的。处理器映射器负责将请求映射到相应的处理器上，Spring 中提供了多种处理器映射器，包括注解处理器映射器、路径匹配处理器映射器等，通过工厂模式来创建对应的处理器映射器对象。

4.4 Spring Security 中的认证管理器（AuthenticationManager）也是通过工厂模式创建的。Spring Security 提供了多种认证管理器的实现，包括基于内存、数据库、LDAP 等方式，通过工厂模式来创建相应的认证管理器对象。

综上所述，Spring Framework 中使用了工厂模式的地方比较多，这也体现了工厂模式在软件设计中的重要性和灵活性。

原型模式

1、原理

创建较大的对象，或者对已有对象进行复制，以节省创建时间。原型模式关注如何复制对象，复制即创建。

2、不同
将原型模式和其他创建型模式进行比较。原型模式和工厂模式、抽象工厂模式、建造者模式等创建型模式都有相似之处，但是它们的关注点不同。例如，工厂模式关注如何创建对象，而原型模式关注如何复制对象。

3、实现

public class Prototype implements Cloneable {
    private String name;

    public Prototype(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

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


    @Override
    public Prototype clone() {
        try {
            Prototype clone = (Prototype) super.clone();
            clone.setName("sss");
            // TODO: 复制此处的可变状态，这样此克隆就不能更改初始克隆的内部项
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            ois.readObject();
            return clone;
        } catch (CloneNotSupportedException | IOException | ClassNotFoundException e) {
            throw new AssertionError();
        }
    }
}

public class PrototypeDemo {
    public static void main(String[] args) {
        Prototype prototype = new Prototype("fly");
        Prototype clone = prototype.clone();
        System.out.println(prototype.getName());
        System.out.println(clone.getName());
        clone.setName("xxx");
        System.out.println(clone.getName());
    }
}

3、应用场景

原型模式的核心就是对象的克隆，如Spring Framework 中的使用场景有

3.1 Bean 的作用域
Spring Framework 中的 Bean 可以有多种作用域，包括单例（Singleton）、原型（Prototype）、会话（Session）、请求（Request）等。其中，原型作用域就是使用原型模式实现的。当 Bean 的作用域为原型时，每次获取 Bean 时都会创建一个新的实例，避免了多个对象之间共享状态的问题。

3.2 Web 请求参数绑定
Spring Framework 中的 Web MVC 模块提供了请求参数绑定的功能。在处理请求时，Spring Framework 会根据请求参数自动创建一个实体对象，并将请求参数绑定到该对象的属性上。如果该实体对象是原型作用域的 Bean，那么每次请求都会创建一个新的实例，从而避免了多个请求之间共享状态的问题。

构造者模式

1、原理

用来创建复杂的对象，通过不通过的可选参数，创建不同的对象

2、实现

public class User {
    private final String firstName;
    private final String lastName;
    private final int age;
    private final String address;
    private final String phoneNumber;

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.address = builder.address;
        this.phoneNumber = builder.phoneNumber;
    }

    // Getters and setters

    public static class UserBuilder {
        private String firstName;
        private String lastName;
        private int age;
        private String address;
        private String phoneNumber;

        public UserBuilder setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public UserBuilder setLastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

        public UserBuilder setAge(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder setAddress(String address) {
            this.address = address;
            return this;
        }

        public UserBuilder setPhoneNumber(String phoneNumber) {
            this.phoneNumber = phoneNumber;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}