Spring Architecture Series-9.Understanding Design Patterns Through Spring Framework Implementation

Introduction

Design pattern are reusable solutions to common soft ware design problems.The Spring Framework is a perfect example of how design patterns can be effectively applied to create a robust and flexible application framework. In this article,I’ll explore the key design patterns used in my miniSpring implementation.

Core Design Patterns

1. Factory Pattern

The Factory Pattern is central to Spring’s IoC container:

public interface BeanFactory {
    Object getBean(String beanName) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name);
    boolean isPrototype(String name);
    Class<?> getType(String name);
}

Enter fullscreen mode Exit fullscreen mode

Implementation example

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory 
        implements ConfigurableListableBeanFactory {
    protected Map<String, BeanDefinition> beanDefinitionMap = 
        new ConcurrentHashMap<>(256);

    @Override
    public Object getBean(String beanName) throws BeansException {
        Object singleton = getSingleton(beanName);
        if (singleton == null) {
            singleton = createBean(beanName);
        }
        return singleton;
    }
}

Enter fullscreen mode Exit fullscreen mode

Kay aspects:

1. Object creation abstraction
2. Dependency management
3. Lifecycle control

2. Proxy Pattern

The Proxy Pattern is used extensively in Spring’s AOP implementation:

public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
    private Object target;
    private PointcutAdvisor advisor;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
        if (this.advisor.getPointcut().getMethodMatcher()
                .matches(method, target.getClass())) {
            MethodInterceptor interceptor = advisor.getMethodInterceptor();
            MethodInvocation invocation = new ReflectiveMethodInvocation(
                proxy, target, method, args, target.getClass());
            return interceptor.invoke(invocation);
        }
        return method.invoke(target, args);
    }
}

Enter fullscreen mode Exit fullscreen mode

Features:

1. Dynamic proxy creation
2. Method interception
3. Advice application

3. Observer Pattern

The Observer Pattern is implemented in Spring’s event mechanism:

public interface ApplicationListener<E extends ApplicationEvent> 
        extends EventListener {
    void onApplicationEvent(E event);
}

public class SimpleApplicationEventPublisher 
        implements ApplicationEventPublisher {
    private List<ApplicationListener> listeners = new ArrayList<>();

    @Override
    public void publishEvent(ApplicationEvent event) {
        for (ApplicationListener listener : listeners) {
            listener.onApplicationEvent(event);
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Key aspects:

1. Event publishing
2. Listener registration
3. Event handling

4. Template Method Pattern

The Template Method Pattern is used in JDBC operation:

public class JdbcTemplate {
    public Object query(String sql, Object[] args, 
            PreparedStatementCallBack pstmtCallBack) {
        Connection con = null;
        PreparedStatement pstmt = null;
        try {
            con = dataSource.getConnection();
            pstmt = con.prepareStatement(sql);
            ArgumentPreparedStatementSetter setter = 
                new ArgumentPreparedStatementSetter(args);
            setter.setValues(pstmt);
            return pstmtCallBack.doInPreparedStatement(pstmt);
        } finally {
            // Resource cleanup
        }
    }
}

Enter fullscreen mode Exit fullscreen mode

Features:

1. Algorithm skeleton
2. Customizable steps
3. Resource management

5. Strategy Pattern

The Strategy Pattern is used in various parts of Spring:

public interface Pointcut {
    MethodMatcher getMethodMatcher();
}

public class NameMatchMethodPointcut implements Pointcut {
    private String mappedName = "";

    @Override
    public MethodMatcher getMethodMatcher() {
        return new MethodMatcher() {
            @Override
            public boolean matches(Method method, Class<?> targetClass) {
                return mappedName.equals(method.getName());
            }
        };
    }
}

Enter fullscreen mode Exit fullscreen mode

Key aspects:

1. Algorithm selection
2. Runtime configuration
3. Extensibility ## Pattern Integration ### 1. Factory and Proxy Integration

public class ProxyFactoryBean implements FactoryBean<Object> {
    private Object target;
    private PointcutAdvisor advisor;

    @Override
    public Object getObject() throws Exception {
        return createAopProxy().getProxy();
    }

    protected AopProxy createAopProxy() {
        return getAopProxyFactory().createAopProxy(target, this.advisor);
    }
}

Enter fullscreen mode Exit fullscreen mode

2. Observer and Template Method Integration

public abstract class AbstractApplicationContext 
        implements ApplicationContext {
    private ApplicationEventPublisher applicationEventPublisher;

    public void refresh() throws BeansException {
        // Template method steps
        initApplicationEventPublisher();
        registerListeners();
        finishRefresh();
    }

    protected void finishRefresh() {
        // Observer pattern usage
        publishEvent(new ContextRefreshedEvent(this));
    }
}

Enter fullscreen mode Exit fullscreen mode

Design Pattern Benefits

1. Flexibility

• Easy to extend
• Loose coupling
• Runtime configuration ### 2. Maintainability
• Clear structure
• Separation of concerns
• Reusable components ### 3. Scalability
• Modular design
• Efficient resource management
• Performance optimization

Best Practices

1. Pattern Selection

• Match pattern to problem
• Consider trade-offs
• Avoid over-engineering ### 2. Implementation
• Clean interfaces
• Proper abstraction
• Error handling ### 3. Integration
• Pattern combination
• Resource management
• Performance consideration

Common Challenges and Solutions

1. Complexity Management
   • Clear hierarchy
   • Interface segregation
   • Documentation
2. Performance
   • Caching strategies
   • Resource pooling
   • Lazy initialization
3. Extensibility
   • Extension points
   • Plugin architecture
   • Custom implementations

Conclusion

Understanding design patterns through Spring implementation provides:

• Deep insight into pattern usage
• Practical application examples
• Best practice guidelines
• Problem-solving strategies Key takeaways:
• Pattern selection criteria
• Implementation techniques
• Integration approaches
• Performance considerations

This implementation demonstrates how design patterns can be effectively combined to create a robust and flexible framework.

原文链接：Spring Architecture Series-9.Understanding Design Patterns Through Spring Framework Implementation