Spring成神之路第十四篇：单例bean中使用多例bean，你未必会玩？

最新推荐文章于 2024-08-03 16:06:28 发布
最新推荐文章于 2024-08-03 16:06:28 发布
阅读量260 收藏
点赞数
分类专栏： Spring成神之路 文章标签： spring java servlet
原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648934074&idx=1&sn=5b7ccbef079053d9af4027f0dc642c56&chksm=88621e84bf1597923127e459e11da5c27741f080a0bfd033019ccc52cf67915ec4999d76b6dd&token=1283885571&lang=zh_CN&scene=21#wechat_redirect
版权

Spring成神之路第十四篇：单例bean中使用多例bean，你未必会玩？

lookup-method：方法查找

通常情况下，我们使用的bean都是单例的，如果一个bean需要依赖于另一个bean的时候，可以在当前bean中声明另外一个bean引用，然后注入依赖的bean，此时被依赖的bean在当前bean中自始至终都是同一个实例。

先来个案例回顾一下

package com.javacode2018.lesson001.demo13.normal;

public class ServiceA {
}
package com.javacode2018.lesson001.demo13.normal;

public class ServiceB {

    private ServiceA serviceA;

    public ServiceA getServiceA() {
        return serviceA;
    }

    public void setServiceA(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
}

上面2个类，ServiceA和ServiceB，而ServiceB中需要用到ServiceA，可以通过setServiceA将serviceA注入到ServiceB中，spring配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="serviceA" class="com.javacode2018.lesson001.demo13.normal.ServiceA" scope="prototype"/>

    <bean id="serviceB" class="com.javacode2018.lesson001.demo13.normal.ServiceB">
        <property name="serviceA" ref="serviceA"/>
    </bean>

</beans>

上面serviceA的scope是prototype，表示serviceA是多例的，每次从容器中获取serviceA都会返回一个新的对象。

而serviceB的scope没有配置，默认是单例的，通过property元素将serviceA注入。

来个测试案例，如下：

package com.javacode2018.lesson001.demo13;


import com.javacode2018.lesson001.demo13.normal.ServiceA;
import com.javacode2018.lesson001.demo13.normal.ServiceB;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活!
 * lookupMethod的使用
 */
public class LookupMethodTest {

    @Test
    public void normalBean() {
        String beanXml = "classpath:/com/javacode2018/lesson001/demo13/normalBean.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

        System.out.println(context.getBean(ServiceA.class)); //@1
        System.out.println(context.getBean(ServiceA.class)); //@2

        System.out.println("serviceB中的serviceA");
        ServiceB serviceB = context.getBean(ServiceB.class); //@3
        System.out.println(serviceB.getServiceA()); //@4
        System.out.println(serviceB.getServiceA()); //@5
    }
}

@1和@2从容器中按照类型查找ServiceA对应的bean。

@3：从容器中获取ServiceB

@4和@5：获取serviceB中的serviceA对象

运行normalBean()看一下效果：

com.javacode2018.lesson001.demo13.normal.ServiceA@5bfa9431
com.javacode2018.lesson001.demo13.normal.ServiceA@5db250b4
serviceB中的serviceA
com.javacode2018.lesson001.demo13.normal.ServiceA@223f3642
com.javacode2018.lesson001.demo13.normal.ServiceA@223f3642

从输出中可以看出，@1和@2输出了不同的ServiceA，而@4和@5输出的是同一个serviceA，这是因为serviceB是单例的，serviceB中的serviceA会在容器创建serviceB的时候，从容器中获取一个serviceA将其注入到serviceB中，所以自始至终serviceB中的serviceA都是同一个对象。

如果我们希望beanB中每次使用beanA的时候beanA都是一个新的实例，我们怎么实现呢？

我们可以在serviceB中加个方法去获取serviceA，这个方法中我们主动去容器中获取serviceA，那么每次获取到的都是不同的serviceA实例。

那么问题来了，我们如何在serviceB中获取到spring容器呢？

spring中有个接口**ApplicationContextAware**：

org.springframework.context.ApplicationContextAware

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}

上面这个接口有一个方法setApplicationContext，这个接口给了自定义的bean中获取applicationContext的能力，当我们的类实现这个接口之后，spring容器创建bean对象的时候，如果bean实现了这个接口，那么容器会自动调用setApplicationContext方法，将容器对象applicationContext传入，此时在我们的bean对象中就可以使用容器的任何方法了。

下面我们就通过ApplicationContextAware接口来实现单例bean中使用多例bean的案例。

单例bean中使用多例bean：ApplicationContext接口的方式

ServiceA.java
package com.javacode2018.lesson001.demo13.applicationcontextaware;

public class ServiceA {
}
ServiceB.java
package com.javacode2018.lesson001.demo13.applicationcontextaware;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class ServiceB implements ApplicationContextAware { //@1

    public void say(){
        ServiceA serviceA = this.getServiceA();//@2
        System.out.println("this:"+this+",serviceA:"+ serviceA);
    }

    public ServiceA getServiceA() {
        return this.context.getBean(ServiceA.class);//@3
    }

    private ApplicationContext context;

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

注意上面代码，ServiceB实现了ApplicationContextAware接口，然后实现了这个接口中的setApplicationContext方法，spring容器在创建ServiceB的时候会自动调用setApplicationContext方法。

@3：从容器中主动去获取ServiceA，这样每次获取到的ServiceA都是一个新的实例。

@2：say方法中调用getServiceA方法获取ServiceA对象，然后将其输出。

alicationcontextaware.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="serviceA" class="com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA" scope="prototype"/>

    <bean id="serviceB" class="com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceB"/>

</beans>

上面定义了2个bean，第一个是多例的。

测试用例
@Test
public void alicationcontextaware() {
    String beanXml = "classpath:/com/javacode2018/lesson001/demo13/alicationcontextaware.xml";
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

    System.out.println(context.getBean(com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA.class)); //@1
    System.out.println(context.getBean(com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA.class)); //@2

    System.out.println("serviceB中的serviceA");
    com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceB serviceB = context.getBean(com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceB.class); //@3
    serviceB.say();
    serviceB.say();
}

运行输出：

com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA@78047b92
com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA@8909f18
serviceB中的serviceA
this:com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceB@79ca92b9,serviceA:com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA@1460a8c0
this:com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceB@79ca92b9,serviceA:com.javacode2018.lesson001.demo13.applicationcontextaware.ServiceA@4f638935

最后2行是是serviceB中的say方法输出的，可以看出serviceB是一个对象，而serviceA是不同的对象。

单例bean中使用多例bean：lookup-method方式实现

上面这种方式实现了单例bean中使用多例bean的需求，但是用到spring中的接口ApplicationContextAware，此时对spring的api有耦合的作用，我们一直推行高内聚低耦合，所以我们得寻求更好的办法。

能不能有这样的功能，当serviceB中调用getServiceA的时候，系统自动将这个方法拦截，然后去spring容器中查找对应的serviceA对象然后返回，spring中的lookup-method就可以实现这样的功能。

下面我们使用lookup-method来实现一下。

ServiceA.java
package com.javacode2018.lesson001.demo13.lookupmethod;

public class ServiceA {
}
ServiceB.java
package com.javacode2018.lesson001.demo13.lookupmethod;

public class ServiceB {

    public void say() {
        ServiceA serviceA = this.getServiceA();
        System.out.println("this:" + this + ",serviceA:" + serviceA);
    }

    public ServiceA getServiceA() { //@1
        return null;
    }

}

注意上面的@1，这个方法中返回了一个null对象，下面我们通过spring来创建上面2个bean对象，然后让spring对上面的getServiceA方法进行拦截，返回指定的bean，如下：

lookupmethod.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="serviceA" class="com.javacode2018.lesson001.demo13.lookupmethod.ServiceA" scope="prototype"/>

    <bean id="serviceB" class="com.javacode2018.lesson001.demo13.lookupmethod.ServiceB">
        <lookup-method name="getServiceA" bean="serviceA"/>
    </bean>

</beans>

注意上面的配置，重点在于这行配置：

<lookup-method name="getServiceA" bean="serviceA"/>

当我们调用serviceB中的getServiceA方法的时候，这个方法会拦截，然后会按照lookup-method元素中bean属性的值作为bean的名称去容器中查找对应bean，然后作为getServiceA的返回值返回，即调用getServiceA方法的时候，会从spring容器中查找id为serviceA的bean然后返回。

测试用例

LookupMethodTest中加个方法，如下：

@Test
public void lookupmethod() {
    String beanXml = "classpath:/com/javacode2018/lesson001/demo13/lookupmethod.xml";
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

    System.out.println(context.getBean(com.javacode2018.lesson001.demo13.lookupmethod.ServiceA.class)); //@1
    System.out.println(context.getBean(com.javacode2018.lesson001.demo13.lookupmethod.ServiceA.class)); //@2

    System.out.println("serviceB中的serviceA");
    com.javacode2018.lesson001.demo13.lookupmethod.ServiceB serviceB = context.getBean(com.javacode2018.lesson001.demo13.lookupmethod.ServiceB.class); //@3
    serviceB.say();
    serviceB.say();
}

运行看看效果：

com.javacode2018.lesson001.demo13.lookupmethod.ServiceA@619713e5
com.javacode2018.lesson001.demo13.lookupmethod.ServiceA@708f5957
serviceB中的serviceA
this:com.javacode2018.lesson001.demo13.lookupmethod.ServiceB$$EnhancerBySpringCGLIB$$aca8be5a@68999068,serviceA:com.javacode2018.lesson001.demo13.lookupmethod.ServiceA@7722c3c3
this:com.javacode2018.lesson001.demo13.lookupmethod.ServiceB$$EnhancerBySpringCGLIB$$aca8be5a@68999068,serviceA:com.javacode2018.lesson001.demo13.lookupmethod.ServiceA@2ef3eef9

注意最后2行的输出，serviceA是调用this.getServiceA()方法获取 ，源码中这个方法返回的是null，但是spring内部对这个方法进行了拦截，每次调用这个方法的时候，都会去容器中查找serviceA，然后返回，所以上面最后2行的输出中serviceA是有值的，并且是不同的serviceA实例。

lookup-method：看其名字，就知道意思：方法查找，调用name属性指定的方法的时候，spring会对这个方法进行拦截，然后去容器中查找lookup-method元素中bean属性指定的bean，然后将找到的bean作为方法的返回值返回。

这个地方底层是使用cglib代理实现的，后面有篇文章会详细介绍代理的2种实现，到时候大家注意下，spring中很多牛逼的功能都是靠代理实现的。

spring提供的还有一个功能，同样可以可以解决上面单例bean中用到多例bean的问题，也就是下面我们要说的replaced-method。

replaced-method：方法替换

replaced-method：方法替换，比如我们要调用serviceB中的getServiceA的时候，我们可以对serviceB这个bean中的getServiceA方法进行拦截，把这个调用请求转发到一个替换者处理。这就是replaced-method可以实现的功能，比lookup-method更强大更灵活。

replaced-method的使用3个步骤
步骤一：定义替换者

自定义一个替换者，替换者需要实现spring中的MethodReplacer接口，看一下这个接口的定义：

package org.springframework.beans.factory.support;

import java.lang.reflect.Method;

public interface MethodReplacer {

    /**
     * @param obj 被替换方法的目标对象
     * @param method 目标对象的方法
     * @param args 方法的参数
     * @return return value for the method
     */
    Object reimplement(Object obj, Method method, Object[] args) throws Throwable;

}

当调用目标对象需要被替换的方法的时候，这个调用请求会被转发到上面的替换者的reimplement方法进行处理。

如：

package com.javacode2018.lesson001.demo14;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.support.MethodReplacer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.lang.reflect.Method;
import java.util.Map;

/**
 * servieB的方法替换者
 */
public class ServiceBMethodReplacer implements MethodReplacer, ApplicationContextAware {

    @Override
    public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
        return this.context.getBean(ServiceA.class);
    }

    private ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}
步骤二：定义替换者bean
<!-- 定义替换者bean -->
<bean id="serviceBMethodReplacer" class="com.javacode2018.lesson001.demo14.ServiceBMethodReplacer" />
步骤二：通过replaced-method元素配置目标bean需要被替换的方法
<bean id="serviceB" class="com.javacode2018.lesson001.demo14.ServiceB">
    <replaced-method name="getServiceA" replacer="serviceAMethodReplacer"/>
</bean>

注意上面的replaced-method元素的2个属性：

name：用于指定当前bean需要被替换的方法

replacer：替换者，即实现了MethodReplacer接口的类对应的bean

上面配置中当调用serviceB的getServiceA的时候，会自动调用serviceAMethodReplacer这个bean中的reimplement方法进行处理。

案例
ServiceA.java
package com.javacode2018.lesson001.demo14;

public class ServiceA {
}
ServiceB.java
package com.javacode2018.lesson001.demo14;

public class ServiceB {

    public void say() {
        ServiceA serviceA = this.getServiceA();
        System.out.println("this:" + this + ",serviceA:" + serviceA);
    }

    public ServiceA getServiceA() { //@1
        return null;
    }
}

上面getServiceA需要返回一个ServiceA对象，此处返回的是null，下面我们通过spring对这个方法进行替换，然后从容器中获取ServiceA然后返回，下面我们来看看替换者的代码。

替换者ServiceBMethodReplacer.java

这个替换者会替换ServiceB中的getServiceA方法

package com.javacode2018.lesson001.demo14;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.support.MethodReplacer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.lang.reflect.Method;
import java.util.Map;

/**
 * servieB的方法替换者
 */
public class ServiceBMethodReplacer implements MethodReplacer, ApplicationContextAware {

    @Override
    public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
        return this.context.getBean(ServiceA.class);
    }

    private ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}
spring中bean配置文件：replacedmethod.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    <!-- 定义替换者bean -->
    <bean id="serviceBMethodReplacer" class="com.javacode2018.lesson001.demo14.ServiceBMethodReplacer" />

    <bean id="serviceA" class="com.javacode2018.lesson001.demo14.ServiceA" scope="prototype"/>

    <bean id="serviceB" class="com.javacode2018.lesson001.demo14.ServiceB">
        <replaced-method name="getServiceA" replacer="serviceBMethodReplacer"/>
    </bean>

</beans>
测试用例ReplacedMethodTest
package com.javacode2018.lesson001.demo14;


import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活!
 * replaced-method：方法替换
 */
public class ReplacedMethodTest {

    @Test
    public void replacedmethod() {
        String beanXml = "classpath:/com/javacode2018/lesson001/demo14/replacedmethod.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

        System.out.println(context.getBean(ServiceA.class)); //@1
        System.out.println(context.getBean(ServiceA.class)); //@2

        System.out.println("serviceB中的serviceA");
        ServiceB serviceB = context.getBean(ServiceB.class); //@3
        serviceB.say();
        serviceB.say();
    }

}
运行输出
com.javacode2018.lesson001.demo14.ServiceA@7722c3c3
com.javacode2018.lesson001.demo14.ServiceA@2ef3eef9
serviceB中的serviceA
this:com.javacode2018.lesson001.demo14.ServiceB$$EnhancerBySpringCGLIB$$21bb8912@243c4f91,serviceA:com.javacode2018.lesson001.demo14.ServiceA@291ae
this:com.javacode2018.lesson001.demo14.ServiceB$$EnhancerBySpringCGLIB$$21bb8912@243c4f91,serviceA:com.javacode2018.lesson001.demo14.ServiceA@61df66b6

从输出中可以看出结果和lookup-method案例效果差不多，实现了单例bean中使用多例bean的案例。

输出中都有CGLIB这样的字样，说明这玩意也是通过cglib实现的。

总结

  1. lookup-method：方法查找，可以对指定的bean的方法进行拦截，然后从容器中查找指定的bean作为被拦截方法的返回值
  2. replaced-method：方法替换，可以实现bean方法替换的效果，整体来说比lookup-method更灵活一些
  3. 单例bean中使用多例bean，本文中列出了3种方式，大家消化一下。

案例源码

链接：https://pan.baidu.com/s/1p6rcfKOeWQIVkuhVybzZmQ 
提取码：zr99

来源：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648934074&idx=1&sn=5b7ccbef079053d9af4027f0dc642c56&chksm=88621e84bf1597923127e459e11da5c27741f080a0bfd033019ccc52cf67915ec4999d76b6dd&token=1283885571&lang=zh_CN&scene=21#wechat_redirect

小明的学习圈子
关注
专栏目录
spring成神之路第三篇：Spring容器基本使用及原理（ApplicationContext接口获取bean的4种方式）...
CSDN_KONGlX的博客
10-16 844
环境 jdk1.8 idea maven-3.6.1 spring-5.2.3.RELEASE IOC容器 IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由ioc容器进行管理，不需要我们再去手动通过new的方式去创建对象，由ioc容器...
spring成神之路第十八篇：@ComponentScan、@ComponentScans 详解(bean 批量注册)
CSDN_KONGlX的博客
10-20 168
灵魂拷问 @ComponentScan注解是做什么的？ basePackages的方式和basePackageClasses的方式有什么区别？你建议用哪个？为什么？ useDefaultFilters有什么用？ 常见的过滤器有哪些类型？说说你知道的几个 @ComponentScan是在哪个类中处理的？说一下大概的解析过程？ 这些问题如果都ok，恭喜你，太优秀了，不知道没关...
Spring In Action-3.2@Scope单例、多例Bean
09-06
Spring In Action-3.2@Scope单例、多例Bean,Spring In Action-3.2@Scope单例、多例Bean,Spring In Action-3.2@Scope单例、多例Bean,Spring In Action-3.2@Scope单例、多例Bean
【spring5学习笔记】-----bean的多实例与单实例
qq_44765221的博客
08-17 631
bean的多实例与单实例 首先介绍概念，什么是spring中bean的多实例和单实例。 在上面这个例子中，我们两次调用context的getBean()方法得到的两个对象的引用值是相等的。这说明此时spring是单实例的，两次调用方法得到的是同一个对象。 spring修改使用多实例方案 // 配置中的scope有两种选择 singleton和prototype <bean id="user" class="beanDemo.User" scope="prototype">
Spring的生命周期及Spring Bean单例和多例---超详细教学
m0_73192864的博客
08-18 2284
本文章详细介绍了spring的生命周期及单例和多例的区别及如何使用，感兴趣的小伙伴可以看看，提取精华
spring的bean为什么是单例的？spring可以配置多例对象么什么时候用单例？什么时候用多例？
m0_52869579的博客
07-14 1440
spring的bean为什么是单例的？spring可以配置多例对象么什么时候用单例？什么时候用多例？
【Spring】单例bean中使用多例bean，你未必会玩？
m0_73311735的博客
08-18 176
lookup-method：方法查找，可以对指定的bean的方法进行拦截，然后从容器中查找指定的bean作为被拦截方法的返回值replaced-method：方法替换，可以实现bean方法替换的效果，整体来说比lookup-method更灵活一些单例bean中使用多例bean，本文中列出了3种方式，大家消化一下。...
spring成神之路第二十一篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）...
CSDN_KONGlX的博客
10-24 286
　　先来看几个问题 通过注解的方式注入依赖对象，介绍一下你知道的几种方式 @Autowired和@Resource有何区别 说一下@Autowired查找候选者的过程 说一下@Resource查找候选者的过程 @Qulifier有哪些用法？ @Qulifier加在类上面是干什么用的？ @Primary是做什么的？ 泛型注入用过么？ 这些问题如果你都ok，那么恭...
Spring系列第14篇：单例bean中使用多例bean，你未必会玩？
路人甲Java
03-05 2675
lookup-method：方法查找通常情况下，我们使用的bean都是单例的，如果一个bean需要依赖于另一个bean的时候，可以在当前bean中声明另外一个bean引用，然后注入依赖的...
【Spring成神之路】从源码角度深度刨析Spring循环依赖
最新发布
沉迷写代码的程序猿的博客
08-03 1103
互相依赖导致出现的问题，我个人感觉有点死锁的味道，就是A需要实例化的B才能完成实例化，而B而又需要实例化的A才能完成实例化，从而出现了循环依赖问题。PS：下面的源码解读会比较乱，就是看起来会感觉联系不起来，但是没关系可以先看一个眼熟，后面看我的流程图还有结合案例就能理解了。所以三级缓存的存在就是为了解决AOP代理，具体解决的AOP代理的循环依赖的流程如下图所示。是代理对象，则会将这个对象进行动态代理，返回其代理对象，否则返回前面实例化的。的实例化是一个AOP代理，则获取其代理对象，否则获取其半实例化对象。
Spring中单例bean注入多例bean的解决方法
lovesman的博客
08-24 2479
1、问题描述 在项目代码的使用过程，单例对象A中需要注入对象B。B对象要求是多例的。我们在对象B上添加注解“@Scope(“prototype”)”，代码运行过程中，发现A中注入的B对象始终是同一个，并没有实现多例的效果。 下面展示一些 内联代码片。 @Componment public class A { @Autowired private B b } 下面展示一些 内联代码片。 @Componment @Scope("prototype") public class B { .... } 2、
Spring单例Bean中注入多例Bean
weixin_33814685的博客
02-15 645
问题:当在一个单例Bean中注入一个多例Bean的时候,是获取不到那个多例对象的,因为,单例在初始化的时候,就直接初始化,这个多例Bean啦, 一直获取的是第一次初始化的Bean配置文件:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org...
Spring中Bean的单例、多例
热门推荐
longzhutengyue的博客
07-09 3万+
问题一： Spring哪里用到了单例？ 1 springboot 采用的是单例模式 2 @Component注解默认实例化的对象是单例，如果想声明成多例对象可以使用@Scope(“prototype”) @Component @Scope(“prototype”) 3 @Repository默认单例 4 @Service默认单例 5 @Controller默认多例 问题二：Spring单例Be...
Spring系列之单例bean中使用多例bean
azhou的代码园
04-29 2179
lookup-method：方法查找 通常情况下，我们使用的bean都是单例的，如果一个bean需要依赖于另一个bean的时候，可以在当前bean中声明另外一个bean引用，然后注入依赖的bean，此时被依赖的bean在当前bean中自始至终都是同一个实例。 先来个案例回顾一下 packagecom.javacode2018.lesson001.demo13.normal; publicclassServiceA{ } packagecom.javacode2018.lesson0...
Spring Bean的单例和多例配置
BASK2311的博客
01-04 1770
在Spring以及Spring Boot开发中，我们常常使用自动装配就可以完成一个类中字段的组装，这是非常方便的，这是因为Spring框架会自动地将特定的类（标注了@Component等注解的）自动实例化为Bean并自动处理其依赖关系，最后存入IoC容器，我们直接取出就可以使用了。，这究竟是什么意思呢？以及能否配置Bean为多例的呢？
Spring之bean对象
qq_66924116的博客
08-08 2642
目录一、了解Bean二、Bean的生命周期三、Bean的应用单例模式多例模式单例模式与多例模式优劣势： 什么是javaBean对象?----- Spring Bean的生命周期： 1）通过XML、Java annotation（注解）以及Java Configuration（配置类） 等方式加载Spring Bean2）BeanDefinitionReader：解析Bean的定义。在Spring容器启动过程中， 会将Bean解析成Spring内部的BeanDefinition结构； 理解为：将spring
Spring 注入多例 Bean
daodfs1的博客
11-14 5854
如何在单例 bean 中注入多例 Bean ？ 目录配置多例 Bean再来个单例 Bean错误示例方式一 使用 @Lookup方式二 使用 ObjectProvider@Lookup 的局限及 ObjectProvider 的强大使用 @Lookup 注入使用 ObjectProvider 注入结语 配置多例 Bean public interface ProtoService { void test1(); void test2(); } //使用 @Service 注册 @Service @
java 什么时候用单例_项目中什么时候用单例什么时候用多例？
weixin_39774644的博客
02-13 952
单例多例需要搞明白两个问题： 1. 什么是单例多例； 2. 如何产生单例多例； 3. 为什么要用单例多例 4. 什么时候用单例，什么时候用多例； 1. 什么是单例多例: 所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action; 2. 如何产生单例多例: 在通用的SSH中，单例在spring中是默...
Spring之bean单例与多例
djssubddbj的博客
08-18 487
bean是单例还是多例的，bean沉默是单例，但是他可以配置多例在Spring中，有两个类型，一个是单例一个和多例，一个Bean同学，要么是单例要么是多例。prototype（多例）和singleton（单例）在Spring中，bean的Scope常被定义的两种模式：prototype（多例）和singleton（单例）。singleton（单例）：只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例。此取值时表明容器中创建时只存在一个实例，所有引用此bean都是单一实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值