精华内容
下载资源
问答
  • 编程第一件事情,就是对象的生命周期管理问题。有多少人的习惯,能够做到哪里创建,哪里释放? 1.想象力. 2.实现想象的能力. 3.学习能力. 如果只是一个普通的程序员,那么算法并不是最重要的 如果要成为...

    编程中第一件事情,就是对象的生命周期管理问题。有多少人的习惯,能够做到哪里创建,哪里释放?

    1.想象力.
    2.实现想象的能力.
    3.学习能力.

    如果只是一个普通的程序员,那么算法并不是最重要的
    如果要成为大师级人物,熟悉并且掌握各种算法是必须的

    一篇优秀程序员的一些性质,读完估计你就明白区别在哪里了。

    在这个世界上,有数百万的人热衷于软件开发,他们有很多名字,如:软件工程师(Software

    Engineer),程序员(Programmer),编码人(Coder),开发人员(Developer)。经过一段时间后,

    这些人能够成为一个优秀的编码人员,他们非常熟悉如何用计算机语言来完成自己的工作。但是,如果

    你要成为一个优秀的程序员,你还可以需要有几件事你需要注意,如果你能让下面十个条目成为你的习

    惯,那么你才能真正算得上是优秀程序员。

    1. 学无止境。就算是你有了10年以上的程序员经历,你也得要使劲地学习,因为你在计算机这个充满一

    创造力的领域,每天都会有很多很多的新事物出现。你需要跟上时代的步伐。你需要去了解新的程序语

    言,以及了解正在发展中的程序语言,以及一些编程框架。还需要去阅读一些业内的新闻,并到一些热

    门的社区去参与在线的讨论,这样你才能明白和了解整个软件开发的趋势。在国内,一些著名的社区例

    如:CSDN,ITPUB,CHINAUINX等等,在国外,建议你经常上一上digg.com去看看各种BLOG的聚合。


    2. 掌握多种语言。程序语言总是有其最适合的领域。当你面对需要解决的问题时,你需要找到一个最适

    合的语言来解决这些问题。比如,如果你需要性能,可能C/C++是首选,如果你需要跨平台,可能Java是

    首选,如果你要写一个Web上的开发程序,那么PHP,ASP,Ajax,JSP可能会是你的选择,如果你要处理

    一些文本并和别的应用交互,可能Perl, Python会是最好的。所以,花一些时间去探索一下其它你并熟

    悉的程序语言,能让你的眼界变宽,因为你被武装得更好,你思考问题也就更为全面,这对于自己和项

    目都会有好的帮助。

    3. 理性面对不同的操作系统或技术。程序员们总是有自己心目中无可比拟的技术和操作系统,有的人喜

    欢Ubuntu,有的人喜欢Debian,还有的人喜欢Windows,以及FreeBSD,MacOSX或Solaris等等。只有一部

    分优秀的程序员明白不同操作系统的优势和长处和短处,这样,在系统选型的时候,才能做到真正的客

    观和公正,而不会让情绪影响到自己。同样,语言也是一样,有太多的程序员总是喜欢纠缠于语言的对

    比,如:Java和Perl。哪个刚刚出道的程序员没有争论去类似的话题呢?比如VC++和Delphi等等。争论

    这些东西只能表明自己的肤浅和浮燥。优秀的程序并不会执着于这些,而是能够理性的分析和理心地面

    对,从而才能客观地做出正确的选择。

    4. 别把自己框在单一的开发环境中。 再一次,正如上面所述,每个程序员都有自己忠爱的工具和技术

    ,有的喜欢老的(比如我就喜欢Vi编辑程序),而有的喜欢新的比如gedit或是Emacs等。有的喜欢使用

    像VC++一样的调试器,而我更喜欢GDB命令行方面的调式器。等等等等。程序员在使用什么样的工具上的

    争论还少吗?到处都是啊。使用什么样的工具本来无所谓,只要你能更好更快地达到你的目的。但是有

    一点是优秀程序员都应该了解的——那就是应该去尝试一下别的工作环境。没有比较,你永远不知道谁

    好谁不好,你也永远不知道你所不知道的。

    5. 使用版本管理工具管理你的代码。千万不要告诉我你不知道源码的版本管理,如果你的团队开发的源

    代码并没有版本管理系统,那么我要告诉你,你的软件开发还处于石器时代。赶快使用一个版式本管理

    工具吧。CVS 是一个看上去平淡无奇的版本工具,但它是被使用最广的版本管理系统,Subversion 是

    CVS的一个升级版,其正在开始接管CVS的领地。Git 又是一个不同的版本管理工具。还有Visual

    SourceSafe等。使用什么样的版本管理工具依赖于你的团队的大小和地理分布,你也许正在使用最有效

    率或最没有效率的工具来管理你的源代码。但一个优秀的程序员总是会使用一款源码版本管理工具来管

    理自己的代码。如果你要我推荐一个,我推荐你使用开源的Subversion。

    6. 是一个优秀的团队成员。 除非你喜欢独奏,除非你是孤胆英雄。但我想告诉你,今天,可能没有一

    个成熟的软件是你一个人能做的到的,你可能是你团队中最牛的大拿,但这并不意味着你就是好的团队

    成员。你的能力只有放到一个团队中才能施展开来。你在和你的团队成员交流中有礼貌吗?你是否经常

    和他们沟通,并且大家都喜欢和你在一起讨论问题?想一想一个足球队吧,你是这个队中好的成员吗?

    当别人看到你在场上的跑动,当别人看到你的传球和接球和抢断,能受到鼓舞吗?

    7. 把你的工作变成文档。 这一条目当然包括了在代码中写注释,但那还仅仅不够,你还需要做得更多

    。有良好的注释风格的代码是一个文档的基础,他能够让你和你的团队容易的明白你的意图和想法。写

    下文档,并不仅仅是怕我们忘了当时的想法,而且还是一种团队的离线交流的方法,更是一种知识传递

    的方法。记录下你所知道的一切会是一个好的习惯。因为,我相信你不希望别人总是在你最忙的时候来

    打断你问问题,或是你在休假的时候接到公司的电话来询问你问题。而你自己如果老是守着自己的东西

    ,其结果只可能是让你自己长时间地深陷在这块东西内,而你就更本不可以去做更多的事情。包括向上

    的晋升。你可能以为“教会徒弟能饿死师父”,但我告诉你,你的保守会让你失去更多更好的东西,请

    你相信我,我绝不是在这里耸人听闻。

    8. 注意备份和安全。 可能你觉得这是一个“废话”,你已明白了备份的重要性。但是,我还是要在这

    里提出,丢失东西是我们人生中的一部份,你总是会丢东西,这点你永远无法避免。比如:你的笔记本

    电脑被人偷了,你的硬盘损坏了,你的电脑中病毒了,你的系统被人入侵了,甚至整个大楼被烧了,等

    等,等等。所以,做好备份工作是非常非常重要的事情,硬盘是不可信的,所以定期的刻录光盘或是磁

    带可能会是一个好的方法,网络也是不可信的,所以小心病毒和黑客,不但使用软件方面的安全策略,

    你更需要一个健全的管理制度。此外,尽量的让你的数据放在不同的地方,并做好定期(每日,每周,

    每月)的备份策略。

    9. 设计要足够灵活。 可能你的需求只会要求你实现一个死的东西,但是,你作为一个优秀的程序,你

    应该随时在思考这个死的东西是否可以有灵活的一面,比如把一些参数变成可以配置的,把一些公用的

    东西形成你的函数库以便以后重用,是否提供插件方面的功能?你的模块是否要以像积木一样随意组合

    ?如果要有修改的话,你的设计是否能够马上应付?当然,灵活的设计可能并不是要你去重新发明轮子

    ,你应该尽可能是使用标准化的东西。所谓灵话的设计就是要让让考虑更多需求之外的东西,把需求中

    这一类的问题都考虑到,而不是只处理需求中所说的那一特定的东西。比如说,需要需要的屏幕分辨率

    是800×600,那么你的设计能否灵活于其他的分辨率?程序设计总是需要我们去处理不同的环境,以及

    未来的趋势。我们需要用动态的眼光去思考问题,而不是刻舟求剑。也许有一天,你今天写的程序就要

    移植到别的环境中去,那个时候你就能真正明白什么是灵活的设计了。

    10. 不要搬起石头砸自己的脚。程序员总是有一种不好的习惯,那就是总是想赶快地完成自己手上的工

    作。但情况却往往事已愿违。越是想做得快,就越是容易出问题,越是想做得快,就越是容易遗漏问题

    ,最终,程序改过来改过去,按下葫芦起了瓢,最后花费的时间和精力反而更多。欲速而不达。优秀程

    序员的习惯是前面多花一些时间多作一些调查,试验一下不同的解决方案,如果时间允许,一个好的习

    惯是,每4个小时的编程,需要一个小时的休息,然后又是4个小时的编码。当然,这因人而异,但其目

    的就是让你时常回头看看,让你想一想这样三个问题:1)是否这么做是对的?2)是否这么做考虑到了

    所有的情况?3)是否有更好的方法?想好了再说,时常回头看看走过的路,时常总结一下过去事,会对

    你有很大的帮助。

    展开全文
  • 接口面向对象中是一个非常重要的概念。接口可以理解成我们日常所准守的管理规定或是国家的法律法规。一个公司要想便于管理就必须有管理规定来管理各种行为,这些行为准则就是接口现实生活中的实际应用。我们到一...

    我们都知道面向对象语言的三大特征是:封装、继承、多态。其中的多态就是靠接口实现的。接口在面向对象中是一个非常重要的概念。接口可以理解成我们日常所准守的管理规定或是国家的法律法规。一个公司要想便于管理就必须有管理规定来管理各种行为,这些行为准则就是接口在现实生活中的实际应用。我们到一个公司以后,公司怎么规定,我们就怎么做事。

    接口就是统一的行为规定,派生类就是按照接口规定的要求来具体做事的(后续文章会讲到)。

    本文最后有项目代码,有需要可自行下载

    下面我们就学习一下C#中接口的用法,还是老方法,要想会使用就必须想会语法,接口定义的关键字是:Interface,所以我们先来看看接口的语法定义:

    interface 接口名
    {
        //接口成员
        void 方法名();
    }

    接口里可以定义属性、方法和事件。

    例如:

    interface IWork
    {
        //上班
        void StartWork();
        //下班
        void OffWork();
    }

    以上代码定义了接口 IWork。通常接口以 I 字母开头,这个接口写了两个方法StartWork()和OffWork(),没有参数和返回值,当然我们可以按照需求设置参数和返回值。

    注意:该方法并没有具体的实现

    接口实现

    接下来我们来实现上面定义的接口,我们在定义个类:Company(公司)的类

    //我们使用冒号(:)来继承接口,并实现接口定义的两个方法StartWork,OffWork
    pulice class Company:IWord
    {
        static void Main()
        {
            Company company = new Company();
            company.StartWork();
            company.OffWork();
        }
    
        //实现接口里定义的StartWork方法
        public void StartWork()
        {
            Console.WriteLine("8:00了,现在开始工作了!");
        }
    
        //实现接口里定义的OffWork方法
        public void OffWork()
        {
            Console.WriteLine("5:30了,工作一天,您辛苦了,现在下班了!");
        }
    }

    输出结果

    8:00了,现在开始工作了!
    5:30了,工作一天,您辛苦了,现在下班了!

    接口继承

    在日常生活中会存在多种情况下的规定,这也就是说程序里也可以定义多个接口,并且接口是可以继承接口的

    
    //个人需求接口
    interface INeed:IWork
    {
        //吃饭
        void Eat();
        //睡觉
        void Sleep();
    }

    接下来我们来实现INeed接口,我们还用公司类(Company)

    //我们使用冒号(:)来继承接口,并实现接口定义的两个方法StartWork,OffWork
    pulice class Company:INedd
    {
        static void Main()
        {
            Company company = new Company();
            company.StartWork();
            company.OffWork();
            company.Eat();
            company.Sleep();
        }
    
        //实现接口里定义的StartWork方法
        public void StartWork()
        {
            Console.WriteLine("8:00了,现在开始工作了!");
        }
    
        //实现接口里定义的OffWork方法
        public void OffWork()
        {
            Console.WriteLine("5:30了,工作一天,您辛苦了,现在下班了!");
        }
    
        //实现个人需求接口中的方法
        public void Eat()
        {
            Console.WriteLine("下班了可以去掐饭了,太好了!");
        }
        
        //实现个人需求接口中的方法
        public void Sleep()
        {
            Console.WriteLine("有点困了,睡会吧!");
        }
    }

    从上面实现的过程来看,一个接口继承了另一个接口后,那么继承最终接口的类或结构就必须实现所有接口中的成员方法。

    输出结果

    8:00了,现在开始工作了!
    5:30了,工作一天,您辛苦了,现在下班了!
    下班了可以去掐饭了,太好了!
    有点困了,睡会吧!

    点此下载源码

    展开全文
  • 4. 新增客户时,重要的客户资料不允许为空,避免销售人员抢占客户; 5. 重要客户要填写备忘录,销售人员可随时查看; 6. 销售人员可非常方便的查看自己的工作清单,可查看任一时段自己的工作清单; 7. 自动提醒 ...
  • 别再找了,这就是全网SpringBean作用域管理!

    千次阅读 多人点赞 2020-09-16 05:40:23
    可以控制要插入到从特定 BeanDefinition 创建的对象中的各种依赖项和配置值 可以控制从特定 BeanDefinition 创建对象作用域。 这种方式功能强大且灵活,因为开发者可以选择通过配置创建对象作用域,而不必...

    创建 BeanDefinition 时,就等于创建了一个配方,用于创建由 BeanDefinition 所定义的类实例。BeanDefinition 是配方的这种思想很重要,因为这意味着,与使用类一样,也可通过一个配方创建多个对象实例。

    有如下优点:

    • 可以控制要插入到从特定 BeanDefinition 创建的对象中的各种依赖项和配置值
    • 可以控制从特定 BeanDefinition 创建的对象的作用域。

    这种方式功能强大且灵活,因为开发者可以选择通过配置创建的对象的作用域,而不必在Java类级别上考虑对象的范围。

    Spring 支持哪些作用域呢?

    Spring支持如下六种作用域,其中四种只有在使用可识别Web的 ApplicationContext 时才可用。

    作用域 描述
    singleton

    当然了,作为灵活的框架,Spring 还允许开发者创建自定义的作用域。

    详细介绍下 singleton 作用域?

    仅管理一个singleton bean的一个共享实例,并且所有对具有ID或与该 BeanDefinition 相匹配的ID的bean的请求都将导致该特定的bean实例由Spring容器返回。

    换言之,当我们定义了一个 BeanDefinition 并且其作用域为 singleton 时,IoC容器将为该 BeanDefinition 所定义的对象创建一个实例。该单实例存储在此类单例bean的缓存中,并且对该命名bean的所有后续请求和引用都返回该缓存的对象。

    和单例模式有何联系去区别呢?

    Spring的 singleton bean概念与传说中的四人帮创建的《Gang of Four (GoF) patterns》一书中定义的单例模式并不一样。

    • GoF的单例模式会硬编码对象的作用域,使得每个类加载器只能创建一个特定类的唯一实例
    • 因此,最恰当的应该将Spring单例的作用域描述为一个容器对应一个bean。若我们在单个Spring容器中为特定类定义一个bean,则Spring容器将创建该 BeanDefinition 所定义的类的一个且只有一个实例。

    单例作用域是Spring中的默认作用域。要将bean定义为XML中的单例,可以定义bean,如以下示例所示:

    Prototype作用域

    Bean部署的非单一原型作用域会在每次请求特定bean时创建一个新bean实例。也就是说,该Bean被注入到另一个Bean中,或者您可以通过容器上的getBean()方法调用来请求它。通常,应将原型作用域用于所有有状态Bean,将单例作用域用于无状态Bean。

    下图说明了Spring原型范围

    前言

    在 Spring 中,那些组成应用程序的主体及由 Spring IOC 容器所管理的对象,被称之为 bean。
    简单地讲,bean 就是由 IOC 容器初始化、装配及管理的对象,除此之外,bean 就与应用程序中的其他对象没有什么区别了。
    而 bean 的定义以及 bean 相互间的依赖关系将通过配置元数据来描述。

    Spring中的bean默认都是单例的,这些单例Bean在多线程程序下如何保证线程安全呢?

    例如对于Web应用来说,Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求,引入Spring框架之后,每个Action都是单例的,那么对于Spring托管的单例Service Bean,如何保证其安全呢?

    • Spring的单例是基于BeanFactory也就是Spring容器的,单例Bean在此容器内只有一个
    • Java的单例是基于 JVM,每个 JVM 内只有一个实例

    1 bean的作用域

    创建一个bean定义,其实质是用该bean定义对应的类来创建真正实例的“配方”。
    把bean定义看成一个配方很有意义,它与class很类似,只根据一张“处方”就可以创建多个实例。
    不仅可以控制注入到对象中的各种依赖和配置值,还可以控制该对象的作用域。
    这样可以灵活选择所建对象的作用域,而不必在Java Class级定义作用域。

    • Spring Framework支持五种作用域,分别阐述如下表。

    五种作用域中,request、sessionglobal session 三种作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于 web 的 Spring ApplicationContext 环境。

    2 singleton —— 唯一 bean 实例

    当一个 bean 的作用域为 singleton,那么Spring IoC容器中只会存在一个共享的 bean 实例,并且所有对 bean 的请求,只要 id 与该 bean 定义相匹配,则只会返回bean的同一实例。
    singleton 是单例类型(对应于单例模式),就是在创建起容器时就同时自动创建了一个bean的对象,不管你是否使用,但我们可以指定Bean节点的 lazy-init=”true” 来延迟初始化bean,这时候,只有在第一次获取bean时才会初始化bean,即第一次请求该bean时才初始化。
    每次获取到的对象都是同一个对象。注意,singleton 作用域是Spring中的缺省作用域。要在XML中将 bean 定义成 singleton ,可以这样配置:

    <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
    

    也可以通过 @Scope 注解(它可以显示指定bean的作用范围。)的方式

    @Service
    @Scope("singleton")
    public class ServiceImpl{
    
    }
    

    3 prototype——每次请求都会创建一个新的 bean 实例

    当一个bean的作用域为 prototype,表示一个 bean 定义对应多个对象实例。

    prototype 作用域的 bean 会导致在每次对该 bean 请求(将其注入到另一个 bean 中,或者以程序的方式调用容器的 getBean() 方法)时都会创建一个新的 bean 实例。prototype 是原型类型,它在我们创建容器的时候并没有实例化,而是当我们获取bean的时候才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。

    对有状态的 bean 应该使用 prototype 作用域,而对无状态的 bean 则应该使用 singleton 作用域。

    在 XML 中将 bean 定义成 prototype

    <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
     或者
    <bean id="account" class="com.foo.DefaultAccount" singleton="false"/> 
    

    通过 @Scope 注解的方式实现就不做演示了。

    4 request——每一次HTTP请求都会产生一个新的bean

    该bean仅在当前HTTP request内有效

    request只适用于Web程序,每一次 HTTP 请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效,当请求结束后,该对象的生命周期即告结束。
    在 XML 中将 bean 定义成 request ,可以这样配置:

    <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>
    

    5 session——每一次HTTP请求都会产生一个新的 bean

    该bean仅在当前 HTTP session 内有效。

    session只适用于Web程序,session 作用域表示该针对每一次 HTTP 请求都会产生一个新的 bean,同时该 bean 仅在当前 HTTP session 内有效.与request作用域一样,可以根据需要放心的更改所创建实例的内部状态,而别的 HTTP session 中根据 userPreferences 创建的实例,将不会看到这些特定于某个 HTTP session 的状态变化。当HTTP session最终被废弃的时候,在该HTTP session作用域内的bean也会被废弃掉。

    <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
    

    6 globalSession

    global session 作用域类似于标准的 HTTP session 作用域,不过仅仅在基于 portlet 的 web 应用中才有意义。Portlet 规范定义了全局 Session 的概念,它被所有构成某个 portlet web 应用的各种不同的 portle t所共享。在global session 作用域中定义的 bean 被限定于全局portlet Session的生命周期范围内。

    <bean id="user" class="com.foo.Preferences "scope="globalSession"/>
    

    Spring框架支持5种作用域,有三种作用域是当开发者使用基于web的ApplicationContext的时候才生效的

    下面就是Spring内置支持的作用域

    作用域 描述
    单例(singleton) (默认)每一个Spring IoC容器都拥有唯一的一个实例对象
    原型(prototype) 一个Bean定义可以创建任意多个实例对象
    请求(request) 一个HTTP请求会产生一个Bean对象,也就是说,每一个HTTP请求都有自己的Bean实例。只在基于web的Spring ApplicationContext中可用
    会话(session) 限定一个Bean的作用域为HTTPsession的生命周期。同样,只有基于web的Spring ApplicationContext才能使用
    全局会话(global session) 限定一个Bean的作用域为全局HTTPSession的生命周期。通常用于门户网站场景,同样,只有基于web的Spring ApplicationContext可用
    应用(application) 限定一个Bean的作用域为ServletContext的生命周期。同样,只有基于web的Spring ApplicationContext可用

    在Spring 3.0中,线程作用域是可用的,但不是默认注册的

    1 singleton

    全局只有一个共享的实例,所有将单例Bean作为依赖的情况下,容器返回将是同一个实例

    换言之,当开发者定义一个Bean的作用域为单例时,Spring IoC容器只会根据Bean定义来创建该Bean的唯一实例。这些唯一的实例会缓存到容器中,后续针对单例Bean的请求和引用,都会从这个缓存中拿到这个唯一的实例

    1.1 单例Bean和单例模式

    • 单例模式是将一个对象的作用域硬编码,一个ClassLoader只有唯一的一个实例
    • 而Spring的单例作用域,是基于每个容器,每个Bean只有一个实例
      这意味着,如果开发者根据一个类定义了一个Bean在单个的Spring容器中,那么Spring容器会根据Bean定义创建一个唯一的Bean实例。默认情况下,它们为每个给定的org.springframework.context.ApplicationContext实例存在唯一的一个bean (有点别扭,也就是可以有多个Spring容器,每一个容器内存在唯一bean实例).这意味着如果你有两个或更多上下文,所有这些上下文都由同一Java的类加载器管理(因为在同一个jvm环境中),则可能会有多个给定bean的实例。唯一需要做到的是必须在每个上下文中定义此bean.

    所以你可以看到,bean只是一个上下文的单例
    你不应该将Spring的单例概念与设计模式中的的单例混淆

    单例作用域是Spring的默认作用域,下面的例子是在基于XML的配置中配置单例模式的Bean。

    <bean id="accountService" class="com.sss.DefaultAccountService"/>
    
    <!-- the following is equivalent, though redundant (singleton scope is the default) -->
    <bean id="accountService" class="com.sss.DefaultAccountService" scope="singleton"/>
    
    

    2 prototype

    每次请求Bean实例时,返回的都是新实例的Bean对象
    也就是说,每次注入到另外的Bean或者通过调用getBean()来获得的Bean都将是全新的实例。
    这是基于线程安全性:

    • 有状态的Bean对象用prototype 作用域
    • 无状态的Bean对象用singleton 作用域

    下面的例子说明了Spring的原型作用域。DAO通常不会配置为原型对象,因为典型的DAO是不会有任何的状态的。

    下面的例子展示了XML中如何定义一个原型的Bean:

    <bean id="accountService" 
    	class="com.javaedge.DefaultAccountService" scope="prototype"/>
    

    与其他的作用域相比,Spring不会完全管理原型Bean的生命周期:
    Spring容器只会初始化配置以及装载这些Bean,传递给Client。
    但是之后就不会再去管原型Bean之后的动作了。

    也就是说,初始化生命周期回调方法在所有作用域的Bean是都会调用的,但是销毁生命周期回调方法在原型Bean是不会调用的

    所以,客户端代码必须注意清理原型Bean以及释放原型Bean所持有的一些资源。
    可以通过使用自定义的bean post-processor来让Spring释放掉原型Bean所持有的资源。

    在某些方面来说,Spring容器的角色就是取代了Java的new操作符,所有的生命周期的控制需要由客户端来处理。

    2-1 Singleton beans with prototype-bean dependencies

    在原型bean中放置单例

    如果注入的单例对象真的是一个单例的bean(没有状态),这个真的没一点问题
    想象一下,对于我们的购物车,我们需要注入产品服务。此服务只会检查添加到购物车的产品是否库存。由于服务没有状态,并且会基于在方法签名中所传递的对象进行验证,因此不存在风险

    当使用单例Bean的时候,而该单例Bean的依赖是原型Bean时,需要注意的是依赖的解析都是在初始化的阶段
    因此,如果将原型Bean注入到单例的Bean之中,只会请求一次原型Bean,然后注入到单例Bean中。这个依赖的原型Bean仍然属于只有一个实例的。

    然而,假设你需要单例Bean对原型的Bean的依赖
    需要每次在运行时都请求一个新的实例,那么你就不能够将一个原型的Bean来注入到一个单例的Bean当中了,因为依赖注入只会进行一次
    当Spring容器在实例化单例Bean的时候,就会解析以及注入它所需的依赖
    如果实在需要每次都请求一个新的实例,可以通过bean工厂手动获取实例,也可以参考Dependencies中的方法注入部分。
    ##使用单例还是原型?

    • Singleton适用于无状态的bean,比如一个service,DAO或者controller
      他们都没有自己的状态(举个简单的例子,一个函数sin(x),这个函数本身就是无状态的,所以我们现在喜欢的函数式编程也遵循这个理念)。而是根据传输的参数执行一些操作(作为HTTP请求参数)。
    • 另一方面,我们可以通过状态bean管理一些状态。比如购物车bean,假如它是一个单例,那么两个不同消费者购买的产品将被放置在同一个对象上。而如果其中一个消费者想要删除一个产品,另一个消费者就铁定不高兴。这也就是状态类对象应该是原型
      #3. Request
      Spring容器会在每次用到loginAction来处理每个HTTP请求的时候都会创建一个新的LoginAction实例。也就是说,loginActionBean的作用域是HTTPRequest级别的。 开发者可以随意改变实例的状态,因为其他通过loginAction请求来创建的实例根本看不到开发者改变的实例状态,所有创建的Bean实例都是根据独立的请求来的。当请求处理完毕,这个Bean也会销毁。

      每个请求初始化具有此作用域的Bean注解。这听起来像是原型作用域的描述,但它们有一些差异。
    • 原型作用域在Spring的上下文中可用。而请求作用域仅适用于Web应用程序
    • 原型bean根据需求进行初始化,而请求bean是在每个请求下构建的

    需要说的是,request作用域bean在其作用域内有且仅有一个实例。而你可以拥有一个或多个原型作用域bean实例

    在以下代码中,你可以看到请求作用域bean的示例:

    <bean id="shoppingCartRequest" class="com.sss.scope.ShoppingCartRequest" scope="request">
        <aop:scoped-proxy/> 
    </bean>
    

    当使用注解驱动组件或Java Config时,@RequestScope注解可以用于将一个组件分配给request作用域。

    @RequestScope
    @Component
    public class ShoppingCartRequest {
    	// ...
    }
    // request bean
     
    // injection sample
    @Controller
    public class TestController {
        @Autowired
        private ShoppingCartRequest shoppingCartRequest;
         
        @RequestMapping(value = "/test", method = RequestMethod.GET)
        public String test(HttpServletRequest request) {
            LOGGER.debug("shoppingCartRequest is :"+shoppingCartRequest);
            // ...
        }
    }
    

    请注意定义内存在的<aop: scoped-proxy />标签。这代表着使用代理对象。所以实际上,TestController持有的是代理对象的引用。我们所有的调用该对象都会转发到真正的ShoppingCartRequest对象。

    有时我们需要使用DispatcherServlet的另一个servlet来处理请求。在这种情况下,我们必须确保Spring中所有请求都可用(否则可以抛出与下面类似的异常)。为此,我们需要在web.xml中定义一个监听器:

    <listener>   
      <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>
    

    调用/测试URL后,你应该能在日志中的发现以下信息:

    shoppingCartRequest is :com.migo.scope.ShoppingCartRequest@2586b11c
    shoppingCartRequest is :com.migo.scope.ShoppingCartRequest@3bd5b945
    

    如果我们尝试在单例bean中使用request作用域的bean,则会在应用程序上下文加载阶段抛出一个BeanCreationException
    #4. session
    参考如下的Bean定义:

    <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>
    
    

    Spring容器会在每次调用到userPreferences在一个单独的HTTP会话周期来创建一个新的UserPreferences实例。换言之,userPreferencesBean的作用域是HTTPSession级别的。 在request-scoped作用域的Bean上,开发者可以随意的更改实例的状态,同样,其他的HTTPSession基本的实例在每个Session都会请求userPreferences来创建新的实例,所以开发者更改Bean的状态,对于其他的Bean仍然是不可见的。当HTTPSession销毁了,那么根据这个Session来创建的Bean也就销毁了。


    Session作用域的bean与request 作用域的bean没有太大不同。它们也与纯Web应用程序上下文相关联。注解为Session作用域的Bean对于每个用户的会话仅创建一次。他们在会话结束时被破坏销毁掉。

    由Session作用域限制的Bean可以被认为是面向Web的单例,因为给定环境(用户会话)仅存在一个实例。但请记住,你无法在Web应用程序上下文中使用它们(说个好理解点的,就是一个函数内部自定义变量所在的作用域,函数执行完就销毁了,没有什么逃逸)。

    想知道Session作用域bean在Spring中的操作,我们需要在配置文件中定义一个bean:

    <bean id="shoppingCartRequest" class="com.migo.scope.ShoppingCartSession" scope="session">
    
        <aop:scoped-proxy/> 
    
    </bean>
    

    通过@Autowired注解,查找这个bean的方式与request 作用域的bean相同。可以看到以下结果:
    你可以看到,前5个打印输出代表相同的对象。最后一个是不同的。这是什么意思 ?简单来说,这代表 着一个新的用户使用自动注入的Session作用域访问该页面。我们可以通过打开两个浏览器的测试页(/test)来观察它。每个都将初始化一个新的会话Session,因此也就创建新的ShoppingCartSession bean实例。
    #5. global session

    该部分主要是描述portlet的,详情可以Google更多关于portlet的相关信息。

    参考如下的Bean定义:

    <bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>
    
    

    global session作用域比较类似之前提到的标准的HTTPSession,这种作用域是只应用于基于门户(portlet-based)的web应用的上下之中的。门户的Spec中定义的global session的意义:global session被所有构成门户的web应用所共享。定义为global session作用域的Bean是作用在全局门户Session的声明周期的。

    如果在使用标准的基于Servlet的Web应用,而且定义了global session作用域的Bean,那么只是会使用标准的HTTPSession作用域,不会报错。

    关于全局会话作用域(Global session scope)属于4.3x的范畴了,Spring5已经没有了,Spring5文档是去掉了因为4的存在所以还是说两句,它保留给portlet应用程序。 是不是一脸懵逼,so,来解释一下portlet是什么。Portlet是能够生成语义代码(例如:HTML)片段的小型Java Web插件。它们基于portlet容器,可以像servlet一样处理HTTP请求。但是,与servlet不同,每个portlet都有不同的会话。在这种情况下,Spring提供了一个名为global-session的作用域。通过它,一个bean可以通过应用程序中的多个portlet共享。

    至此,我们解释了请求和面向会话的作用域。第一个的作用是在每个request请求上创建新的bean。第二个在Session会话开始的时候初始化bean。

    展开全文
  • 因此,制订物料需求计划前就必须具备以下的基本数据:第一项数据是主生产计划,它指明某一计划时间段内应生产出的各种产品和备件,它是物料需求计划制订的一个最重要的数据来源。第二项数据是物料清单(BOM),它...
  • 嵌套 DataRelation:讨论嵌套 DataRelation 对象在以 XML 数据形式表示 DataSet 内容时的重要性,并描述如何创建这些对象。 从 XML 架构 (XSD) 生成 DataSet 关系结构:描述从 XML 架构定义语言 (XSD) 架构创建 ...
  • 各种类型

    2013-07-12 14:45:26
    *表:表是Oracle数据库中最重要的段。表是数据库中最常用的存储数据的机制,表段中所存储的数据是无序的,数据库管理员无法控制某一行数据所存放一个表中的具体位置。Oracle规定一个表中的所有数据必须存放一...

    段:是在数据库中占有磁盘空间的对象。这些段使用数据库的数据文件中的磁盘空间。Oracle为了数据库管理和维护的方便,提供了多种不同类型的段。它们包括:

    *表:表是Oracle数据库中最重要的段。表是数据库中最常用的存储数据的机制,在表段中所存储的数据是无序的,数据库管理员无法控制某一行数据所存放在一个表中的具体位置。Oracle规定一个表中的所有数据必须存放在一个表空间中。

    *分区表:当一个表的规模很大或并行操作非常频繁时,可以将这个表划分为若干个分区(partition),此时表已经成了逻辑的概念,每一个分区为一个存储数据的段,每个分区的存储参数可以单独定义。
    在一些大型数据库中使用分区表有时是不可避免的,如银行和电信系统。
    例如电信的客户表可能很大,此时可以将客户表按客户所居住的地区分区。这样做的好处是可以改进数据库的可获得性,因为对于分区表来说,当一个分区损坏了并不影响其他分区的操作。另外可以通过把每个分区放在不同的磁盘上以提高并行操作的能力,从而达到改进系统效率的目的。

    *索引:引入索引段的目的是加快基于某一特殊键的查询速度,这样的查询可以很快的查找到在某一表中所需数据行的准确位置。如果每一个表有5个索引,那么,就会有5个相应的索引段。

    *簇:能少用就少用

    *索引分区:在一个超大型表上创建索引时,这个索引可能很大,所以可以想分区表那样,将该索引划分为若干个分区,每个索引分区为一单独的段。这样一个索引可以发布在不同的表空间上。但是每个索引分区(段)只能存放在一个表空间中。引入索引分区的主要目的也是为了减少输入或输出竞争。

    *索引表:如果用户的查询主要是基于索引关键字,那么在索引树的叶子结点中的数据行的地址部分可以存放真正的数据,这种存储结构就称为索引表。索引表可以大大加快基于索引关键字的查询,但是这种存储结构不适合DML操作非常频繁的表。

    *临时段:在sql语句中使用了诸如ORDER BY,GROUP BY或DISTINCT等子句或关键字时,Oracle服务器就要试着在内存中进行排序。如果内存中排不下就要把中间 的结果写到磁盘上,该磁盘区就是临时段。

    *还原段:还原段用来存放事务对数据库所作的改变。在对任何数据块或索引块改变之前,所有的原始值都将存放在还原段中。这样不但允许用户可以还原所作的变化,而且还可以在一个进程对某一行数据进行DML操作的同时,允许其他进程对该行数据进行读操作(读的是存放在还原段的原来的数据)。

    *大对象段(LOB SEGMENT):用来存放大的正文文档,图像或音像信息的。在一个表中可以有一列或多列LOB数据类型。如果LOB类型的列很大,Oracle服务器就会将该列的值单独存放在另一个段中,该段就称为大对象段(LOB segment),在表中只包含了一个指向相应大对象数据的指针(地址)。

    *嵌套表(nested table):嵌套表是种特殊的表,该表中的某一列又由一个用户定义的表组成,即表中套表。
     
    *自举段:是在数据库被创建时由sql.bsp脚本建立的。它也被称为高速缓存段。该段在实例打开数据库时帮助初始化数据字典高速缓存区,不能对自举段进行任何的查询或修改,DBA也无需对该段进行任何的维护。

     

    整理自 何明《Oracle DBA基础培训教程》

    展开全文
  • 最重要的信息,并帮助读者消化最难以理解的概念。本书是一本友好而易于使用的自学指南,适合用做编 程课程的教材,也可供熟悉其他语言的开发人员参考,以更深入地理解C++语言的基本知识。 本书采用了各种教学技巧...
  • 最重要的信息,并帮助读者消化最难以理解的概念。本书是一本友好而易于使用的自学指南,适合用做编 程课程的教材,也可供熟悉其他语言的开发人员参考,以更深入地理解C++语言的基本知识。 本书采用了各种教学技巧...
  • 有一点需要注意的是,VB的标准版中仅能使用数据控件(Data Control)对数据库中的记录进行访问,主要的数据库存取对象中也仅有Database、Dynaset对象可通过数据控件的属 性提供,其它的重要对象如TableDef、Field、...
  • 最重要的信息,并帮助读者消化最难以理解的概念。本书是一本友好而易于使用的自学指南,适合用做编 程课程的教材,也可供熟悉其他语言的开发人员参考,以更深入地理解C++语言的基本知识。 本书采用了各种教学技巧...
  • 最重要的信息,并帮助读者消化最难以理解的概念。本书是一本友好而易于使用的自学指南,适合用做编 程课程的教材,也可供熟悉其他语言的开发人员参考,以更深入地理解C++语言的基本知识。 本书采用了各种教学技巧...
  • Linux 内核文件 Cache 管理机制介绍

    千次阅读 2017-04-14 14:57:41
    操作系统是计算机上最重要的系统软件,它负责管理各种物理资源,并向应用程序提供各种抽象接口以便其使用这些物理资源。从应用程序的角度看,操作系统提供了一个统一的虚拟机,该虚拟机没有各种机器的具体细节,...
  • 前面文章,我们了解了IT运维管理的概念以及重要作用,本文重点讲述其工作内容。IT运维是IT管理的核心和重点部分,也是内容最多、繁杂部分,主要用于IT部门内部日常运营管理,涉及的对象分成两大部分,即IT...
  • 信息的获取、处理、交流和应用能力,已经成为人们最重要的能力之一。不久的将来知识经济将占世界经济发展的主导地位,国家综合国力和国际竞争能力越来越取决于教育发展,科学技术和知识创新的水平,教育经济和...
  • OpenCASCADE一个强大几何内核,是FreeCAD的最重要组件 Coin3D库兼容Open Inventor3D场景表示模型 Python FreeCAD提供了广泛Python API Qt使用Qt构建图形用户界面 正在安装 预编译(可安装)软件包可...
  • 上面方式引入的是Fly的默认实例(浏览器、Node、React Native相同),你也可以自己创建Fly实例: // 浏览器和React Native var Fly=require("flyio/dist/npm/fly") // Node 入口 // var Fly=require("flyio/src/...
  • 最重要的还是Object Pascal语言,它才是一切的根本。 Object Pascal语言是Pascal语言的基础上发展起来的,简单易学。 Delphi提供了各种开发工具,包括集成环境、图像编辑(Image Editor),以及各种开发数据库的...
  • 信息的获取、处理、交流和应用能力,已经成为人们最重要的能力之一。不久的将来知识经济将占世界经济发展的主导地位,国家综合国力和国际竞争能力越来越取决于教育发展,科学技术和知识创新的水平,教育经济和...
  • 计算机中最重要的思想就是抽象了吧,或者说封装,那就是不用理解其实现原理,只需要使用即可,不断的使用过程中,加深对系统的理解。  比如,对于物理硬盘的抽象,可以把它看成一个存储各种数据的对象,有read和...
  • 目前许多支持UML工具行列,Rational Rose算得上是出名分析和设计面向对象软件系统可视化工具。总来说,Rational Rose是一个完全、具有能满足所有建模环境(包括Wed开发、数据库建模、各种开发工具和...
  • 为了监督,控制业务各种流程,以建立有效的制造系统,例如卖方-制造商关系,客户制造商关系,商品或服务生产的车间管理,运营管理起着重要的作用。 运营管理基本上是在管理过程,该过程将原材料,人力和能源...
  • 以往的WPS 着重处理文字,而现在的WPS 2000 极大地丰富了文字处理软件的内涵,它不仅有极强的文字处理功能,更重要的是它能将多种对象的处理有效地融为一体。譬如,现在数据库文件格式众多,如 dBase 文件、FoxPro ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 445
精华内容 178
关键字:

在各种管理对象中最重要的是