Spring实例化bean的6种常见方式详解_Java

spring 实例化 bean 是 ioc 容器的核心能力之一，主要有 6 种常见方式，我会从新手易懂的角度，由基础到进阶逐一讲解，并配合代码示例，让你清晰理解每种方式的使用场景和实现逻辑。

一、核心实例化方式（附代码示例）

1. 构造器实例化（最常用）

这是 spring 默认的实例化方式，ioc 容器通过调用 bean 的无参构造器创建实例（如果有参构造器，需通过配置指定参数）。

适用场景：绝大多数普通业务 bean（如 service、controller）。

代码示例：

// 1. 定义普通类（无参构造器默认存在，无需显式写）
public class userservice {
    public userservice() {
        system.out.println("userservice 无参构造器执行");
    }
    
    public void sayhello() {
        system.out.println("hello, spring!");
    }
}

// 2. spring 配置（xml 方式）
<!-- applicationcontext.xml -->
<bean id="userservice" class="com.example.userservice"/>

// 3. 测试代码
public class test {
    public static void main(string[] args) {
        applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
        userservice userservice = (userservice) context.getbean("userservice");
        userservice.sayhello(); // 输出：userservice 无参构造器执行 + hello, spring!
    }
}

如果是有参构造器，xml 配置需指定参数：

xml

<!-- 有参构造器实例化 -->
<bean id="userservice" class="com.example.userservice">
    <constructor-arg value="张三"/> <!-- 对应构造器的参数 -->
</bean>

2. 静态工厂方法实例化

通过调用静态方法返回 bean 实例，适用于需要统一控制实例创建逻辑的场景（如工具类、单例对象）。

适用场景：第三方类库、自定义单例工厂。

代码示例：

// 1. 定义工厂类（包含静态方法）
public class userservicefactory {
    // 静态工厂方法，返回 userservice 实例
    public static userservice createuserservice() {
        return new userservice();
    }
}

// 2. spring 配置
<bean id="userservice" class="com.example.userservicefactory" 
      factory-method="createuserservice"/> <!-- 指定静态工厂方法 -->

// 3. 测试（和构造器方式一致，spring 会调用 createuserservice() 创建实例）

3. 实例工厂方法实例化

通过调用非静态方法（即先创建工厂 bean 实例，再调用其方法）返回 bean 实例，适用于工厂类需要维护状态的场景。

适用场景：工厂类需要依赖其他 bean、或需要多实例工厂。

代码示例：

// 1. 定义实例工厂类（非静态方法）
public class userserviceinstancefactory {
    public userservice createuserservice() {
        return new userservice();
    }
}

// 2. spring 配置（先定义工厂 bean，再通过工厂 bean 调用方法）
<bean id="userservicefactory" class="com.example.userserviceinstancefactory"/>
<bean id="userservice" factory-bean="userservicefactory" 
      factory-method="createuserservice"/>

4. factorybean 接口实例化（进阶）

这是 spring 提供的专用工厂接口（注意和上面的 “工厂方法” 区分），实现该接口可以自定义 bean 的创建逻辑，还能控制 bean 的初始化、销毁。

核心方法：

getobject()：返回 bean 实例；
getobjecttype()：返回 bean 的类型；
issingleton()：是否单例（默认 true）。

适用场景：复杂对象创建（如数据源、mybatis 的 sqlsessionfactory）。

代码示例：

// 1. 实现 factorybean 接口
public class userservicefactorybean implements factorybean<userservice> {
    @override
    public userservice getobject() throws exception {
        return new userservice(); // 自定义创建逻辑
    }

    @override
    public class<?> getobjecttype() {
        return userservice.class;
    }

    // 可选：指定是否单例（默认 true）
    @override
    public boolean issingleton() {
        return true;
    }
}

// 2. spring 配置
<bean id="userservice" class="com.example.userservicefactorybean"/>

// 3. 测试（spring 会自动调用 getobject() 获取实例）

5. 注解驱动实例化（主流）

基于注解的方式是现代 spring 开发的主流，替代 xml 配置，核心注解包括：

@component：通用注解（标注普通 bean）；
@service：标注业务层 bean；
@controller：标注控制层 bean；
@repository：标注数据访问层 bean；
@configuration + @bean：标注配置类，通过方法返回 bean 实例。

代码示例（@component 方式）：

// 1. 标注注解
@service // 等同于在 xml 中定义 bean
public class userservice {
    public void sayhello() {
        system.out.println("hello, annotation!");
    }
}

// 2. 开启注解扫描（xml 或配置类）
<!-- xml 方式开启扫描 -->
<context:component-scan base-package="com.example"/>

// 或配置类方式（推荐）
@configuration
@componentscan("com.example") // 扫描指定包下的注解 bean
public class springconfig {}

// 3. 测试
public class test {
    public static void main(string[] args) {
        applicationcontext context = new annotationconfigapplicationcontext(springconfig.class);
        userservice userservice = context.getbean(userservice.class);
        userservice.sayhello(); // 输出：hello, annotation!
    }
}

代码示例（@configuration + @bean 方式）：

// 1. 配置类中定义 bean
@configuration
public class springconfig {
    // 方法返回值即为 bean 实例，方法名默认是 bean 的 id
    @bean
    public userservice userservice() {
        return new userservice();
    }
}

// 2. 测试（直接获取 bean）

6. 通过 beandefinition 手动实例化（底层）

这是最底层的方式，直接操作 spring 的 beandefinition（bean 的定义元数据），通过编程式方式向容器注册 bean，适用于框架开发或动态创建 bean。

适用场景：自定义 spring 扩展、动态生成 bean。

代码示例：

public class test {
    public static void main(string[] args) {
        // 1. 创建 beanfactory 容器
        defaultlistablebeanfactory beanfactory = new defaultlistablebeanfactory();
        
        // 2. 构建 beandefinition（定义 bean 的元数据）
        beandefinition beandefinition = beandefinitionbuilder
                .genericbeandefinition(userservice.class)
                .getbeandefinition();
        
        // 3. 注册 beandefinition 到容器
        beanfactory.registerbeandefinition("userservice", beandefinition);
        
        // 4. 获取 bean 实例
        userservice userservice = beanfactory.getbean("userservice", userservice.class);
        userservice.sayhello();
    }
}

二、不同方式的使用场景总结

实例化方式	核心特点	适用场景
构造器实例化	简单、默认支持	普通业务 bean（无复杂创建逻辑）
静态工厂方法	统一控制实例创建	第三方类库、单例对象
实例工厂方法	工厂可维护状态、依赖其他 bean	需多实例工厂、工厂依赖注入
factorybean 接口	自定义创建逻辑、控制初始化	复杂对象（数据源、sqlsessionfactory）
注解驱动实例化	简洁、主流	现代 spring 项目（spring boot）
beandefinition 手动	底层、灵活	框架开发、动态创建 bean