当前位置：首页 > news >正文

Java全栈面试宝典：内存模型与Spring设计模式深度解析

news 来源：原创 2025/6/10 3:58:10

一、JVM内存模型进阶篇

🔥 问题13：堆与栈的六大维度对比

内存结构对比图

核心差异对照表

对比维度	堆（Heap）	栈（Stack）
存储内容	对象实例、数组	局部变量、方法参数
线程共享	全局共享	线程私有
生命周期	由GC管理	方法执行结束自动释放
空间分配	动态分配	编译期确定大小
默认容量	数百MB~数GB	1MB（可调优）
访问速度	较慢（寻址开销）	极快（直接操作栈指针）
内存碎片	频繁GC产生碎片	几乎无碎片
异常类型	OutOfMemoryError	StackOverflowError

🔥 问题14：三区联动内存模型解析

代码内存分配图解

public class MemoryModelDemo {
    private String user;          // 堆中对象成员变量
    
    public void execute() {
        int count = 0;            // 栈帧中的局部变量
        String msg = "Hello";     // 栈存引用，堆存字符串对象
        Object obj = new Object(); // 栈存引用，堆存对象实例
    }
}

三区协作流程图

二、Spring设计模式全景解析

🌟 Spring框架七大设计模式

1. 工厂模式（Factory Pattern）

应用场景：BeanFactory体系
实现原理：

public interface BeanFactory {
    Object getBean(String name);
}

public class DefaultListableBeanFactory implements BeanFactory {
    private Map<String, Object> beanCache = new ConcurrentHashMap<>();
    
    public Object getBean(String name) {
        return beanCache.get(name);
    }
}

2. 单例模式（Singleton Pattern）

实现方式：

@Component
@Scope("singleton") // 默认作用域
public class OrderService {
    // 单例实现
}

3. 代理模式（Proxy Pattern）

AOP实现：

public class JdkDynamicProxy implements InvocationHandler {
    private Object target;
    
    public Object createProxy(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args) {
        // 前置增强
        Object result = method.invoke(target, args);
        // 后置增强
        return result;
    }
}

4. 模板方法模式（Template Method）

JdbcTemplate应用：

public class JdbcTemplate {
    public <T> T query(String sql, ResultSetExtractor<T> extractor) {
        // 1.获取连接
        // 2.创建Statement
        // 3.执行查询（模板方法）
        // 4.结果提取（抽象方法）
        // 5.释放资源
    }
}

5. 观察者模式（Observer Pattern）

事件驱动模型：

// 定义事件
public class OrderEvent extends ApplicationEvent {
    public OrderEvent(Object source) {
        super(source);
    }
}

// 监听器实现
@Component
public class OrderListener implements ApplicationListener<OrderEvent> {
    public void onApplicationEvent(OrderEvent event) {
        // 处理订单事件
    }
}

6. 适配器模式（Adapter Pattern）

HandlerAdapter实现：

public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, 
                       HttpServletResponse response, 
                       Object handler);
}

public class RequestMappingHandlerAdapter implements HandlerAdapter {
    // 适配不同处理器
}

7. 装饰器模式（Decorator Pattern）

HttpRequest增强：

public class ContentCachingRequestWrapper extends HttpServletRequestWrapper {
    private byte[] cachedContent;
    
    public ContentCachingRequestWrapper(HttpServletRequest request) {
        super(request);
    }
    
    // 增强getInputStream方法
    public ServletInputStream getInputStream() {
        // 缓存读取逻辑
    }
}

三、Spring核心容器模块深度剖析

Spring Context模块架构

核心功能解析

Bean生命周期管理

public class BeanLifecycleDemo implements 
    BeanNameAware, 
    BeanFactoryAware,
    ApplicationContextAware,
    InitializingBean,
    DisposableBean {
    
    // 实现各阶段回调方法
}

国际化支持

MessageSource messageSource = context.getBean(MessageSource.class);
String msg = messageSource.getMessage(
    "welcome.message", 
    new Object[]{"用户"}, 
    Locale.CHINA);

事件传播机制

context.publishEvent(new CustomEvent(this));

环境抽象

Environment env = context.getEnvironment();
String profile = env.getProperty("spring.profiles.active");

四、高频面试题强化训练

1. Spring中如何保证线程安全？

方案一：使用原型（Prototype）作用域
方案二：ThreadLocal变量隔离
方案三：同步代码块控制
最佳实践：无状态Bean设计

2. BeanFactory与ApplicationContext的区别？

维度	BeanFactory	ApplicationContext
功能范围	基础IoC容器	企业级扩展容器
加载方式	延迟加载	预加载
国际化支持	不支持	支持
事件机制	无	完整事件发布体系
资源访问	基础ResourceLoader	增强资源模式

3. 如何实现自定义Bean作用域？

public class ThreadScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadLocal = 
        ThreadLocal.withInitial(HashMap::new);
        
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadLocal.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }
    
    // 实现其他接口方法
}

// 注册作用域
context.getBeanFactory().registerScope("thread", new ThreadScope());

实战建议：