Java创建对象和spring创建对象的过程和区别

暮乘白帝过重山

从new到IoC的演进，体现了软件工程从"怎么做"到"做什么"的思维转变。理解Java对象创建的底层机制，是写出高性能代码的基础；掌握Spring的Bean管理哲学，则是构建可维护大型系统的关键。二者如同汽车的发动机与智能驾驶系统——前者保证基础性能，后者提供高阶能力，共同推动Java生态持续发展。

从new到IoC：揭秘Java与Spring对象创建的差异与本质

一、Java原生对象创建全流程剖析

先来个王炸：Java的new关键字实际上是语法糖，其底层通过bytecode new + invokespecial两条指令协作完成。这种设计既保持了语言简洁性，又为JVM优化（如逃逸分析、栈上分配）留足了空间

1.1 new关键字背着我们都做了些什么？？？

当我们写下UserService service = new UserService()时，JVM会执行以下精密流程：

public class UserService {
    private int id;      // 默认0
    private String name; // 默认null
    
    {
        System.out.println("初始化块执行"); // 第1步
    }
    
    public UserService() {
        System.out.println("构造函数执行");  // 第2步
    }
}

类加载检查：
- JVM检查方法区是否已加载类元数据
- 未加载则触发类加载机制（双亲委派模型）
内存分配：
- 计算对象大小（指针压缩影响）
- 选择分配方式（指针碰撞/空闲列表）
- 堆内存中划分对象空间
零值初始化：
- 所有基本类型赋默认值（int=0, boolean=false）
- 引用类型置null
对象头设置：
- MarkWord（哈希码、GC年龄、锁状态）
- 类型指针（指向类元数据）
初始化执行：
- 初始化块（按代码顺序）
- 构造函数（显式初始化）

1.2 反射创建：灵活背后的代价

通过反射API创建对象的典型流程：

Class<?> clazz = Class.forName("com.example.UserService");
Constructor<?> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true);
UserService instance = (UserService) constructor.newInstance();

执行步骤：

类加载器加载目标类
获取构造器对象并绕过访问检查
通过Unsafe类分配内存
直接调用构造器（跳过常规初始化顺序）

1.3 其他创建方式对比

创建方式	适用场景	注意事项
Cloneable	对象拷贝场景	深拷贝/浅拷贝问题
反序列化	网络传输、持久化存储	绕开构造器执行
Unsafe.allocate	极高性能需求	可能破坏JVM内存模型

一些补充：

1.4 JavaBean规范

必须是公共类，类访问权限需为 public，以便外部访问。
提供无参公共构造方法，必须有一个 public 的无参数构造函数（默认构造方法），便于反射实例化。
属性私有化，属性（字段）必须用 private 修饰，通过公共方法访问。通过 getter/setter 访问属性，对每个 private 属性，提供标准的 getXxx() 和 setXxx() 方法（布尔属性可用 isXxx()）。
实现 Serializable 接口（可选但常见），支持序列化，便于网络传输或持久化存储。

二、Spring IoC容器对象创建全解析

一样的，先来手王炸：Spring IoC容器对象创建

Spring创建对象的本质是通过BeanDefinition元数据驱动IoC容器执行一套标准化的对象生命周期管理流程，在运行时动态组装、增强和管理对象依赖关系，实现控制反转和面向切面编程的统一治理。

什么？你有点被炸懵了？那我换种说法

Spring创建对象的核心机制就是IoC（控制反转）容器在运作，

但更准确的说法是：

"Spring创建对象 = IoC容器管理 + 依赖注入 + 扩展增强"

通俗说就是：

IoC容器是"工厂"：它负责根据你的配置（注解/XML）生产对象（比如@Service标注的类）。
依赖注入是"自动装配"：对象需要的其他组件（比如@Autowired的成员），Spring会自动塞进去。
扩展增强是"增值服务"：AOP代理、生命周期回调等（比如@Transactional事务控制）。

为什么说"不只是IoC"？

单纯IoC：只是"不用你自己new"（控制权反转）。
Spring的完整流程：还包括依赖注入（DI）、AOP、作用域管理（单例/原型）等，比传统IoC更强大。

（就像网购：IoC是"商家替你发货"，而Spring是"发货+送货上门+七天无理由+赠品"一套完整服务）

2.1 Bean生命周期全景图

Spring Bean 的创建过程之所以远比直接 new 对象复杂，是因为它在底层构建了一套完整的对象生命周期管理体系。让我们通过一个生活中的比喻来理解这个精密过程：想象我们现在要建造房子（Bean），而 Spring 容器就像一个全能的建筑管理局，不仅负责砖瓦堆砌（对象创建），还要统筹水电布线（依赖注入）、安全监控（AOP）、装修验收（生命周期回调）等全套流程。OK，我们说一说建房子的一套简单流程

第1阶段：图纸审批（加载配置元数据）

现实场景：向城建局提交房屋设计图（XML/注解/JavaConfig）
技术实现：
1. 扫描 @ComponentScan 指定的包路径
2. 解析 @Configuration 类中的 @Bean 方法
3. 读取 XML 中的 <bean> 定义
4. 处理 @Import 导入的其他配置
关键机制：兄弟们记住：BeanDefinitionReader 任务就是将不同格式的配置统一转化为内存中的 Bean 然后能进行下一步

第2阶段：地基浇筑（也就是实例化Bean）

现实场景：我们花钱请来一批施工队，然后施工队的任务是不是就是根据图纸打地基？（调用构造方法）

技术细节：

// AbstractAutowireCapableBeanFactory
protected Object createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 构造器推断算法：智能匹配参数最多的构造器
    Constructor<?> constructorToUse = determineConstructor(beanName, mbd);
    
    // 通过反射实例化或CGLIB动态生成子类
    return instantiateBean(beanName, mbd, constructorToUse, args);
}

我说一下，有种特殊特殊场景：记住是spring！！！
当遇到循环依赖（A依赖B，B又依赖A）时，Spring 的"三级缓存"开始运作：
1. 施工许可证公示（三级缓存 singletonFactories）：提前暴露半成品对象
2. 毛坯房展示（二级缓存 earlySingletonObjects）：存放未装修的原始对象
3. 精装房交付（一级缓存 singletonObjects）：最终成品

第3阶段：毛坯的人生，精装的朋友圈，房子一样，毛坯房建好了，接下俩就是请水电师傅，叫他们水电安装（也就是属性填充）

现实场景：给房屋安装水管（@Autowired）和电线（@Value）

技术流程：

// 处理自动装配的核心逻辑
for (PropertyValue pv : mbd.getPropertyValues().getPropertyValues()) {
    // 1. 解决依赖：在容器中查找匹配的Bean
    Object resolvedValue = resolveDependency(pv);
    
    // 2. 反射注入：通过Field.set()或setter方法
    ReflectionUtils.makeAccessible(field);
    field.set(beanInstance, resolvedValue);
}

智能处理：
- 遇到 @Lazy 注解时延迟加载
- 对 @Qualifier 指定的 Bean 进行精确匹配
- 处理 @Primary 标注的优先候选对象

第4阶段：最后要叫人来看看房子达不达标，也就是安全验收（BeanPostProcessor处理）

现实场景：消防检查（前置处理）和环保认证（后置处理）

代码示例：

public interface BeanPostProcessor {
    // 装修前检查（如@PostConstruct处理）
    default Object postProcessBeforeInitialization(Object bean, String name) { return bean; }
    
    // 装修后验收（如AOP代理包装）
    default Object postProcessAfterInitialization(Object bean, String name) { return bean; }
}

开发中经常遇到的情况处理
1. AutowiredAnnotationBeanPostProcessor 处理自动装配
2. CommonAnnotationBeanPostProcessor 解析 @PostConstruct
3. AbstractAdvisingBeanPostProcessor 准备AOP代理

第5阶段：精装修（初始化方法执行）

现实场景：安装智能家居系统（初始化逻辑）
执行顺序：
1. @PostConstruct 标注的方法 → 2. InitializingBean 接口的 afterPropertiesSet() → 3. XML 中配置的 init-method

代码演示：

public class SmartHomeService implements InitializingBean {
    @PostConstruct
    public void connectIoT() {
        System.out.println("连接智能设备...");
    }
    
    @Override
    public void afterPropertiesSet() {
        System.out.println("启动环境监测系统...");
    }
    
    public void initSceneMode() {
        System.out.println("配置情景模式...");
    }
}

第6阶段：安防系统部署（AOP代理）

现实场景：安装监控摄像头（切面逻辑）

代理策略：

public DefaultAopProxyFactory createAopProxy(AdvisedSupport config) {
    // 条件判断：目标类是否有接口？是否是CGLIB代理？
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        return new ObjenesisCglibAopProxy(config);
    } else {
        return new JdkDynamicAopProxy(config);
    }
}

动态代理示例：

// JDK代理示例
public class $Proxy12 extends Proxy implements UserService {
    public final void saveUser() {
        // 1. 执行@Before advice
        // 2. 调用target.saveUser()
        // 3. 执行@After advice
    }
}

第7阶段：房产登记（注册单例池）

现实场景：将房屋信息录入不动产登记中心

最终存储：

// DefaultSingletonBeanRegistry
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
    }
}

2.2 核心阶段详解

阶段1：实例化（Instantiation）

通过反射或CGLIB创建原始对象
构造器解析策略：构造器参数匹配算法

阶段2：属性填充（Population）

处理@Autowired/@Value注解
解决循环依赖的三级缓存机制：
1. singletonFactories（三级）
2. earlySingletonObjects（二级）
3. singletonObjects（一级）

阶段3：初始化（Initialization）

public class UserService implements InitializingBean {
    @PostConstruct
    public void customInit() {
        // 注解方式初始化
    }
    
    @Override
    public void afterPropertiesSet() {
        // 接口方式初始化
    }
    
    public void xmlInit() {
        // XML配置的初始化方法
    }
}

初始化顺序：

@PostConstruct

InitializingBean接口

XML配置的init-method

2.3 代理与包装阶段（了解）

AOP代理的两种实现方式：

JDK动态代理：基于接口（生成$Proxy类）
CGLIB代理：基于继承（生成Enhancer子类）

代理时机选择：

// AbstractAutoProxyCreator
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        return bean;
    }
    // 创建代理逻辑...
}

三、核心差异对比与选型指南

3.1 核心机制对比表

维度	Java原生创建	Spring Bean创建
控制权	开发者直接控制	容器控制（IoC）
生命周期	由JVM管理	完整生命周期管理
依赖注入	手动设置	自动装配
对象类型	原始类型	可能被代理包装
创建成本	低（约5ns）	高（约5000ns）
作用域	单一实例	支持多种作用域

3.2 性能对比数据

通过JMH测试（纳秒/操作）：

操作	平均耗时	99%分位
new创建	5.2	7.1
反射创建	18.7	25.3
Spring单例获取	42.3	55.9
Spring原型创建	4832.6	5214.8

3.3 最佳实践建议

适合Java原生创建的场景：

高频创建的对象（如DTO）
不需要依赖管理的工具类
对启动速度敏感的应用

适合Spring管理的场景：

需要依赖注入的业务组件
需要AOP增强的服务类
需要复杂生命周期的资源对象

四、深度思考：

4.1 对象管理范式的转变

Java原生方式体现命令式编程思想：

// 开发者全权控制
DBConn conn = new MySQLConn(config);
UserDAO dao = new UserDAO(conn);
Service service = new Service(dao);

Spring IoC体现声明式编程哲学：

@Configuration
public class AppConfig {
    @Bean
    public DBConn dbConn() { /*...*/ }
    
    @Bean
    public UserDAO userDAO(DBConn conn) { /*...*/ }
    
    @Bean
    public Service service(UserDAO dao) { /*...*/ }
}