spring如何创建多例bean

worktile 1年前其他 55

共3条回复我来回复

worktile
Worktile官方账号
评论
Spring框架在创建bean时，默认情况下会使用单例模式来创建，即每个bean在Spring容器中只有一个实例。但是有时候我们需要创建多个实例，即多例模式。下面是几种Spring创建多例bean的方法：
1. 通过@Scope注解设置多例模式：
  在bean的定义类上使用@Scope注解，将scope属性设置为"prototype"，即可将该bean设置为多例模式，示例代码如下：
```
@Component
@Scope("prototype")
public class MyBean {
    // ...
}
```
2. 使用Lookup方法注入：
  可以通过在父类或接口中定义一个抽象方法，然后在子类或实现类中使用methods属性和@Lookup注解注入该方法，示例如下：
```
@Component
public abstract class MyBean {
    public abstract AnotherBean createAnotherBean();
}

@Component
public class MyBeanImpl extends MyBean {
    @Lookup
    public AnotherBean createAnotherBean() {
        // 返回具体的AnotherBean实例
    }
}
```
3. 使用自定义的BeanPostProcessor：
  可以自定义一个实现了BeanPostProcessor接口的类，重写postProcessBeforeInstantiation和postProcessAfterInitialization方法，在这两个方法中手动创建实例并返回，示例代码如下：
```
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("myBean".equals(beanName)) {
            // 返回MyBean的实例
        }
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}
```
需要注意的是，使用多例模式的bean在每次被使用时都会创建一个新的实例，并且不受Spring容器的管理，需要手动管理其生命周期。另外，多例模式的bean在使用时可能会带来一些性能上的开销，需慎重使用。
1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

在Spring框架中，默认情况下，所有的Bean都是单例的，也就是说每一个Bean的实例在容器中只有一个。但是有些情况下，我们可能需要创建多个实例，也就是多例的Bean。

在Spring框架中，创建多例的Bean有以下几种方式：

使用@Scope注解：可以通过在Bean的定义处使用@Scope注解来指定作用域为"prototype"，这样Spring容器就会为每次请求创建一个新的Bean实例。例如：

@Component
@Scope("prototype")
public class MyBean {
   // 类的定义
}

使用ConfigurableBeanFactory接口：可以通过实现ConfigurableBeanFactory接口并重写getBean方法来创建多例Bean。

@Component
public class MyBeanFactory implements ConfigurableBeanFactory {

  @Override
  public Object getBean(String name) throws BeansException {
    // 创建新的Bean实例
    return new MyBean();
  }

  // 其他方法的实现
}

然后，在配置文件中配置使用自定义的BeanFactory：

<bean id="myBeanFactory" class="com.example.MyBeanFactory"/>

<bean id="myBean" factory-bean="myBeanFactory" factory-method="getBean"/>

使用ApplicationContext接口：可以通过实现ApplicationContextAware接口，并重写setApplicationContext方法来访问ApplicationContext对象，从而手动创建多个Bean实例。

@Component
public class MyBeanHolder implements ApplicationContextAware {

  private ApplicationContext applicationContext;

  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
  }

  public MyBean getNewInstance() {
    // 创建新的Bean实例
    return applicationContext.getBean(MyBean.class);
  }
}

使用ObjectProvider接口：可以通过在需要获取多个Bean实例的地方注入ObjectProvider对象，并调用其stream方法来获取多个Bean实例。

@Component
public class MyBeanConsumer {

  private final ObjectProvider<MyBean> myBeans;

  public MyBeanConsumer(ObjectProvider<MyBean> myBeans) {
    this.myBeans = myBeans;
  }

  public void processBeans() {
    myBeans.stream().forEach(bean -> {
      // 对每个Bean实例进行处理
    });
  }
}

使用自定义注解：可以通过自定义注解，并配合自定义的BeanPostProcessor来实现多例Bean的创建。具体步骤如下：

定义自定义注解：

import org.springframework.context.annotation.Scope;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Scope("prototype")
public @interface PrototypeScoped {
}

实现自定义的BeanPostProcessor，并在其中处理带有自定义注解的Bean：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class PrototypeScopedBeanPostProcessor implements BeanPostProcessor {

  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    // 处理带有自定义注解的Bean
    if (bean.getClass().isAnnotationPresent(PrototypeScoped.class)) {
      return new MyBean();
    }
    return bean;
  }

  // 其他方法的实现
}

通过以上几种方式，我们可以实现在Spring框架中创建多例的Bean。根据具体的需求和场景，选择合适的方式来创建多个Bean实例。

1年前 0条评论

fiy
Worktile&PingCode市场小伙伴
评论
在Spring中，默认情况下，所有的Bean都是以单例的方式创建的，即每个Bean定义只会创建一个实例。但是，在某些情况下，我们可能需要以多例的方式创建Bean，也就是每个Bean定义可以创建多个实例。下面介绍几种创建多例Bean的方法。
1. 通过自定义作用域来创建多例Bean
  可以通过自定义作用域来实现多例Bean的创建。Spring中，作用域是通过实现org.springframework.beans.factory.config.Scope接口来实现的。
首先，我们需要实现Scope接口，重写其中的方法。以下是一个自定义多例作用域的示例代码：
```
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

import java.util.HashMap;
import java.util.Map;

public class CustomScope implements Scope {

    private final Map<String, Object> scopedObjects = new HashMap<>();

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        if (!scopedObjects.containsKey(name)) {
            scopedObjects.put(name, objectFactory.getObject());
        }
        return scopedObjects.get(name);
    }

    @Override
    public Object remove(String name) {
        return scopedObjects.remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable destructionCallback) {
        // 不支持销毁回调
    }

    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Override
    public String getConversationId() {
        return null;
    }
}
```
然后，在Spring配置文件中，注册我们自定义的作用域：
```
<bean class="com.example.CustomScope" scope="customScope" />
```
接下来，我们可以使用这个自定义作用域来创建多例Bean。在Bean定义中，指定作用域为我们自定义的作用域：
```
<bean id="myBean" class="com.example.MyBean" scope="customScope" />
```
这样，每次获取myBean时，都会创建一个新的实例。
1. 使用prototype作用域
  除了通过自定义作用域来创建多例Bean之外，还可以使用prototype作用域。prototype作用域表示每次获取Bean时都会创建一个新的实例。可以在Spring配置文件中，将作用域指定为prototype：
```
<bean id="myBean" class="com.example.MyBean" scope="prototype" />
```
这样，每次获取myBean时，都会创建一个新的实例。

需要注意的是，使用prototype作用域创建的Bean不会由Spring容器管理其生命周期，所以需要自行处理销毁操作。
1. 使用ObjectFactory或Provider来创建多例Bean
  还可以使用ObjectFactory或Provider来创建多例Bean。这两个接口可以通过@Autowired注解进行注入，通过调用getObject()方法来获取多例Bean的实例。
首先，在Bean定义中，将作用域指定为singleton（单例）：
```
<bean id="myBean" class="com.example.MyBean" scope="singleton" />
```
然后，在需要使用多例Bean的地方注入ObjectFactory或Provider：
```
import javax.inject.Provider;

public class MyService {

    @Autowired
    private Provider<MyBean> myBeanProvider;
    
    public void doSomething() {
        MyBean myBean = myBeanProvider.get();
        // 使用多例Bean
    }
}
```
通过调用get()方法，可以获取多例Bean的实例。

综上所述，我们可以通过自定义作用域、使用prototype作用域、或者使用ObjectFactory或Provider来创建多例Bean。根据具体情况选择合适的方式。
1年前 0条评论