好的！以下是您提到的八种设计模式在 Spring 中的简单示例：

1. 简单工厂模式

简单工厂模式通过传入参数来决定实例化哪个类。Spring 中的 BeanFactory 就是简单工厂模式的应用。

示例代码：

// 1. 创建接口和具体实现类
public interface Animal {
    void speak();
}

public class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

public class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

// 2. 工厂类，传入参数决定实例化哪个类
public class AnimalFactory {
    public static Animal getAnimal(String animalType) {
        if ("dog".equalsIgnoreCase(animalType)) {
            return new Dog();
        } else if ("cat".equalsIgnoreCase(animalType)) {
            return new Cat();
        }
        return null;
    }
}

// 3. 使用工厂类创建实例
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Animal dog = AnimalFactory.getAnimal("dog");
        dog.speak(); // 输出: Woof!

        Animal cat = AnimalFactory.getAnimal("cat");
        cat.speak(); // 输出: Meow!
    }
}

2. 工厂方法模式

工厂方法模式定义一个方法用于创建对象，由子类决定实例化哪一个类。Spring 使用 FactoryBean 来实现这个模式。

示例代码：

// 1. 定义接口
public interface Product {
    void doSomething();
}

// 2. 具体实现
public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA is doing something.");
    }
}

// 3. 工厂方法
public abstract class Creator {
    public abstract Product factoryMethod();
}

public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 4. 使用工厂方法
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreatorA();
        Product product = creator.factoryMethod();
        product.doSomething(); // 输出: ConcreteProductA is doing something.
    }
}

3. 单例模式

Spring 中的 Singleton 模式使用了双重检查锁定的方式来确保只有一个实例。

示例代码：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

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

public class SingletonDemo {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

4. 代理模式

Spring AOP 是通过代理模式来增强对象的功能。Spring 提供了 JDK 动态代理和 CGLIB 代理。

示例代码（使用 JDK 动态代理）：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public interface Service {
    void serve();
}

public class ServiceImpl implements Service {
    @Override
    public void serve() {
        System.out.println("Service is serving...");
    }
}

public class ProxyHandler implements InvocationHandler {
    private final Object target;

    public ProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call...");
        Object result = method.invoke(target, args);
        System.out.println("After method call...");
        return result;
    }
}

public class ProxyPatternDemo {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        Service proxy = (Service) Proxy.newProxyInstance(
                Service.class.getClassLoader(),
                new Class[]{Service.class},
                new ProxyHandler(service));

        proxy.serve(); // 输出: Before method call... Service is serving... After method call...
    }
}

5. 装饰器模式

装饰器模式动态地给一个对象添加一些额外的功能。Spring 中的 DataSource 装饰模式就是这个例子。

示例代码：

public interface Coffee {
    String make();
}

public class SimpleCoffee implements Coffee {
    @Override
    public String make() {
        return "Simple Coffee";
    }
}

public class MilkDecorator implements Coffee {
    private final Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String make() {
        return coffee.make() + " + Milk";
    }
}

public class SugarDecorator implements Coffee {
    private final Coffee coffee;

    public SugarDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String make() {
        return coffee.make() + " + Sugar";
    }
}

public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.make()); // 输出: Simple Coffee

        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.make()); // 输出: Simple Coffee + Milk

        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.make()); // 输出: Simple Coffee + Milk + Sugar
    }
}

6. 观察者模式

观察者模式用于一对多的依赖关系，Spring 中的事件监听器使用了这个模式。

示例代码：

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

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);
    }
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

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

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

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

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.notifyObservers("Hello Observers!"); // 输出: Observer 1 received message: Hello Observers!
                                                   // 输出: Observer 2 received message: Hello Observers!
    }
}

7. 策略模式

策略模式允许在运行时选择算法。Spring 中的 HandlerMapping 使用了策略模式来根据请求映射到不同的处理器。

示例代码：

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing Strategy B");
    }
}

class Context {
    private final Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context contextA = new Context(new ConcreteStrategyA());
        contextA.executeStrategy(); // 输出: Executing Strategy A

        Context contextB = new Context(new ConcreteStrategyB());
        contextB.executeStrategy(); // 输出: Executing Strategy B
    }
}

8. 模板方法模式

模板方法模式定义了一个操作中的步骤，并允许子类在不改变操作结构的情况下实现某些步骤。

示例代码：

abstract class AbstractTemplate {
    public void templateMethod() {
        step1();
        step2();
    }

    protected abstract void step1();
    protected abstract void step2();
}

class ConcreteClass extends AbstractTemplate {
    @Override
    protected void step1() {
        System.out.println("Step 1");
    }

    @Override
    protected void step2() {
        System.out.println("Step 2");
    }
}

public class TemplateMethodPatternDemo {
    public static void main(String[] args) {
        AbstractTemplate template = new ConcreteClass();
        template.templateMethod();
    }
}

---

以上示例演示了 Spring 中常见的 8 种设计模式的应用。通过这些设计模式，Spring 提供了高度的灵活性和可扩展性，帮助开发者实现松耦合和高内聚的代码结构。