设计模式的简单理解

简单工厂模式：

spring中的BeanFactory，

根据传入一个唯一的标识来获得bean对象但是在传入参数前创建还是传入参数后创建，需要根据业务决定

// Simple Factory
// 简单工厂模式
public class BeanFactory {
    // 根据 beanName 创建并返回 bean 的逻辑
    public static Object getBean(String beanName) {
        // 逻辑省略，返回一个新的对象
        return new Object();
    }
}

// Client Code
// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用简单工厂获取 bean
        Object myBean = BeanFactory.getBean("myBean");
    }
}

工厂模式：

spring中的FactoryBean 

工厂方法模式定义了一个创建对象的接口，但允许子类改变将被创建的对象的类型。在Spring中，FactoryBean接口由充当创建其他bean的工厂的bean实现，其特点是，spring 在使用 getBean() 调用获得该 bean 时，会自动调 用该 bean 的 getObject() 方法，所以返回的不是 factory 这个 bean，而是这个 bean.getOjbect() 方法的返回值

// Factory Method
// 工厂方法模式
public interface Factory {
    Object create();
}

public class MyFactory implements Factory {
    @Override
    public Object create() {
        // 具体的创建对象的逻辑
        return new Object();
    }
}

// Client Code
// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用工厂方法创建对象
        Factory factory = new MyFactory();
        Object myObject = factory.create();
    }
}

单例模式：

Spring中的  scope = "singleton" 

单例模式确保一个类只有一个实例，并提供对它的全局访问点。在Spring中，使用单例作用域（scope="singleton"）定义bean意味着Spring容器中只有一个bean实例。该bean以bean名称为键存储在映射中,或者是  注册式单例模式，bean 存放于 Map 中。bean name 当做 key，bean 当做 value

// Singleton
// 单例模式
public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        // 懒汉式单例模式，当需要时才创建实例
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// Client Code
// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 获取单例实例
        Singleton singleton = Singleton.getInstance();
    }
}

原型模式：

Spring中的 sope = “prototype”

原型模式通过复制现有对象（称为克隆）创建对象的新实例。在Spring中，使用原型作用域（scope="prototype"）定义的bean意味着每次请求该bean时都会创建一个新实例。对一个实例的修改不会影响其他实例。

// Prototype
// 原型模式
public class Prototype implements Cloneable {
    @Override
    public Prototype clone() throws CloneNotSupportedException {
        return (Prototype) super.clone();
    }
}

// Client Code
// 客户端代码
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 创建原型对象
        Prototype original = new Prototype();
        // 克隆原型对象
        Prototype cloned = original.clone();
    }
}

迭代器模式：

Spring中的ConpositeIterator

迭代器模式提供了一种按顺序访问聚合对象元素的方法，而不暴露其底层表示。在Spring中，CompositeIterator实现了Iterator和Iterable接口，允许对元素集合进行迭代。Iterator接口定义了迭代的方式。可以这么认为，实现了 Iterable 接口，则表示某个对象是可被迭 代的。Iterator 接口相当于是一个迭代器，实现了 Iterator 接口，等于具体定义了这个可被迭代的 对象时如何进行迭代的

// Iterator
// 迭代器模式
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

// Iterable
// 可迭代接口
public interface Iterable<T> {
    Iterator<T> iterator();
}

// Concrete Iterator
// 具体的迭代器实现
public class MyIterator implements Iterator<String> {
    private String[] elements;
    private int position = 0;

    public MyIterator(String[] elements) {
        this.elements = elements;
    }

    @Override
    public boolean hasNext() {
        return position < elements.length;
    }

    @Override
    public String next() {
        return elements[position++];
    }
}

// Client Code
// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建数据集合
        String[] data = {"A", "B", "C"};
        // 创建可迭代对象
        Iterable<String> iterable = () -> new MyIterator(data);

        // 使用迭代器遍历集合
        for (String item : iterable) {
            System.out.println(item);
        }
    }
}

代理模式：

Spring中使用动态代理实现AOP（面向切面编程）

代理模式涉及创建另一个对象作为原对象的代理或占位符，以控制对它的访问。在Spring AOP中，使用动态代理（JDK或CGLib）创建类的代理。这些代理截取方法调用，允许应用横切关注点，如日志记录或安全性。简单来说就是就是使用动态代理实现的，分 JDK 和 CGlib 动态代理。

// Subject
public interface Subject {
    void request();
}

// Real Subject
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject handles the request.");
    }
}

// Proxy
public class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
    }
}

// Client Code
public class Client {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.request();
    }
}

适配器模式：

Spring AOP中的AdvisorAdapter 如“MethodBeforeAdviceAdapter”

适配器模式允许不兼容的接口协同工作。在Spring AOP中，AdvisorAdapter及其实现（例如MethodBeforeAdviceAdapter）充当适配器。它们使得可以应用不同类型的advice到方法上，实现了处理方法调用的灵活性。也可以这样理解，它有三个实现： MethodBeforAdviceAdapter、AfterReturnningAdviceAdapter、ThrowsAdviceAdapter。Spring 会根据不同的 AOP 配置来使用对应的 Advice，与策略模式不同的是，一个方法可以同时拥有多个 Advice。Spring 存在很多以 Adapter 结尾的，大多数都是适配器模式

// Target
public interface Target {
    void request();
}

// Adaptee
public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee's specific request.");
    }
}

// Adapter
public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// Client Code
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);
        adapter.request();
    }
}

观察者模式：

Spring中的事件和监听器（“ApplicationEvent”和“ApplicationListener”）

观察者模式定义了对象之间的一对多依赖关系，确保一个对象状态改变时，所有依赖它的对象都得到通知。在Spring中，事件和监听器遵循这一模式。ApplicationEvent是表示事件的抽象类，而ApplicationListener是希望被特定事件通知的类的接口。

// Observer
public interface Observer {
    void update(String message);
}

// Observable
public interface Observable {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

// Concrete Observer
public class ConcreteObserver implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

// Concrete Observable
public class ConcreteObservable implements Observable {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// Client Code
public class Client {
    public static void main(String[] args) {
        ConcreteObservable observable = new ConcreteObservable();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        observable.addObserver(observer1);
        observable.addObserver(observer2);

        observable.notifyObservers("Hello Observers!");
    }
}