prototype模式,面试中,常问道j2ee中23种设计模式中的8种是哪些

prototype模式,面试中,常问道j2ee中23种设计模式中的8种是哪些详细介绍

本文目录一览： 创建型模式有哪些

单例模式 ，抽象工厂，工厂方法，建造模式，原型模式。
1.Singleton，单例模式 ： 保证一个类只有一个实例，并提供一个访问它的全局访问点
2.Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类
3.Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类
4.Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示 5.Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象
各种模式的分类
首先得明确 23 种设计模式也是分为三大类的，分别是创建型、结构型、行为型
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式，共七种：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

java中常用到得设计模式有哪几种(java常用的设计模式及应用场景)

一共23种设计模式！
按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
工厂方法模式（FactoryMethodPattern）
抽象工厂模式（AbstractFactoryPattern）
建造者模式（BuilderPattern）
原型模式（PrototypePattern）
单例模式（SingletonPattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
适配器模式（AdapterPattern）
桥接模式（BridgePattern）
组合模式（CompositePattern）
装饰者模式（DecoratorPattern）
外观模式（FacadePattern）
享元模式（FlyweightPattern）
代理模式（ProxyPattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
责任链模式（ChainofPattern）
命令模式（CommandPattern）
解释器模式（InterpreterPattern）
迭代器模式（IteratorPattern）
中介者模式（MediatorPattern）
备忘录模式（MementoPattern）
观察者模式（ObserverPattern）
状态模式（StatePattern）
策略模式（StrategyPattern）
模板方法模式（TemplateMethodPattern）
访问者模式（VisitorPattern）
推荐你一本好书：《软件秘笈：设计模式那点事》，里面讲解的23中设计模式例子很生动，容易理解，还有JDK中设计模式应用情况，看了收获挺大的！百度里面搜“设计模式”，第一条中设计模式百度百科中就有首推该图书，浏览量在20几万以上的，不会错的。好东西大家一起分享！
祝你早日学会设计模式！

com编程模式

一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
行为型有：
六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
结构型有：
十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。
十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问
二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
二十三、Flyweight，享元模式

面试中,常问道j2ee中23种设计模式中的8种是哪些

一般会用到的：
Factory（ 工厂模式）
Singleton（单例模式）
这两个比较多
Proxy（代理模式）
Adapter（适配器模式）
Command（命令模式）
Observer（观察者模式）
Facade（门面模式）
这些也会碰到
Template Method（模板方法模式）
Decorator（装饰模式）
Iterator（迭代子模式）
这些很少遇见
至于其他的，遇见的可能不大，只有符合一定条件的需求才会用到吧。
笔试面试的时候应该准备什么：
设计模式的笔试主要是前3个的Demo，就是简单的实现，比如单例的懒汉饿汉模式。
面试时，设计模式主要问该设计的好处，还有应用的场景吧。
怎么破？？？
个人觉得搞明白这些设计模式的基本实现应该就能明白这些模式怎么用了吧，为什么会用吧。
推荐Gof的书。
Java 中的23 种设计模式：Factory（ 工厂模式），Builder（ 建造模式）， Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）。
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

singleton和prototype的区别

singleton作用域：当把一个Bean定义设置为singleton作用域是，Spring
IoC容器中只会存在一个共享的Bean实例，并且所有对Bean的
请求，只要id与该Bean定义相匹配，则只会返回该Bean的同一实例。值得强调的是singleton作用域是Spring中的缺省作用域。
prototype作用域：prototype作用域的Bean会导致在每次对该Bean请求（将其注入到另一个Bean中，或者以程序的方式调用容器的getBean
()方法）时都会创建一个新的Bean实例。根据经验，对有状态的Bean应使用prototype作用域，而对无状态的Bean则应该使用singleton作用
域。
对于具有prototype作用域的Bean，有一点很重要，即Spring不能对该Bean的整个生命周期负责。具有prototype作用域的Bean创建后交由调
用者负责销毁对象回收资源。
简单的说：
singleton
只有一个实例，也即是单例模式。
prototype访问一次创建一个实例，相当于new。
singleton作用域：当把一个bean定义设置为singleton作用域是，spring
ioc容器中只会存在一个共享的bean实例，并且所有对bean的
请求，只要id与该bean定义相匹配，则只会返回该bean的同一实例。值得强调的是singleton作用域是spring中的缺省作用域。
prototype作用域：prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getbean
()方法）时都会创建一个新的bean实例。根据经验，对有状态的bean应使用prototype作用域，而对无状态的bean则应该使用singleton作用
域。
对于具有prototype作用域的bean，有一点很重要，即spring不能对该bean的整个生命周期负责。具有prototype作用域的bean创建后交由调
用者负责销毁对象回收资源。
简单的说：
singleton
只有一个实例，也即是单例模式。
prototype访问一次创建一个实例，相当于new。
应用场合：
1.需要回收重要资源(数据库连接等)的事宜配置为singleton，如果配置为prototype需要应用确保资源正常回收。
2.有状态的bean配置成singleton会引发未知问题，可以考虑配置为prototype。

常用设计模式概览：提高程序可维护性和可扩展性的秘密武器？

设计模式是在软件开发中常用的一种编程技巧，它提供了一种通用的解决方案，以便在面对特定的问题时，能够提高软件的可维护性、可扩展性和可重用性。设计模式是一种经过实践证明并被广泛使用的最佳实践。在本文中，我们将简要介绍常见的设计模式。
一、创建型模式
1、工厂方法模式（Factory Method）
工厂方法模式是一种用于创建对象的设计模式。它定义了一个接口来创建对象，并由子类来实现这个接口，从而创建出不同的对象。这样，我们就可以在不暴露对象创建细节的情况下创建对象。工厂方法模式可以帮助我们解决创建对象时的复杂性。
2、抽象工厂模式（Abstract Factory）
抽象工厂模式是工厂方法模式的一种扩展。它可以帮助我们创建一组相关的对象，而不是单个对象。抽象工厂模式定义了一个抽象工厂接口，具体的工厂实现了这个接口来创建对象。通过使用抽象工厂模式，我们可以将对象的创建过程封装起来，从而让客户端代码更加简单。
3、单例模式（Singleton）
单例模式是一种确保一个类只有一个实例的模式。它通过将类的构造函数私有化来实现。这样，就可以防止通过构造函数创建多个实例。单例模式通常提供一个静态方法来获取类的唯一实例。单例模式可以帮助我们确保全局只有一个实例，并且可以让我们方便地访问这个实例。
4、建造者模式（Builder）
建造者模式是一种用于创建复杂对象的模式。它将对象的构造过程分解成多个步骤，并且允许在每个步骤中使用不同的构造方法。这样，就可以创建出不同的对象。建造者模式可以帮助我们解决创建复杂对象时的复杂性。
5、原型模式（Prototype）
原型模式是一种用于创建对象的模式。它允许我们通过克隆一个现有对象来创建一个新的对象。这样，我们就可以在不知道对象创建细节的情况下创建新的对象。原型模式可以帮助我们提高对象创建的效率。
二、结构型模式
1、适配器模式（Adapter）
适配器模式是一种用于将不兼容接口转换为兼容接口的模式。适配器模式通过包装一个对象来适配不同的接口。这样，就可以让原本不兼容的接口能够相互协作。适配器模式可以帮助我们将旧系统与新系统无缝集成。
2、桥接模式（Bridge）
桥接模式是一种用于将抽象部分与实现部分分离的模式。桥接模式通过将抽象部分与实现部分分离，从而可以让它们能够独立地变化。这样，就可以在不影响其他部分的情况下修改抽象部分或实现部分。
3、组合模式（Composite）
组合模式是一种用于将对象组合成树形结构的模式。组合模式通过将对象组合成树形结构，从而可以让客户端代码以统一的方式处理单个对象和组合对象。组合模式可以帮助我们简化代码结构，从而提高代码的可读性和可维护性。
4、装饰器模式（Decorator）
装饰器模式是一种用于在运行时添加功能的模式。装饰器模式通过将对象包装在另一个对象中，从而可以在运行时动态地添加功能。装饰器模式可以帮助我们将复杂的功能分解成简单的功能，并且可以让我们方便地扩展对象的功能。
5、外观模式（Facade）
外观模式是一种用于简化接口的模式。外观模式通过提供一个简单的接口来隐藏系统的复杂性。这样，就可以让客户端代码更加简单。外观模式可以帮助我们简化代码结构，并且可以提高代码的可读性和可维护性。
6、享元模式（Flyweight）
享元模式是一种用于共享对象的模式。享元模式通过将共享对象的状态分离出来，从而可以让多个对象共享同一个状态。这样，就可以减少对象的数量，从而提高系统的性能。享元模式可以帮助我们优化系统性能，并且可以减少内存使用量。
三、行为型模式
1、职责链模式（Chain of Responsibility）
职责链模式是一种用于处理请求的模式。职责链模式通过将请求沿着一条链传递下去，从而可以让多个对象都有机会处理这个请求。职责链模式可以帮助我们将复杂的业务逻辑分解成简单的逻辑，并且可以让我们方便地扩展处理请求的对象。
2、命令模式（Command）
命令模式是一种用于封装操作的模式。命令模式通过将操作封装成对象，从而可以让我们能够以统一的方式处理不同的操作。命令模式可以帮助我们简化代码结构，并且可以让我们方便地撤销和重做操作。
3、解释器模式（Interpreter）
解释器模式是一种用于处理语言的模式。解释器模式通过将语言分解成语法树，从而可以让我们方便地解析和执行语言。解释器模式可以帮助我们扩展语言的语法和功能，并且可以让我们方便地添加新的语言。
4、迭代器模式（Iterator）
迭代器模式是一种用于访问集合的模式。迭代器模式通过将集合的遍历过程封装成对象，从而可以让客户端代码以统一的方式访问集合中的元素。迭代器模式可以帮助我们简化代码结构，并且可以让我们方便地扩展集合的遍历方式。
5、中介者模式（Mediator）
中介者模式是一种用于处理对象之间的交互的模式。中介者模式通过将对象之间的交互集中在一个中介者对象中，从而可以让对象之间的交互变得更加简单。中介者模式可以帮助我们解耦对象之间的交互，并且可以让我们方便地添加新的对象和交互方式。
6、备忘录模式（Memento）
备忘录模式是一种用于保存对象状态的模式。备忘录模式通过将对象的状态保存在一个备忘录对象中，从而可以让对象在后续操作中恢复到之前的状态。备忘录模式可以帮助我们实现撤销和重做操作，并且可以让我们方便地保存对象的历史状态。
7、观察者模式（Observer）
观察者模式是一种用于处理对象之间的通知的模式。观察者模式通过将对象之间的通知封装成事件，从而可以让对象之间的通知变得更加简单。观察者模式可以帮助我们解耦对象之间的通知，并且可以让我们方便地添加新的对象和通知方式。
8、状态模式（State）
状态模式是一种用于处理对象状态的模式。状态模式通过将对象的状态分解成不同的状态类，从而可以让对象的状态变得更加清晰。状态模式可以帮助我们简化代码结构，并且可以让我们方便地扩展对象的状态。
9、策略模式（Strategy）
策略模式是一种用于处理算法的模式。策略模式通过将算法封装成不同的策略类，从而可以让客户端代码选择不同的算法。策略模式可以帮助我们简化代码结构，并且可以让我们方便地扩展算法。
10、模板方法模式（Template Method）
模板方法模式是一种用于处理算法的模式。模板方法模式通过将算法的骨架定义在抽象基类中，从而可以让子类实现具体的算法细节。模板方法模式可以帮助我们简化代码结构，并且可以让我们方便地扩展算法的骨架和细节。
11、访问者模式（Visitor）
访问者模式是一种用于处理对象结构的模式。访问者模式通过将对象结构和访问操作分离，从而可以让客户端代码以统一的方式访问对象结构中的元素。访问者模式可以帮助我们简化代码结构，并且可以让我们方便地添加新的访问操作和元素类型。
12、享元模式（Flyweight）
像元模式是一种用于处理大量相似对象的模式。享元模式通过共享相同的状态，从而可以让我们节省内存和时间开销。享元模式可以帮助我们提高程序的性能，并且可以让我们方便地添加新的对象类型。
总结：设计模式是一种被广泛使用的软件设计方法，它可以帮助我们简化代码结构、提高程序的可维护性和可扩展性。在本文中，我们介绍了12种常用的设计模式，包括工厂模式、单例模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。
每种设计模式都有自己的特点和用途，我们可以根据不同的情况选择适合的模式来解决问题。虽然设计模式可以帮助我们提高程序的质量和效率，但是过度使用设计模式也会带来一些问题，例如增加代码的复杂性和维护成本。因此，在使用设计模式时，我们应该权衡利弊，根据实际情况作出选择。

先进制造模式的虚拟制造生产模式

虚拟制造生产模式是利用制造过程计算机模拟和仿真来实现产品的设计和研制的模式，即在计算机中实现的制造技术。它将从根本上改变设计、试制、修改设计、规模生产的传统制造模式。在产品真正制造出来之前，首先应在虚拟制造环境中完成软产品原型（Soft Prototype），代替传统的硬样品（ Hard Prototype）进行试验，对其性能进行了预测和评估，从而大大缩短产品设计与制造周期、降低产品开发成本，提高其快速响应市场变化的能力，以便更可靠地决策产品研制，更经济地投入、更有效地组织生产，从而实现制造系统全面最优的制造生产模式。此外，美国麻省理工学院的“敏捷论坛”和“制造先驱”两个机构还于1995年共同策划提出“下一代制造生产模式”。其中心思想是：经济全球化是推动制造业未来发展的原动力，明确在下一代竞争环境中获得成功应采取的制造方法。认为在制造过程中的管理技术有着统率生产过程、决定产品质量和市场竞争力的独特作用。该模式对21世纪制造业的发展具有深远的影响。

几种JS创建对象的方式分享

本文主要和大家分享几种JS创建对象的方式，希望能帮助到大家。1、使用原生构造函数创建特定类型的对象 var person =new Object(); person.name="wangwu"; person.age="20"; person.sayName=function(){ alert(this.name);}2.用对象字面量var person = { name:"wangwu", age:"20", sayName: function(){ alert(this.name); }}小结：这两种方式都可以用来创建单个对象，但是有明显的缺点，使用同一个接口创建很多对象，会产生大量重复代码。3.使用工厂模式function createPerson(name,age){ var o=new Object(); o.name=name; o.age=age; o.sayName=function(){ alert(this.name); }; return o;}var person1=createPerson("wangwu",20);抽象了创建具体对象的过程，发明一种函数，用函数来封装以特定接口创建对象的细节。4、构造函数模式function Person(name,age){ this.name=name; this.age=age; this.sayName=function(){ alert(this.name); };}var person1=new Person("wangwu",20);创建自定义的构造函数，从而定义自定义对象类型的属性和方法。5、原型模式function Person(){}Person.prototype.name="wangwu";Person.prototype.age=20;Person.prototype.sayName=function(){ alert(this.name);}var person1=new Person();person1.sayName(); //wangwu我们创建的每个函数都有一个prototype(原型)属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。原型模式的缺点是省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都取得相同的属性值；原型中所有属性是被很多实例共享的，对于包含引用类型值的属性来说问题就比较突出了。6、组合使用构造函数模式和原型模式function Person(name,age){ this.name=name; this.age=age; this.friends=["wangwu","zhangsan"];}Person.prototype={ constructor:Person, sayName:function(){ alert(this.name); }}var person1=new Person("wangwu",20);var person2=new Person("zhangsan",23);person1.friends.push("lisi");alert(person1.friends); //"wangwu,zhangsan,lisi"alert(person2.friends); //"wangwu,zhangsan"7、动态原型模式 function Person(name,age,job){ //属性 this.name=name; this.age=age; this.job=job;//方法if(typeof this.sayName!="function"){ person.prototype.sayName=function(){ alert(this.name); };}}var friend=new Person("wangwu",20);friends.sayName();8、寄生构造函数模式function Person(name,age){ var 0=new Object(); o.name="wangwu"; o.age=20; o.sayName=function(){ alert(this.name); }; return o;}var friend=new Person("wangwu",20);friend.sayName(); //"wangwu"9、稳妥构造函数模式function Person(name,age,job){ //创建要返回的对象 var o=new Object(); //可以在这里定义私有变量和函数 //添加方法 o.sayName=function(){ alert(name); };//返回对象return o;}var friend=Person("wangwu",20);friend.sayName(); //"wangwu"

spring的controller默认是单例还是多例

spring的controller默认是单例的。
spring的bean作用域有5个，如下：
singleton：单例模式，当spring创建applicationContext容器的时候，spring会初始化所有的该作用域实例，加上lazy-init就可以避免预处理。
prototype：原型模式，每次通过getBean获取该bean就会产生一个新的实例，创建后spring将不再对齐进行管理。
request：每次请求都会产生一个新的实例，和prototype不同的是，创建以后spring依然在监听。
session：每次会话，同上。
spring的controller默认是单例，原因有二：
（1）为了性能：单例不用每次都创建
（2）不需要多例：只要controller中不定义属性，那么单例完全是安全可用的，如果定义了，那单例肯定会出现竞争访问；非要定义，则通过注解@Scope("prototype")，将其设置为多例模式。
单例的,struts是原型的
曾经面试的时候有面试官问我spring的controller是单例还是多例，结果
我傻逼的回答当然是多例，要不然controller类中的非静态变量如何保证是线程安全的，这样想起似乎是对的，但是不知道（主要是我没看过
spring的源码，不知道真正的内在意图）为什么spring的controller是单例的。
先看看spring的bean作用域有几种，分别有啥不同。
spring bean作用域有以下5个：
singleton:单例模式，当spring创建applicationContext容器的时候，spring会欲初始化所有的该作用域实例，加上lazy-init就可以避免预处理；
prototype：原型模式，每次通过getBean获取该bean就会新产生一个实例，创建后spring将不再对其管理；
====下面是在web项目下才用到的===
request：搞web的大家都应该明白request的域了吧，就是每次请求都新产生一个实例，和prototype不同就是创建后，接下来的管理，spring依然在监听
session:每次会话，同上
global session:全局的web域，类似于servlet中的application
好了，上面都说了spring的controller默认是单例，那很自然就是singleton了。
再看一个例子，看看单例会不会有我说的那种问题（就是类中定义的非静态变量线程安全问题），当然下面这个例子我是实验过的， 要不然也不敢发出来
为什么spring要默认是单例呢？原因有二：
1、为了性能。
2、不需要多例。
1、这个不用废话了，单例不用每次都new，当然快了。
2、不需要实例会让很多人迷惑，因为spring mvc官方也没明确说不可以多例。
我这里说不需要的原因是看开发者怎么用了，如果你给controller中定义很多的属性，那么单例肯定会出现竞争访问了。
因此，只要controller中不定义属性，那么单例完全是安全的。下面给个例子说明下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
默认单例的
1|2

package
com.lavasoft.demo.web.controller.lsh.ch5;
import
org.springframework.context.annotation.Scope;
import
org.springframework.stereotype.Controller;
import
org.springframework.ui.ModelMap;
import
org.springframework.web.bind.annotation.RequestMapping;
/**
* Created by Administrator on 14-4-9.
*
* @author leizhimin 14-4-9 上午10:55
*/
@Controller
@RequestMapping("/demo/lsh/ch5")
public
class MultViewController {

privateintindex =
0; //非静态
@RequestMapping("/show")
publicStringtoShow(ModelMap model) {
System.out.println(++i);
return"/lsh/ch5/show";
}
@RequestMapping("/test")
publicStringtest() {
System.out.println(++i);
return"/lsh/ch5/test";
}
}

改为多例的（就是在class上面加一个@Scope("request")）：
1 | 1
从此可见，单例是不安全的，会导致属性重复使用。
最佳实践：
1、不要在controller中定义成员变量。
2、万一必须要定义一个非静态成员变量时候，则通过注解@Scope("prototype")，将其设置为多例模式。