spring源码中使用了哪些设计模式？

1、依赖注入（Dependency Injection, DI）:
        Spring的核心特性之一就是依赖注入，它通过构造函数注入、setter注入或属性注入实现。例如，BeanFactory会根据配置信息将依赖注入到目标bean中。这并不是一种严格意义上的设计模式，但它是Spring框架的基础。

public interface Service {
    void doSomething();
}

@Service
public class MyServiceImpl implements Service {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

@Component
public class MyComponent {
    private Service service;

    @Autowired
    public void setService(Service service) {
        this.service = service;
    }

    public void execute() {
        service.doSomething();
    }
}

2、工厂模式（Factory Pattern）:
        BeanFactory接口及其实现类如DefaultListableBeanFactory，通过getBean()方法创建和管理bean实例，是典型的工厂模式应用。此外，InstantiationAwareBeanPostProcessor接口允许自定义bean实例化逻辑。

public interface BeanFactory {
    <T> T getBean(Class<T> beanType);
}

public class SimpleBeanFactory implements BeanFactory {
    private Map<String, Object> beans = new HashMap<>();

    public <T> T getBean(Class<T> beanType) {
        return (T) beans.get(beanType.getName());
    }

    public void registerBean(String name, Object bean) {
        beans.put(name, bean);
    }
}

3、单例模式（Singleton Pattern）:
        SingletonBeanRegistry类维护着单例bean的注册表，确保每个bean只有一个实例。DefaultSingletonBeanRegistry的getSingleton()方法实现了单例模式。
4、原型模式（Prototype Pattern）:
        BeanDefinition类的isPrototype()方法标识bean是否为原型，AbstractBeanFactory的doGetBean()方法处理原型bean的实例化。
5、代理模式（Proxy Pattern）:
        Spring AOP中的JdkDynamicAopProxy和CglibAopProxy实现了JDK动态代理和CGLIB代理。Advised接口定义了对代理对象的配置，如设置拦截器链。

public interface TargetInterface {
    void doSomething();
}

public class Target implements TargetInterface {
    @Override
    public void doSomething() {
        System.out.println("Target doing something...");
    }
}

public class JdkDynamicProxy implements InvocationHandler {
    private Object target;

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

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

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }
}

6、策略模式（Strategy Pattern）:
        BeanPostProcessor接口定义了一系列策略，如InstantiationAwareBeanPostProcessor和BeanFactoryPostProcessor，允许用户在bean生命周期的特定阶段插入自定义逻辑。

public interface BeanPostProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

7、桥接模式（Bridge Pattern）:
        Spring的Resource接口和它的实现类（如ClassPathResource，FileSystemResource）展示了桥接模式，将资源的抽象与资源的实现分离。
8、组合模式（Composite Pattern）:
        在Spring的事件模型中，ApplicationEventMulticaster可以包含其他ApplicationEventMulticaster实例，形成一个事件广播的树状结构。
9、装饰器模式（Decorator Pattern）:
        DelegatingFilterProxy类装饰了一个过滤器，允许在Servlet容器之外管理过滤器的行为。

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("Concrete component operation");
    }
}

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        additionalBehaviorA();
    }

    private void additionalBehaviorA() {
        System.out.println("Additional behavior A");
    }
}

10、命令模式（Command Pattern）:
        Spring MVC的HandlerAdapter接口和它的实现类，如RequestMappingHandlerAdapter，封装了控制器处理请求的具体逻辑。
11、模板方法模式（Template Method Pattern）:
        JdbcTemplate和SimpleJdbcInsert类定义了数据库操作的模板方法，子类可以重写某些步骤来定制行为。

public abstract class JdbcTemplate {
    protected abstract RowMapper<T> getRowMapper();

    public List<T> query(String sql, RowMapper<T> rowMapper) {
        Connection connection = getConnection();
        PreparedStatement ps = prepareStatement(connection, sql);
        ResultSet rs = executeQuery(ps);
        List<T> results = new ArrayList<>();
        while (rs.next()) {
            T result = rowMapper.mapRow(rs, rs.getMetaData().getColumnCount());
            results.add(result);
        }
        closeResources(rs, ps, connection);
        return results;
    }

    // ... 实现方法
}

12、观察者模式（Observer Pattern）:
        ApplicationEventPublisher接口和ApplicationListener接口实现事件发布和监听，符合观察者模式。
13、责任链模式（Chain of Responsibility Pattern）:
        在Spring MVC中，HandlerMapping和HandlerAdapter形成一个处理链，每个组件决定是否处理请求。
14、状态模式（State Pattern）:
        例如，PlatformTransactionManager接口和它的实现类如DataSourceTransactionManager，根据事务的不同状态来执行相应的操作。
15、享元模式（Flyweight Pattern）:
        在Spring的ResourcePatternResolver中，可能会复用相同的Resource对象来提高性能。
16、访问者模式（Visitor Pattern）:
        BeanDefinitionVisitor接口允许访问和修改BeanDefinition，但Spring中使用得不多。
这些模式在Spring的各个模块和组件中相互协作，共同构建了其强大的功能和灵活性。理解这些模式有助于深入学习和使用Spring框架。