精华内容
下载资源
问答
  • 1.多例模式使用场景? 比如对商品的属性字段进行操作,此时属性对象的字段偏,在上下文引用过程中使用频次较时,使用多例模式会使代码更加优雅和高扩展 2.LookupContext 生产例对象的类 @Component public...

    1.多例模式使用场景?

    比如对sku(对象的字段偏多)的字段进行操作,在上下文引用过程中需要频繁使用sku的较多字段,使用多例模式会使代码更加优雅和扩展性更高

    2.LookupContext 生产多例对象的类

    @Component
    public abstract class LookupContext {
    
        @Lookup("skuContext")
        public abstract SkuContext skuContext();
    }
    

    3.SkuContext sku的上下文引用

    @Slf4j
    @Component
    @Scope(SCOPE_PROTOTYPE)
    public class SkuContext {
    
         // sku的属性组list
        List<Material> materialGroups;
     
        @Override
        public void wrapProcess(Sku sku) {
    
            this.materialGroups=sku.getMaterialGroups();
            log.info("属性:{}",materialGroups);
        }
    }

    4.SkuService sku的执行类

    @Slf4j
    public class SkuService {
    
        @Autowired
        private LookupContext lookupContext;
    
        
        void wrapProcess(Sku sku) {
    
            // 包装流程
            lookupContext.skuContext().wrapProcess(sku);
        }
    
      
    }

    5.总结

    如果后续需要对sku做个性化差异,继承SkuContext的类实现差异化,然后将多例注入到LookupContext中就行了。

    QQ交流群: 132312549

    展开全文
  • 这里牵扯到单利模式的线程安全的设计。 我们知道sping ioc注入的bean;一般都是无状态的【dao,service等,这种不会牵涉到值或者状态改变的情况】,也就是在线程下可以基本...1. 首先说下spring多例模式的两种配...

    这里牵扯到单利模式的线程安全的设计。

    我们知道sping ioc注入的bean;一般都是无状态的【dao,service等,这种不会牵涉到值或者状态改变的情况】,也就是在多线程下可以基本保证线程安全的;但是,有些情况下可能是有状态的;有状态的bean ,是要注意线程安全的;spring是有考虑到这方面的需求的;prototype 原型类型,应运而生;

    1. 首先说下spring多例模式的两种配置方式: 一个是代码添加注解的,一个是配置xml中bean的范围:

    1.1  xml配置:

     

    <bean id="virtualProductService" class="com.san.mpa.service.VirtualProductService" scope="prototype">

     

    1.2 注解配置:

     

    @Scope("prototype")
    public class CustInfoList extends HttpServlet {}

     

    2. 为什么要使用prototype,分析一下原因

    2.1有状态会话bean  

    每个用户有自己特有的一个实例,在用户的生存期内,bean保持了用户的信息,即“有状态”;一旦用户灭亡(调用结束或实例结束),bean的生命期也告结束。即每个用户最初都会得到一个初始的bean。 
     

    2.2无状态会话bean  

    bean一旦实例化就被加进会话池中,各个用户都可以共用。即使用户已经消亡,bean   的生命期也不一定结束,它可能依然存在于会话池中,供其他用户调用。由于没有特定的用户,那么也就不能保持某一用户的状态,所以叫无状态bean。但无状态会话bean   并非没有状态,如果它有自己的属性(变量),那么这些变量就会受到所有调用它的用户的影响,这是在实际应用中必须注意的。


    使用prototype后可以使并发调用在不同的实例中完成,不会产生线程安全的问题。

     

     

     

    展开全文
  • scope="“是标签的一个属性,作用是:控制对象的作用范围(单例、多例模式) 取值:scope=”"是标签的一个属性,作用是:控制对象的作用范围(单例、多例模式) 取值: singleton:默认值,单例模式; prototype: 例,...

    1、scope属性介绍:
    scope="“是标签的一个属性,作用是:控制对象的作用范围(单例、多例模式)
    取值:scope=”"是标签的一个属性,作用是:控制对象的作用范围(单例、多例模式)
    取值:
    singleton:默认值,单例模式;
    prototype: 多例,每次获取对象都会重新实例化;

    当时导入包spring-mvc和包spring-mvc-portlet可以使用下列值(web应用):
    request:当每次请求时实例化。
    session:当在一个session周期内,对象时单例的。
    globalSession:依赖包spring-mvc-portlet,类似于session.
    
    application:在一个application对象内是单例的。
    singleton:默认值,单例模式;
    prototype: 多例,每次获取对象都会重新实例化;
    
    当时导入包spring-mvc和包spring-mvc-portlet可以使用下列值(web应用):
    request:当每次请求时实例化。
    session:当在一个session周期内,对象时单例的。
    globalSession:依赖包spring-mvc-portlet,类似于session.
    
    application:在一个application对象内是单例的。
    

    所需包:
    在这里插入图片描述

    2、scope配置:
    Application.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"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
        <bean id="user" class="Model.User" scope="singleton">
            <aop:scoped-proxy/>
        </bean>
    </beans>
    

    3、单例模式底层实现模拟:
    3.1、 模拟单例模式 — 懒汉式

    **懒汉式的优点是:**1、提升运行效率;
    2、实现数据共享,例如application对象,application对象单例模式,在程序启动,对象实例化之后,程序结束之前,实例化的对象都可以实现共享。
    懒汉式的缺点是:使用了多线程锁机制,导致效率低。

    实现:

    package SingleTon;
    
    public class SingleTon {
    
        private static SingleTon singleTon;
    
        /**
         * 创建对象一般都是用new XX(),此处XX()是类对象的无参构造方法
         * 一般无参构造方法都public XX(){},但是单例模式使用private修饰构造方法,
         * 这样是为了不让其它类创建单例对象。
         *
         * 构造方法的两个条件:方法名与类名相同,没有返回值
         */
        private SingleTon(){
    
        }
    
        /**
         * 实例方法,使用实例方法创建对象,
         * 因为实例方法需要对象才能调用,然而构造方法时private修饰的,其他类不能使用,
         * 因此实例方法应该是静态的(static),使用public修饰,其他类可以使用,返回值要是类对象.
         *
         */
        public static SingleTon getInstance(){
            /**
             * 判断对象是否已经被创建,要有一个全局的类类型的参数
             * 静态方法不能使用非静态的变量,因此变量应该设置成静态的(static)
             */
            if(singleTon == null){
                /**
                 * 如果是多线程的,此处需要使用锁,所对象使用该类对象
                 * 例如:同时两个线程使用该对象,该对象还为实例化,此处如果不使用锁就会导致对象被重复实例化,不符合单例模式
                 */
                synchronized(SingleTon.class){
                    /**
                     * 双重验证,防止多线程重复实例化对象
                     *
                     * 使用锁缺点:效率较低。
                     */
                    if(singleTon == null){
                        new SingleTon();
                    }
                }
    
            }
            return singleTon;
        }
    }
    

    3.2、饿汉式:优点是解决了懒汉式效率低的缺点。

    package SingleTon;
    
    /***
     * 单例模式 -- 饿汉式
     */
    public class SingleTon2 {
        /**
         * 饿汉式构造方法、全局变量、实例方法都与懒汉式一样,区别在于饿汉式在全局变量处就已经实例化了对象
         * 饿汉式不用考虑多线程问题,解决了懒汉式效率低的问题。
         */
        private static SingleTon2 singleTon2 = new SingleTon2();
    
        /**
         * 构造方法
         */
        private SingleTon2(){}
    
        /**
         * 实例方法
         */
        public static SingleTon2 getInstance(){
            return singleTon2;
        }
    }
    

    3.3、测试方法:

    package SingleTon;
    public class Test {
        public static void main(String[] args) {
            SingleTon singleTon = SingleTon.getInstance();
            System.out.println(singleTon);
        }
    }
    
    展开全文
  • 今天聊聊单例和多例。只想看受spring管理的实例有哪些模式,直接看最后。相信大部分使用java 做web开发的开发人员都用过springspring功能最基础也是功能就是IoC(Inversion of control——控制反转)、AOP(Aspect ...

    今天聊聊单例和多例。只想看受spring管理的实例有哪些模式,直接看最后。

    相信大部分使用java 做web开发的开发人员都用过spring。spring功能最基础也是功能就是IoC(Inversion of control——控制反转)、AOP(Aspect Oriented Programming——面向切面编程)。其中IoC核心是DI(Dependency injection——依赖注入)。

    我们最开始写项目自然而然的是没有框架,生写!但代码多了之后,发现有很多代码,可以抽成公共方法。有些又可以抽成一个类。而有些类又是贯穿整个项目生命周期始终的,而且往往这些类的初始化方法很复杂且重要。那怎么办,总不能每次使用的时候初始化一遍吧,这样很耗编码时间不说,还很占用计算机性能。于是,工厂模式应运而生。通过工厂模式获取各个重要的实例对象。这样就带来一个问题,怎样保证实例只创建一次呢?单例模式应运而生。于是,我们常用的框架spring就成了。

    然而需求的发展往往不是单一技术能很好解决的。单例、依赖注入固然好。但是也让我们的开发模式陷入一种定式。及controller、service、dao这样虽然是快速规范的划分,但是往往一些复杂的逻辑只在service或者controller中写会有大量的私有方法、或者一个方法几百上千行。整个业务操作的声明周期局限在一个方法内。并不能好好利用面向对象的思想,写到最后完全就是面向过程编程。一旦逻辑复杂,那方法写的简直惨不忍睹,而且局限于方法的生命周期,很多参数可能会多次调用数据库查同一个数据。那么有什么办法能改变这个局面呢?历史总会给我们答案。

    自新世纪之初提出“领域驱动设计”(DDD)以来,这玩意一直不受重视,因为玄之又玄的理论很少有人去专研。但这里并不介绍DDD,说一说DDD的充血模型要在传统数据驱动的业务中使用将面临的首要问题——单例如何注入进充血模型。

    比如,我有个User对象,而对象的保存查询操作是与数据库操作。我并不想让User是一个干瘪的值对象,而是让他具备行为,是一个真正有血有肉的充血模型。那么saveUser(User)这样的方法就不再由Dao提供,而是又user.save()替代。熟悉JPA的同学肯定想到了。jpa支持对象操作替代传统的repository操作。例如典型的user中的List roles;属性作为关联查询的属性。如果设置为懒加载,那么jpa只在调用user.getRoles()方法执行的时候发送sql查询对应的role。

    但我们想要的不只是这些。我么可能有些其他的被sqring单例管理的对象方法需要在不同的实例对象中使用。例如:user想要发送数据到远程。那么user.send()可就不归jpa管了。此时如果要想让user能做这个事情必然只能让通过spring上下文获取被spring管理的类。聪明的小伙肯定想到了。我让user也被spring管理起来,不就可以注入了吗?是的,但是一旦被spring管理默认就是单例的。总不能每个user都是同一个吧。其实spring可以设置多例的,只是用的人很少。在加有@componet之类注解受spring管理的类上再加上注解@scope(“prototype”)那么被spring管理的类就是多例的。稍微麻烦点的是,要想获取多例必须通过spring上下文获取。如果直接注入,那么注入的user还是只是那一个。相信各位一定都看过@scope(“prototype”)这种写法吧。但spring其实提供了常量,@scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)也是多例,但可以防止写错那长串单次。有了多例,我们有血有肉的User对象写起来就方便了许多。

    spring支持的模式:

    1.ConfigurableBeanFactory.SCOPE_SINGLETON——单例

    2.ConfigurableBeanFactory.SCOPE_PROTOTYPE——多例

    扩展模式:

    3.WebApplicationContext.SCOPE_APPLICATION

    4.WebApplicationContext.SCOPE_GLOBAL_SESSION

    5.WebApplicationContext.SCOPE_SESSION

    6.WebApplicationContext.SOCPE_REQUEST

    以上扩展模式看名字都能明白不做多介绍了。

    展开全文
  • spring通过注解的方式使用多例模式

    千次阅读 2020-10-20 21:00:12
    spring通过注解的方式使用多例模式 说明:spring容器实例化对象时默认使用单例模式,初学时也知道实现多例模式可以在容器文件中给bean添加prototype,再通过applicationContext获取不同的实例。 那么,如何只使用...
  • Spring的单例模式和多例模式

    万次阅读 多人点赞 2018-06-03 21:14:17
    spring的Bean默认的是单例的,Bean的作用域可以通过Bean标签的scope属性进行设置,Bean的作用域包括:默认情况下scope="singleton",那么该Bean是单例,任何人获取该Bean实例的都为同一个实例;scope=&...
  • Spring中,bean可以被定义为两种模式:prototype(多例)和singleton(单例) singleton(单例):只有一个共享的实例存在,所有对这个bean的请求都会返回这个唯一的实例。 prototype(多例):对这个bean的每次...
  • Spring 的单例模式和多例模式

    千次阅读 2018-03-14 19:33:23
    Spring中,Bean的scope属性中存在着两种模式既单例模式(singleton)和多例模式(prototype)。 singleton 单例模式: 对象在整个系统中只有一份,所有的请求都用一个对象来处理,如service和dao层的对象一般是...
  • 文章目录自定义初始化 销毁方法意义编辑实体类编辑xml编辑测试类运行结果单例模式单例模式定义编写测试类运行结果多例模式多例模式定义编写实体类编辑xml配置文件编写测试类运行结果懒加载懒加载定义懒加载优点懒...
  • 1、声明方式 @Component @Scope("prototype") public class DemoPrototype { ... } 2、其它类要注入改类时 ...对象进行注入(T为你要注入的类),想要使用该多例对象时,用 T t = objectFactory.getObject();
  • Spring中默认生成的bean是全局的而且将只有一个实例,测试代码如下: @Configuration public class GlobalConfig { @Bean public ThreadPoolTaskExecutor defaultThreadPool(){ ThreadPoolTaskExecutor executor=...
  • Spring的配置中,Bean的scope属性中存在两种模式:singleton(单例模式)、prototype(多例模式)  singleton 单例模式:对象在整个系统中只有一份,所有的请求都用一个对象来处理,如service和dao层的对象一般是...
  • spring生成对象默认是单例的。通过scope属性可以更改为多例。 bean id="user" class="modle.User" scope="prototype"> bean> 现在又这么一种情况. User类调用一个service, 这个service
  • spring 什么时候使用单例和多例

    千次阅读 2020-12-25 08:27:40
    一、单例模式和多例模式说明: 单例模式和多例模式属于对象模式。 单例模式的对象在整个系统中只有一份,多例模式可以有个实例。 它们都不对外提供构造方法,即构造方法都为私有。 单例适用场景: 4...
  • Spring框架-Bean作用域中单例模式多例模式的区别 一、单例模式的特点(当没有指定是单例模式还是多例模式的时候,默认是单例模式): 1、Spring容器创建的时候,对应的类的实例化对象一起被创建。 2、不管获取多少...
  • Spring中单例模式下存在例对象的处理方法标签(空格分隔): Spring在日常的开发过程中,在使用Spring时主要使用IOC/DI、AOP特性,通常在IOC容器中,对象默认的作用域scope属性都是singleton类型,也就是单例模式...
  • spring有单例模式和多例模式,首先单例模式是什么呢? 单例模式:不管获取对象几次,每次getBean都是同一个实例。 单例模式又分为懒汉模式和饿汉模式。 饿汉模式:在加载对象时候,对象就会创建实例,为所有...
  • 刚刚看了spring 想到一个问题 在xml配置中,具体什么时候用单例 什么时候用多例
  • Spring 实例注入

    千次阅读 2020-02-22 12:37:28
    Spring 实例注入的应用2. Spring 实例注入的使用 1. Spring 实例注入的应用 Spring 容器中保存的 bean 默认是单例的,通常来说这样做可以降低 bean 对象创建的频率,在某些访问量大的场景下可以节省对象创建...
  • 为什么用单例或者多例?何时用? 之所以用单例,是因为没必要每个请求都新建一个对象,这样子既浪费CPU又浪费内存; 之所以用多例,是为了防止并发问题;即一个请求改变了对象的状态,此时对象又处理另一个请求,而...
  • (1)在配置完spring提示框架后(上一遍文章有介绍),首先创建一个项目,导入sprig所需的jar包然后书写主配置文件applicationContext.&lt;?xml version="1.0" encoding="UTF-8"?&gt; &...
  • 为什么spring单例模式可以支持线程并发访问
  • spring如何开启bean的多例模式

    千次阅读 2020-06-12 14:56:47
    @Component @Service等这些注解默认是单例模式,在spring初始化的时候建立对象, 想使用多例模式时,多加一个@Scope(“prototype”)注解,就成了多例模式,在使用对象的时候初始化对象。
  • Spring mvc的单例和多例性能

    千次阅读 2016-08-25 14:36:26
    推荐博文:Java单例和多例的性能spring mvc 单例业务类import org.springframework.stereotype.Service;@Service public class SpringSingleService { public void doSomething(){ try { Thread.sleep(1);
  • Spring所管理的对象,默认都是单例的,在配置时,通过scope属性可以配置是否单例,默认取值为singleton,当取值为prototype时,是非单例的! <bean id="student" class="cn.tedu.spring.Student" scope=...
  • 主要介绍了springboot prototype设置多例不起作用的解决操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了SpringBoot项目使用线程处理任务时无法通过@Autowired注入bean问题的解决方法,需要的朋友可以参考下
  • ```java /** * 在spring的配置文件中 * init-method="init" ... * * 当该bean为多例时,spring容器不负责容器的销毁工作 * * 如果该bean为多例时,当不用该bean时应该手动的销毁 */.
  • Spring bean配置单例或多例模式

    千次阅读 2018-10-17 19:02:03
    spring bean 默认是单例默认,在对应.xml文件中的配置是: &lt;bean id="user" class="..." scope="singleton"/&gt; singleton就是配置这个bean是否是单例的,如果不写,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,908
精华内容 29,163
关键字:

spring多例模式

spring 订阅