设计模式类型
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、应用场景
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);
}
}
}
