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

1. 简单工厂模式

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

示例代码：

// 1. 创建接口和具体实现类
public interface Animal {void speak();
}public class Dog implements Animal {@Overridepublic void speak() {System.out.println("Woof!");}
}public class Cat implements Animal {@Overridepublic 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 {@Overridepublic void doSomething() {System.out.println("ConcreteProductA is doing something.");}
}// 3. 工厂方法
public abstract class Creator {public abstract Product factoryMethod();
}public class ConcreteCreatorA extends Creator {@Overridepublic 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 {@Overridepublic void serve() {System.out.println("Service is serving...");}
}public class ProxyHandler implements InvocationHandler {private final Object target;public ProxyHandler(Object target) {this.target = target;}@Overridepublic 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 {@Overridepublic String make() {return "Simple Coffee";}
}public class MilkDecorator implements Coffee {private final Coffee coffee;public MilkDecorator(Coffee coffee) {this.coffee = coffee;}@Overridepublic String make() {return coffee.make() + " + Milk";}
}public class SugarDecorator implements Coffee {private final Coffee coffee;public SugarDecorator(Coffee coffee) {this.coffee = coffee;}@Overridepublic 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 Coffeecoffee = new MilkDecorator(coffee);System.out.println(coffee.make()); // 输出: Simple Coffee + Milkcoffee = 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;}@Overridepublic 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 {@Overridepublic void execute() {System.out.println("Executing Strategy A");}
}class ConcreteStrategyB implements Strategy {@Overridepublic 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 AContext 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 {@Overrideprotected void step1() {System.out.println("Step 1");}@Overrideprotected 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 提供了高度的灵活性和可扩展性，帮助开发者实现松耦合和高内聚的代码结构。