Spring框架中的设计模式（自用）

1. 依赖注入模式（Dependency Injection，简称DI）：依赖注入模式是Spring框架的核心机制之一，其目的是将对象的依赖关系外置，通过外部容器来完成对象的创建和依赖注入，从而降低对象间的耦合度，提高代码的可维护性和可测试性。在Spring中，依赖注入有两种方式：基于XML配置和基于注解配置。下面是一个基于XML配置的依赖注入例子：

```xml
<!--定义一个接口-->
public interface MessageService {
    String getMessage();
}

<!--定义一个实现类-->
public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, world!";
    }
}

<!--配置文件中定义Bean-->
<bean id="messageService" class="com.example.MessageServiceImpl"/>

<!--使用依赖注入-->
public class MessagePrinter {
    private MessageService messageService;

    public MessagePrinter(MessageService messageService) {
        this.messageService = messageService;
    }

    public void printMessage() {
        System.out.println(messageService.getMessage());
    }
}

<!--在配置文件中注入依赖-->
<bean id="messagePrinter" class="com.example.MessagePrinter">
    <constructor-arg ref="messageService"/>
</bean>
```

2. 控制反转模式（Inversion of Control，简称IoC）：控制反转是依赖注入模式的一种具体实现，其核心思想是将应用程序中的控制权从应用程序代码中转移到框架中，从而使得框架能够更好地管理应用程序对象的生命周期和依赖关系。在Spring中，IoC容器是实现控制反转的核心，它负责管理Bean的生命周期和依赖关系。下面是一个基于XML配置的IoC例子：

```xml
<!--定义一个接口-->
public interface MessageService {
    String getMessage();
}

<!--定义一个实现类-->
public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, world!";
    }
}

<!--在配置文件中定义Bean-->
<bean id="messageService" class="com.example.MessageServiceImpl"/>

<!--定义另一个Bean-->
<bean id="messagePrinter" class="com.example.MessagePrinter">
    <!--在构造函数中注入依赖-->
    <constructor-arg ref="messageService"/>
</bean>
```

3. AOP模式（Aspect-Oriented Programming）：AOP是一种编程思想，其核心思想是将通用的横切关注点（如日志、事务、安全等）从业务逻辑中分离出来，形成一些横切面（Aspect），从而实现了模块化的编程。在Spring中，AOP模块和AspectJ语言是实现AOP编程的两个核心组件。下面是一个基于注解的AOP例子：

```java
<!--定义一个切面-->
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("before " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("after " + joinPoint.getSignature().getName());
    }
}

<!--定义一个服务类-->
@Service
public class MessageService {
    public String getMessage() {
        return "Hello, world!";
    }
}

<!--在配置文件中启用AOP-->
<aop:aspectj-autoproxy/>
```

4. 工厂模式（Factory Pattern）：工厂模式是一种创建型设计模式，其核心思想是将对象的创建和实现隔离开来，从而实现对象的创建和使用的解耦。在Spring中，BeanFactory和ApplicationContext就是两个典型的工厂模式的实现。下面是一个基于Java配置的工厂模式例子：

```java
<!--定义一个接口-->
public interface MessageService {
    String getMessage();
}

<!--定义一个实现类-->
public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, world!";
    }
}

<!--定义一个工厂类-->
@Configuration
public class AppConfig {
    @Bean
    public MessageService messageService() {
        return new MessageServiceImpl();
    }

    @Bean
    public MessagePrinter messagePrinter() {
        return new MessagePrinter(messageService());
    }
}

<!--使用工厂类创建Bean-->
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MessagePrinter printer = context.getBean(MessagePrinter.class);
        printer.printMessage();
        context.close();
    }
}
```

5. 单例模式（Singleton Pattern）：单例模式是一种创建型设计模式，其核心思想是保证一个类仅有一个实例，并提供一个全局访问点。在Spring中，Bean默认是单例的，即每个Bean定义对应一个单独的实例。这种单例模式的实现可以提高程序的性能和资源利用率。下面是一个基于注解的单例模式例子：

```java
<!--定义一个服务类-->
@Service
public class MessageService {
    public String getMessage() {
        return "Hello, world!";
    }
}

<!--在配置文件中注入单例Bean-->
<bean id="messageService" class="com.example.MessageService" scope="singleton"/>

<!--使用单例Bean-->
public class Application {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MessageService messageService1 = context.getBean(MessageService.class);
        MessageService messageService2 = context.getBean(MessageService.class);
        System.out.println(messageService1 == messageService2); // true
        context.close();
    }
}
```

6. 观察者模式（Observer Pattern）：观察者模式是一种行为型设计模式，其核心思想是定义一种一对多的依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会自动收到通知并更新。在Spring中，事件驱动编程是一种重要的编程思想，它通过观察者模式来实现。下面是一个基于注解的观察者模式例子：

```java
<!--定义一个事件-->
public class MessageEvent extends ApplicationEvent {
    private final String message;

    public MessageEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

<!--定义一个观察者-->
@Component
public class MessageListener implements ApplicationListener<MessageEvent> {
    @Override
    public void onApplicationEvent(MessageEvent event) {
        System.out.println("Received message: " + event.getMessage());
    }
}

<!--发布事件-->
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MessageListener.class);
        context.refresh();
        context.publishEvent(new MessageEvent(context, "Hello, world!"));
        context.close();
    }
}
```

以上是Spring框架中常用的几种设计模式及其例子。当然，Spring框架还使用了其他的设计模式，如代理模式、模板方法模式等，但以上列举的这些模式是Spring框架中最为常用的。