SPRING中属性SCOPE的prototype是什么意思

一个 a; an; one; singleton; [例句]他是一个雷锋式的人物。He is a man of Lei Feng type.

单例模式，在spring1..x中，当bean对象的singleton属性为true时，意味着在spring的bean管理池中，只保持一个该bean对象的实例；当bean对象的singleton属性为false时，意味着在spring的bean管理池中，为每一个针对该bean对象的请求都保持一个实例。

一个 [词典] a; an; one; singleton; [例句]他是一个雷锋式的人物。He is a man of Lei Feng type

singleton就是单例的意思。就是说，单例模式的类只能创建一个对象，这个经常用到的，比如解析配置文件的类就是单例的。饿汉式 class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; } } 懒汉式 class Singleton { private static Singleton instance=null; private Singleton(){} static Singleton getInstance() { if(instance==null) instance=new Singleton(); return instance; } } 创建单例的两种方式。你可以看到无论那种方式都将无参构造函数设为了私有，也就是说想得到这个类的对象是无法使用new来创建了，必须通过它提供的静态方法获得。而静态方法返回的是一个该类的静态对象，静态变量是全局唯一的，这样就保证了，每次get时始终都是返回的这个对象。

单例模式，在spring1..x中，当bean对象的singleton属性为true时，意味着在spring的bean管理池中，只保持一个该bean对象的实例；当bean对象的singleton属性为false时，意味着在spring的bean管理池中，为每一个针对该bean对象的请求都保持一个实例。

singleton

packagetest;publicclasssingleton{privatesingletons;privatesingleton(){}publicstaticsingletongetsigleton(){if(s==null)s=newsingleton();returns;}}这就是一个单例模式，我想应该不用注释了，原理就是这个类的构造方法private了，所有在外边不能调用，也就不能newsingleton();得到实例，那么想得到实例就得调用它的静态方法getsigleton（）；即singleton.getsigleton（）；就会返回一个singleton的实例，注意此方法中的语句，即如果你是第一次调用这个方法那么它会给你new一个实例，以后再调用得到的都是这个实例，也就是说从始至终就只有一个singleton的实例，这就是单例模式。

单例模式用法很多，下面算是比较通用的一种：class Singleton { private static Singleton s; private Singleton(){ System.out.println("A Singleton Model example"); } public static Singleton getSigleton() { if(s==null)s=new Singleton(); return s; }}这种情况只能使用 Singleton.getSigleton()获得一个实例，因为构造方法是private，所以不可能在别的函数里new()实例

public class Singleton { private static Singleton instance = null; //存放唯一实例用的 private Singleton () { //用来防止直接new } public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }}

　单例模式(Singleton) ,属于最常见的设计模式之一，大部分系统都会用到，目的是为了维护系统中唯一的一个实例。x0dx0a　　可分为eager模式，示例代码如下：x0dx0a　　Java代码x0dx0a　　1.class EagerSingleton{x0dx0a　　2. private static final EagerSingleton m_instance = new EagerSingleton();x0dx0a　　3. private EagerSingleton(){}x0dx0a　　4. public static EagerSingleton getInstance(){x0dx0a　　5. return m_instance;x0dx0a　　6. }x0dx0a　　7.}x0dx0a　　class EagerSingleton{x0dx0a　　private static final EagerSingleton m_instance = new EagerSingleton();x0dx0a　　private EagerSingleton(){}x0dx0a　　public static EagerSingleton getInstance(){x0dx0a　　return m_instance;x0dx0a　　}x0dx0a　　}x0dx0a　　和 lazy模式，示例代码如下：x0dx0a　　Java代码x0dx0a　　1.class LazySingleton{x0dx0a　　2. private static LazySingleton m_instance = null;x0dx0a　　3. private LazySingleton(){}x0dx0a　　4. public synchronized static getInstance(){x0dx0a　　5. if(m_instance == null){x0dx0a　　6. m_instance = new LazySingleton();x0dx0a　　7. }x0dx0a　　8. return m_instance;x0dx0a　　9. }x0dx0a　　10.}x0dx0a　　class LazySingleton{x0dx0a　　private static LazySingleton m_instance = null;x0dx0a　　private LazySingleton(){}x0dx0a　　public synchronized static getInstance(){x0dx0a　　if(m_instance == null){x0dx0a　　m_instance = new LazySingleton();x0dx0a　　}x0dx0a　　return m_instance;x0dx0a　　}x0dx0a　　}x0dx0a　　java源码中，Runtime.getRuntime()就是单例的一个例子。x0dx0a　　单例模式的精神就是整个系统中维护一个实例，推广开来，如果在一个系统中需要维护多个示例，那么就产生了多例模式(multiton)。x0dx0a　　多例模式(Multiton) ,通过聚集对象了保留自身的多个示例，根据客户端的参数返回所需要的实例。x0dx0a　　示例代码如下：x0dx0a　　Java代码x0dx0a　　1.class Multiton{x0dx0a　　2. private final int INSTANCE_SIZE = 10;x0dx0a　　3. private static Map instances = new HashMap(INSTANCE_SIZE);x0dx0a　　4. private String name;x0dx0a　　5. private Multiton(){}x0dx0a　　6. private Multiton(String name){x0dx0a　　7. this.name = name;x0dx0a　　8. }x0dx0a　　9. public synchronized static getInstance(String name){x0dx0a　　10. if(instances.containsKey(name)){x0dx0a　　11. return instances.get(name);x0dx0a　　12. }x0dx0a　　13. else{x0dx0a　　14. ins = new Multiton(name);x0dx0a　　15. instances.put(name, ins);x0dx0a　　16. return ins;x0dx0a　　17. }x0dx0a　　18. }x0dx0a　　19.}x0dx0a　　class Multiton{x0dx0a　　private final int INSTANCE_SIZE = 10;x0dx0a　　private static Map instances = new HashMap(INSTANCE_SIZE);x0dx0a　　private String name;x0dx0a　　private Multiton(){}x0dx0a　　private Multiton(String name){x0dx0a　　this.name = name;x0dx0a　　}x0dx0a　　public synchronized static getInstance(String name){x0dx0a　　if(instances.containsKey(name)){x0dx0a　　return instances.get(name);x0dx0a　　}x0dx0a　　else{x0dx0a　　ins = new Multiton(name);x0dx0a　　instances.put(name, ins);x0dx0a　　return ins;x0dx0a　　}x0dx0a　　}x0dx0a　　}x0dx0a　　[nextpage]x0dx0a　　一个实用的例子就是KeyGenerator, 示例代码如下：x0dx0a　　Java代码x0dx0a　　1.class KeyGenerator{x0dx0a　　2. private final int POOL_SIZE = 20;x0dx0a　　3. private static Map instances = new HashMap(16);x0dx0a　　4. private KeyInfo keyinfo;x0dx0a　　5. private KeyGenerator(){}x0dx0a　　6. private KeyGenerator(String keyName){x0dx0a　　7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);x0dx0a　　8. }x0dx0a　　9. public synchronized static getInstance(String keyName){x0dx0a　　10. if(instances.containsKey(keyName)){x0dx0a　　11. return (KeyGenerator)instances.get(keyName);x0dx0a　　12. }x0dx0a　　13. else{x0dx0a　　14. keyGen = new KeyGenerator(keyName);x0dx0a　　15. instances.put(name, keyGen);x0dx0a　　16. return keyGen;x0dx0a　　17. }x0dx0a　　18. }x0dx0a　　19. public synzhronized int getNextKey(){x0dx0a　　20. return keyinfo.getNextKey();x0dx0a　　21. }x0dx0a　　22. }x0dx0a　　class KeyGenerator{x0dx0a　　private final int POOL_SIZE = 20;x0dx0a　　private static Map instances = new HashMap(16);x0dx0a　　private KeyInfo keyinfo;x0dx0a　　private KeyGenerator(){}x0dx0a　　private KeyGenerator(String keyName){x0dx0a　　this.keyinfo = new KeyInfo(POOL_SIZE, keyName);x0dx0a　　}x0dx0a　　public synchronized static getInstance(String keyName){x0dx0a　　if(instances.containsKey(keyName)){x0dx0a　　return (KeyGenerator)instances.get(keyName);x0dx0a　　}x0dx0a　　else{x0dx0a　　keyGen = new KeyGenerator(keyName);x0dx0a　　instances.put(name, keyGen);x0dx0a　　return keyGen;x0dx0a　　}x0dx0a　　}x0dx0a　　public synzhronized int getNextKey(){x0dx0a　　return keyinfo.getNextKey();x0dx0a　　}x0dx0a　　}

singleton(in gene sequencing) a nucleotide sequence that has no overlaps with other fragments at a given stringency and is not therefore contained in any fragment assembly for a given gene.

singleton 单例false 不是单例

【答案】：D本题主要考查单例模式。单例模式的最大特点是一个类只有一个实例，因此采用这种设计模式，就可以实现类A的所有使用者都使用A的同一个实例。

私有化默认构造方法，声明一个静态方法对外提供此类的实例对象。

singleton可以说是不能组装的单一read。这个名词是对于454来说的，第一种说法比较正确，因为454的读长较长，拼接不上的单一reads也是有分析价值的。

单例模式（Singleton Pattern）是一个比较简单的模式。定义：确保某一个类只有一个实例，而且自动实例化并向整个系统提供这个实例。通用类图：通用代码：Singleton类称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化的。/** * 线程安全的单例模式 * 饿汉式单例 * @author Administrator * */public class Singleton { private static final Singleton singleton = new Singleton(); // 限制产生多个对象 private Singleton() { } // 通过该方法获得实例对象 public static Singleton getSingleton() { return singleton; } // 类中其他方法尽量是static public static void doSomething() { }}单例模式的优点：由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显了。由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。单例模式的缺点：单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能用mock的方式虚拟一个对象。单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。单例模式的使用场景：要求生成唯一序列号的环境；在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。单例模式的注意事项： 1. 在高并发情况下，请注意单例模式的线程同步问题。/** * 懒汉式单例 * @author Administrator * */public class Singleton2 { private static Singleton2 singleton = null; // 限制产生多个对象 private Singleton2() { } // 通过该方法获得实例对象 public static Singleton2 getSingleton() { synchronized (singleton) { if (singleton == null) { singleton = new Singleton2(); } } return singleton; }}如果不加synchronized进行控制，如果第一个线程A执行到singleton = new Singleton2()，但还没有获得对象，第二个线程B也在执行，执行到if (singleton == null)判断，那么线程B获得判断条件为真，于是继续运行下去，线程A和B都获得了对象，内存中就出现了两个对象。建议使用饿汉式单例，那是线程安全的单例模式。 2. 需要考虑对象的复制情况。在Java中，若实现Cloneable接口，并实现了clone方法，则可以直接通过对象复制方式创建一个新对象，对象复制是不用调用类的构造函数的。 3. 注意JVM的垃圾回收机制，如果我们的一个单例对象在内存中长久不使用，JVM就认为这是一个垃圾对象，在CPU资源空闲的情况下该对象会被清理掉，下次再调用时就需要产生一个新对象。如果该对象作为有状态值的管理，则会出现状态恢复原状的情况，就会出现故障。有两种方法可以解决该问题1、由容器管理单例的生命周期Java EE容器或者框架级容器（如Spring）可以让对象长久驻留内存。2、状态随时记录可以使用异步记录的方式，或者使用观察者模式，记录状态的变化，写入文件或写入数据库中，确保即使单例对象重新初始化也可以从资源环境获得销毁前的数据，避免应用数据丢失。单例模式的扩展：能产生固定数量实例的单例模式/** * 能产生固定数量实例的单例模式 * @author Administrator * */public class Singleton3 { // 最多能产生的实例数 private static int maxNumOfSingleton = 2; // 定义一个列表，容纳所有实例 private static ArrayList<Singleton3> singletonList = new ArrayList<Singleton3>(); // 产生所有对象 static { for (int i = 0; i < maxNumOfSingleton; i++) { singletonList.add(new Singleton3()); } } // 限制其他类生成对象 private Singleton3() { } // 随机获得一个实例 public static Singleton3 getInstance() { Random random = new Random(); return singletonList.get(random.nextInt(maxNumOfSingleton)); }}

　　单身的英文： 　　bachelordom 　　参考例句： 　　Stay single 　　保持单身 　　A Bar for singles. 　　单身酒吧 　　Spinster.of or suitable for an unmarried person 　　单身者的适宜于单身者的 　　A confirmed bachelor 　　习惯于单身的人 　　The illegitimate daughter of an ecclesiastic who has taken a vow of celibacy. 　　教士的私生女已誓单身的"神职人员的私生女 　　Matchmaking for single friends can be done in a disastrously tactless way which makes both parties cringe. 　　为单身朋友做媒可能搞得拙劣不堪，太不乖巧，致使双方畏缩不前。 　　My sister stayed single all along. 　　我姐姐一直是单身。 　　Bachelordom, sometimes, is not noble. 　　单身，有时不一定是贵族。 　　Married peopie just want to be singie again. 　　已婚的人都想恢复单身。 　　Should great men of genius stay single? 　　天才就应该是单身吗？ 　　bachelordom是什么意思： 　　n. 单身 　　Bachelordom, sometimes, is not noble. 　　单身，有时不一定是贵族。 　　Departing from parents and bachelordom was 　　离开各自的家庭，离开各自的单身生活，这是”分”，而我们所组成的家庭则是“成”。 　　I am a bachelordom and still haven"t a wedded plan. 　　我还是单身，也还没有要结婚的计划。 　　“单身”的其它常用表达 　　1、句子 　　I"m on the market 　　如果一个人“on the market”就表示“单身”的意思 　　I"m on the market.=I"m single. 　　例句： 　　Some might also be wondering how Captain America is still on the market. 　　有些人可能会想，为什么“美国队长”现在还是单身。 　　2、单词 　　①single 　　单身的，独身的 　　例句： 　　He"s been single for so long now, I don"t think he"ll ever marry. 　　他这么长时间一直单身，我认为他永远不会结婚了。 　　②unattached 　　未订婚的；未结婚的 　　例句： 　　He"s very rich and graduated from a famous university. What"s more, he"s unattached. 　　他很有钱，名牌大学毕业。而且，还是个单身汉。 　　③singleton 　　单身人士 　　例句： 　　Bank is a 38-year-old singleton who grew up in Philadelphia. 　　班克是一个38岁的单身汉，在费城长大。

【答案】：D抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类，而非单例模式

苏格登威士忌Singleton_苏格兰纯麦威士忌

1、Bean的简介 在Spring中，那些组成应用程序的主体(backbone)及由Spring IoC容器所管理的对象，被称之为bean。 简单地讲，bean就是由Spring容器初始化、装配及管理的对象，除此之外，bean就与应用程序中的其他对象没有什么区别了。 而bean定义以及bean相互间的依赖关系将通过配置元数据来描述。2、Bean的作用域 创建一个bean定义，其实质是用该bean定义对应的类来创建真正实例的“配方(recipe)”。把bean定义看成一个配方很有意义，它与class很类似，只根据一张“处方”就可以创建多个实例。 不仅可以控制注入到对象中的各种依赖和配置值，还可以控制该对象的作用域。这样可以灵活选择所建对象的作用域，而不必在Java Class级定义作用域。Spring Framework支持五种作用域（其中有三种只能用在基于web的Spring ApplicationContext）。 1）singleton 当一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。注意：Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置： 1<bean id="empServiceImpl" class="cn.csdn.service.EmpServiceImpl" scope="singleton">2）prototype 一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。 3）request 在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：1<bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>针对每次HTTP请求，Spring容器会根据loginAction bean定义创建一个全新的LoginAction bean实例， 且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态， 而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。 当处理请求结束，request作用域的bean实例将被销毁。 4）session 在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：1<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例， 且该userPreferences bean仅在当前HTTP Session内有效。 与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例， 将不会看到这些特定于某个HTTP Session的状态变化。 当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。 5）global session 在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：1<bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>global session作用域类似于标准的HTTP Session作用域，不过仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

设置你配置的bean是否为单例，默认是“true”，singleton="false"表示每次生成bean的时候都新建一个实例

独生子女 [dú shēng zǐ nǚ] the only child；only son [daughter] ◇独生子女费 the only-child allowance；独生子女家庭 (a) one-child family；独生子女家长 one-child parents；独生子女证 certificate of the only child；a one-child certificate

or<IDbContext>().Use(c => new DbContext(AppSettings.ConnectionString));x.For<IManager>().Singleton().Use<DefaultManagerImplementation);x.For<IManagerService>().Use<DefaultManagerServiceImplementation>();我的问题是关于设置的DbContext实例，在IManagerService哪一个。 IManagerService：using(var ctx = new DbContext(AppSettings.ConnectionString){

问题一：软件设计模式主要有哪几种 创建型模式用来处理对象的创建过程，主要包含以下5种设计模式： ? 工厂方法模式（Factory Method Pattern） ? 抽象工厂模式（Abstract Factory Pattern） ? 建造者模式（Builder Pattern） ? 原型模式（Prototype Pattern） ? 单例模式（Singleton Pattern） 结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式： ? 适配器模式（Adapter Pattern） ? 桥接模式（Bridge Pattern） ? 组合模式（posite Pattern） ? 装饰者模式（Decorator Pattern） ? 外观模式（Facade Pattern） ? 享元模式（Flyweight Pattern） ? 代理模式（Proxy Pattern） 行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式： ? 责任链模式（Chain of Responsibility Pattern） ? 命令模式（mand Pattern） ? 解释器模式（Interpreter Pattern） ? 迭代器模式（Iterator Pattern） uf0d8 中介者模式（Mediator Pattern） ? 备忘录模式（Memento Pattern） ? 观察者模式（Observer Pattern） ? 状态模式（State Pattern） ? 策略模式（Strategy Pattern） ? 模板方法模式（Template Method Pattern） ? 访问者模式（Visitor Pattern） 问题二：软件开发的设计模式有哪些 最常用的是设计模式是工厂模式或者单例模式。 问题三：什么是软件设计模式 你好。 软件设计模式就是Uml统一建模语言的技巧性概念。主要研究各个类模块和接口之间的安排与搭配，也是为程序员提供亥流的一个很好的平台。 利用软件设计模式您可以做出质量更高，代码更少，扩充更容易的软件。我个人理解它更像是一个工具箱，可以让你生产出更漂亮、更简洁的代码。 我的回答您还满意吗？ 问题四：常见的软件开发模式和设计模式有哪些 MVC 这个是JAVA ee中就经常用到的模式 将数据模型、界面视图和业务逻辑控制分开的模式在Android开发中体现的最明显 数据模型一定单独 界面视图在布局中实现 业务控制单独编写，典型的MVC 问题五：软件工程中的设计模式都有哪些 Builder模式：比如AlertDialog.Builder。 适配器模式：比如GridView、ListView与Adapter。 命令模式：比如Handler.post。 享元模式：比如Message.obtain。 单例模式：比如InputMethodManager.getInstance。 观察者模式：比如ContentObserver。 这是一些经常用到的设计模式以及举例。 问题六：列出几种软件开发中常见的设计模式并解释 设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、mand，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、posite，组合模式：将对象组合成树形结构以表示部分整体的关系，posite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 二十一、Decrator，装饰顶式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。......>> 问题七：设计模式都有哪些? 设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、mand，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、posite，组合模式：将对象组合成树形结构以表示部分整体的关系，posite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。 二十二、Bridge，桥模式：将抽......>> 问题八：总共有几种设计模式？？？ 共有23种 简单工厂是设计模式中比较简单的创建型模式 其原理就是创建一个工厂类（接口），客户端调用的为接口的实现类，来实现代码的复用与简单恭耦，其实简单工厂也是工厂方法模式的一种特殊实现。 推荐你看篇文章，你就会更好的理解。 blog.csdn/ai92/article/details/209198 问题九：软件设计模式的四个要素 设计模式使人们可以更加简单方便地复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。模式名称一个助记名，它用一两个词来描述模式的问题、解决方案和效果。命名一个新的模式增加了我们的设计词汇。设计模式允许我们在较高的抽象层次上进行设计。基于一个模式词汇表，我们自己以及同事之间就可以讨论模式并在编写文档时使用它们。模式名可以帮助我们思考，便于我们与其他人交流设计思想及设计结果。找到恰当的模式名也是我们设计模式编目工作的难点之一。问题描述问题存在的前因后果，它可能描述了特定的设计问题，如怎样用对象表示算法等。也可能描述了导致不灵活设计的类或对象结构。有时候，问题部分会包括使用模式必须满足的一系列先决条件。解决方案描述了设计的组成成分，它们之间的相互关系及各自的职责和协作方式。因为模式就像一个模板，可应用于多种不同场合，所以解决方案并不描述一个特定而具体的设计或实现，而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合（类或对象组合）来解决这个问题。效果描述了模式应用的效果及使用模式应权衡的问题。尽管我们描述设计决策时，并不总提到模式效果，但它们对于评价设计选择和理解使用模式的代价及好处具有重要意义。软件效果大多关注对时间和空间的衡量，它们也表述了语言和实现问题。因为复用是面向对象设计的要素之一，所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响，显式地列出这些效果对理解和评价这些模式很有帮助。 问题十：有哪些比较好的设计模式 单例模式：这个是必须会的 观察者模式：这个最典型的应用就是mvc模式。 flyweight模式：这个也很常用 posite（组合）：这个很常见吧， 适配器模式：这个也很常用，比如我们一般会封装一些类库。然后成为我们用起来更方便的类。 其它的还很多的。总共23种。设计模式需要边学边用。很多不好理解。等以后觉得自己设计思路不太好了可以再翻翻。

如何进行供应链分析 如何进行供应链分析，在职场生活当中，供应商是指为企业生产和科研单位研发提供原料、设备及其他资源的企业，我们应该提前做好准备，以备不防之需，下面我整理了如何进行供应链分析。 如何进行供应链分析1 1、 什么是供应链 供应链这个术语形象地描述了产品或原材料从供应商到制造商、到分销商、再到零售商、直至顾客这一链条移动的过程。 供应链涵盖接受并满足顾客需求的全部功能，包括但不限于以下内容：新产品开发、市场营销、生产运作、分销、财务和顾客服务。 以便利店的系统流程为例： 2 、供应链目标 供应链的目标应该是供应链整体价值最大化。供应链所产生的价值（即供应链盈余）应为来自顾客的总收益与供应链消耗的总成本之差。 供应链盈余=顾客收益价值-供应链成本 3、 供应链流程观点 供应链是由一系列发生在不同环节内、不同环节间的流程和流组成，如下结构示意图： 供应链流程的循环观点 每一个循环发生在供应链两个相邻环节之间的界面上，即每个环节内都有自有的流程，且环节之间都有相应的交互。 供应链流程的推/拉观点 拉动流程：订单的执行依据顾客订货 推动流程：订单的执行依据对顾客订货的预测 企业中供应链的宏流程 供应链管理书中一般将供应链流程划分为如下三个宏流程： 客户关系宏流程的目的是产生顾客需求、发出订货并跟踪订货的过程，包括市场营销、定价、销售、订单管理和呼叫中心管理等流程。 内部供应链管理宏流程的主要目的是高效地以尽可能低的成本满足由客户关系管理流程产生的需求，包括选址和仓库能力计划，决定每个仓库都保存什么产品，制定库存管理策略，以及按订单取货、包装和发货。 供应商关系管理宏流程的主要目的是为不同的产品和服务安排和管理供货资源，包括为各种商品选择供应商、评价供应商、与供应商就价格和交付条款谈判、与供应商分享供给与需求计划、补货订单处理。 这三个宏流程控制着信息流、产品流、和资金流，以产生、接收和履行顾客订单。 4、 供应链战略匹配 战略匹配 公司层面一般具备竞争战略与供应链战略，战略匹配意味着竞争战略和供应链战略要有共同目标。 竞争战略一般与公司竞争对手息息相关，界定了需要通过本公司的产品和服务满足的顾客需求。供应链战略则关注原材料的获取、物料的运输、产品制造或所提供服务的运作、产品的分销、后续服务以及这些流程是由公司自行解决还是外包。 实现战略匹配目标： 竞争战略要和所有的职能战略相互匹配以形成协调统一的总体战略。任何一个职能战略必须支持其他职能战略，帮助公司实现竞争战略目标。 公司的不同职能部门必须恰当地构建本部门的流程以及配置资源，以成功执行这些战略。 整体供应链战略设计和各环节的作用必须协调一致，以支持供应链战略。 选择合适的供应链功能 每个顾客得需求都会影响潜在需求不确定性，针对潜在需求得不同程度可以区分不同特性得产品（如图2），不同特性得产品需要通过不同功能得供应链支持满足供给。 潜在需求不确定性低的产品一般具有品种少、批量大、较长生产周期的特点，对供应链的效率性要求高； 潜在需求不确定性高的产品一般具有多样化、批量灵活、订货提前期短等特点，此时对供应链的响应性要求高。 效率性对应的是效率性供应链（Efficient Supply Chain），是以降低供应链成本为目的的供应链。 响应性对应的是反应性供应链（Responsive Supply Chain，有时也称柔性），是追求快速响应客户的供应链。 现在最流行的分类是：精益供应链 Lean Supply Chain）和敏捷供应链（Agile Supply Chain）。 效率性供应链往往采取推式，也即预测驱动，由此展开供应链节点间的紧密协作，以降低销售、生产、物流、供应等成本，达成成本竞争优势。 反应性一般采取拉动式，也即订单拉动的模式（MTO），通过提高生产，供应、物流，销售的柔性和速度，实现对客户个性化多样化需求的快速反应。 当需求和供给都稳定确定时，匹配的是效率性供应链（ Efficient Supply Chain） 当需求和供给都不确定时，与之匹配的是敏捷性供应链（Agile Supply Chain） 而需求确定供给不确定时，匹配的是风险规避性供应链（Risk-hidging Supply Chain） 最后供给确定而需求不确定时，应该采取的是反应性供应链（Responsive Supply Chain） 如何进行供应链分析2 1、将数据转化为可操作的简单见解 网络技术服务商Extreme Networks公司首席信息官John Abel表示，大多数企业拥有着大量数据，这些数据通常存储在不同的系统和数据库中。他补充说，供应链的复杂性增加，是因为外包、物流和分销运营等扩展合作伙伴会产生额外的数据源。 Abel说，“因此，许多人难以使用这些数据来生成超出顶级指标和描述性统计数据的有意义的见解。数据分析工具可以提供更深入、可操作的见解，并提高这些见解的准确性。” Abel表示，供应链数据分析战略的成功基础，包括确保内部和外部数据以结构化格式汇集在一起;将数据项目的结果集中在需要采取哪些行动来推动绩效指标上;并确保其结果易于理解。 他说，“最后一点也是最重要的一点，通常倾向于关注使用的模型而不是输出。因为许多技术领导者希望将人工智能纳入他们的流程。但更重要的`目标是专注于生成清晰、可解释且易于被业务用户消化的见解。” 与跨职能团队共享的任何报告或仪表板都必须能够讲述一个易于理解的清晰故事。Abel说，“否则，数据分析的好处可能会因通过召开冗长的会议来解释其价值而黯然失色。” Abel说，“这反过来也起作用。虽然大多数数据分析专家对产生该数据的业务流程和系统没有深入的知识，但他们通常对上游和下游流程和系统有着广泛的了解，成功的供应链分析项目从‘数据告诉我们什么"的角度开始，然后深入了解业务流程。” 他表示，分析团队和业务用户之间的合作有助于开发这些可解释的见解，这些见解可以在整个企业中轻松传达。 2、专注于差异化领域的分析 咨询机构North Highland Worldwide Consulting公司全球供应链专家Erik Singleton表示，很多供应链企业正被客户订单、项目信息、设备利用率和不断变化的运输成本等数据所困扰。 Singleton说，“这些公司需要建立一个成功的以客户为中心的供应链，同时最大限度地提高运营效率的关键是使用正确的分析来做出数据驱动的决策。” 他建议，供应链企业将分析重点放在三个主要领域： 一是需求计划和库存放置。Singleton说，“企业通过收集数百万行交易数据，从而能够对客户购买模式进行有力的分析。利用这些数据构建强大的分析算法，以推动整个供应链的库存配置，确保产品在正确的时间出现在正确的位置。企业应将分析资源集中在预测产品类型、销售渠道和地理位置之间的需求模式上。” 第二个领域是运营效率。Singleton说，“客户和订单数据通过有效调度资源以适应波动的需求模式，使供应链能够最大限度地利用资产和劳动力。调整劳动力计划以在高峰期增加资源，同时在低谷期安排设备/资产的维护，使企业能够最大限度地提高效率，并降低运营成本。” 第三个领域是订单履行路径决策。Singleton说，“客户希望供应链比以往任何时候都更加灵活和以客户为中心，产品可以通过多种途径到达最终客户。企业需要平衡多种因素，包括服务预期、运输和履行成本以及库存水平，以确定订单履行的最佳方法。” Singleton表示，利用分析来权衡成本与客户体验对于保持竞争力至关重要。 3、利用实时数据处理中断 Abel表示，随着全球供应链的规模和复杂性都在增长，管理和应对整个供应链的波动变得越来越困难。 Abel说，“随着数据点的快速变化，分析和决策通常基于过时的信息，并且由于有效分析数据所需的时间而进一步加剧。为了成功地驾驭这一点，供应链经理需要开发并行计划系统，通过利用高级分析和整个供应链的实时可见性来优化需求和供应。” Abel表示，从历史上看，更新基于特定的时间范围，并且可能每天或每小时共享一次。他说，“但现在的措施还不够，由于需求和供应不断波动，因此最好与主要供应商进行系统集成，以便实时获取更新。” 如果供应商发生变化，企业需要立即了解潜在影响，以便制定替代计划以维持对客户的承诺。Abel说，“对实时数据馈送使用高级分析，使管理供应链的人员能够快速建模和评估潜在中断的影响，因此他们可以计划和执行需求、供应和库存的波动。” Abel指出，这些见解还可以用来理解供应链约束对收入预测的潜在影响。预订、发货、库存水平、供应商承诺、折扣和管道销售机会等数据的近实时可见性，以及对这些数据的实时分析，对于企业监控和管理收入预测的能力至关重要。 Abel说，“通过使用高级分析和自动化，这些可变数据输入可用于创建跟踪模型，使供应链团队能够近乎实时地对变化做出反应，制定应急措施，并提供更准确的收入预测。” 如何进行供应链分析3 供应商管理及其作用 供应商是指为企业生产和科研单位研发提供原料、设备及其他资源的企业 , 供应商既可以是生产企业 , 也可以是流通企业。企业要保证正常的生产 ,科研要保证研究过程的不间断 , 就必须有一批可靠的供应商为其提供必需的物资供应 , 其重要地位由此可见。供应商管理的目的 , 就是要建立一个稳定可靠的供应商管理队伍 , 为最终客户提供高质量的 快捷服务保障。好的供应商是高质量的保证 , 卓越的供应商是组织的一项重要资产 , 将为购买其产品或服务的组织带来丰厚的回报。为了营造良好的供应商关系 , 克服传统的供应商关系观念 , 供应商管理便成为一项非常有价值的工作。 建立采购方、 供应商新型的合作关系 采购方、供应商是同一个价值链的两个节点成员 , 这个价值链是有机联系的整体 , 在这个价值链上 ,产品与服务的最低消费者对成本、 质量、 服务等要求成为链中所有参与成员共同追求的绩效管理目标。 作为链上的成员 , 在考虑自身利益的同时 , 要兼顾其他成员的利益 , 保证自己的合理利润 , 才是链上各成员发展的长久之计。 采供双方必须充分考虑这一利益准则 , 建立良好的合作关系。 采购方、 供应商良好的合作关系使采供关系逐步摆脱了传统模式 , 逐渐形成有利于采供双方共同获益的新的关系模式。

2种public class Singleton { private static Singleton instance = new Singleton(); private Singleton(){ } public static Singleton getInstance(){ return instance; } }和public class Singleton { private static Singleton instance = null; private Singleton(){ } public static Singleton getInstance(){ if(instance==null){ instance = new Singleton(); } return instance; } }

有关单例模式的描述正确的是单例模式必须在只有一个实例是才应当使用。单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例）数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”。单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。

本文开始整个设计模式的系列学习，希望通过不断的学习，可以对设计模式有整体的掌握，并在项目中根据实际的情况加以利用。 单例模式是指一个类仅允许创建其自身的一个实例，并提供对该实例的访问权限。它包含静态变量，可以容纳其自身的唯一和私有实例。它被应用于这种场景——用户希望类的实例被约束为一个对象。在需要单个对象来协调整个系统时，它会很有帮助。 1、单例类只能有一个实例 2、单例类必须自己创建自己的唯一实例 3、单例类必须给其他所有对象提供这一实例 1.尽量使用懒加载 2.双重检索实现线程安全 3.构造方法为private 4.定义静态的Singleton instance对象和getInstance()方法 单例模式至少有六种写法。 作为一种重要的设计模式，单例模式的好处有： 1、控制资源的使用，通过线程同步来控制资源的并发访问 2、控制实例的产生，以达到节约资源的目的 3、控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信 Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。但其实通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。 虽然也是只有一个线程能够执行，假如线程B先执行，线程B获得锁，线程B执行完之后，线程 A获得锁，但是此时没有检查singleton是否为空就直接执行了，所以还会出现两个singleton实例的情况。 既然懒汉式是非线程安全的，那就要改进它。最直接的想法是，给getInstance方法加锁不就好了，但是我们不需要给方法全部加锁啊，只需要给方法的一部分加锁就好了。基于这个考虑，引入了双检锁（Double Check Lock，简称DCL）的写法： 使用volatile 的原因： 对于JVM而言，它执行的是一个个Java指令。在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间， 然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例： 加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。 枚举类实现单例模式是 effective java 作者极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。因为枚举类没有构造方法，可以防止反序列化操作。 1、除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象，所以如果我们想要阻止单例破坏，可以在构造方法中进行判断，若已有实例, 则阻止生成新的实例，解决办法如下: 2、如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例，所以我们可以不实现序列化接口,如果非得实现序列化接口，可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。 Runtime是一个典型的例子，看下JDK API对于这个类的解释"每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接，可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的Runtime类实例。"，这段话，有两点很重要： 1、每个应用程序都有一个Runtime类实例 2、应用程序不能创建自己的Runtime类实例 只有一个、不能自己创建，是不是典型的单例模式？看一下，Runtime类的写法： 为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，我们无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，我们可以通过单例模式来实现。 单例模式应用的场景一般发现在以下条件下： 　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。 　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。 关于单例模式的漫画分析： https://mp.weixin.qq.com/s/f-sJIZHr7JUa31gKTllSFQ 单例模式的优缺点、注意事项、使用场景

面向对象，区别于c的面向过程

spring2.5之前用 singleton=“false“；2.5或更新版本用scope="singleton"

单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。　　单例模式(singleton)顾名思义，就是只有一个实例。 　　 作为对象的创建模式[GOF95]， 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 　　单例模式的要点 　　显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。 　　一些资源管理器常常设计成单例模式。 　　在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler， 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡，但是只应该有一个软件负责管理传真卡，以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。 　　需要管理的资源包括软件内部资源，譬如，大多数的软件都有一个（甚至多个）属性（properties）文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。 　　需要管理的软件内部资源也包括譬如负责记录网站来访人数的部件，记录软件系统内部事件、出错信息的部件，或是对系统的表现进行检查的部件等。这些部件都必须集中管理，不可政出多头。 　　这些资源管理器构件必须只有一个实例，这是其一；它们必须自行初始化，这是其二；允许整个系统访问自己这是其三。因此，它们都满足单例模式的条件，是单例模式的应用。 　　在java中，可以使用以下这种方式使用单例模式创建类的实例： 　　public class MyBean { 　　private static MyBean instance = null; 　　private MyBean(){ 　　//do something 　　} 　　public static synchronized MyBean getInstance(){ 　　if(instance == null){ 　　instance = new MyBean(); 　　} 　　return instance; 　　} 　　} 　　当一个类的实例可以有且只可以一个的时候就需要用到了。为什么只需要有一个呢？有人说是为了节约内存。本人对这个说法持保留态度。只有一个实例确实减少内存占用，可是我认为这不是使用单例模式的理由。我认为使用单例模式的时机是当实例存在多个会引起程序逻辑错误的时候。比如类似有序的号码生成器这样的东西，怎么可以允许一个应用上存在多个呢？ 　　Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 　　一般Singleton模式通常有两种形式: 　　第一种形式: 也是常用的形式。 　　public class Singleton { 　　private static Singleton instance = null; 　　private Singleton(){ 　　//do something 　　} 　　public static Singleton getInstance(){ 　　if(instance==null){ 　　instance = new Singleton(); 　　} 　　return instance; 　　} 　　} //这个方法比下面的有所改进，不用每次都进行生成对象，只是第一次使用时生成实例，提高了效率 　　第二种形式: 　　public class Singleton { 　　//在自己内部定义自己的一个实例，只供内部调用 　　private static Singleton instance = new Singleton(); 　　private Singleton(){ 　　//do something 　　} 　　//这里提供了一个供外部访问本class的静态方法，可以直接访问 　　public static Singleton getInstance(){ 　　return instance; 　　} 　　} 　　Flex中的单例模式 　　Flex中单例模式,常见的model层实例: 　　package models 　　{ 　　import flash.events.EventDispatcher; 　　import mx.collections.ArrayCollection; 　　import vo.articlesVO; 　　import vo.linksVO; 　　[Bindable] 　　public class ModelLocator extends EventDispatcher 　　{ 　　public static var _instance:ModelLocator; 　　public static function getInstance():ModelLocator{ 　　if(_instance == null){ 　　_instance = new ModelLocator(); 　　} 　　return _instance; 　　} 　　public var total:int; 　　public var isLogin:Boolean = false; 　　public var articles:ArrayCollection; 　　public var selectedArticle:articlesVO; 　　public var categories:ArrayCollection; 　　public var links:ArrayCollection; 　　public var selectedLink:linksVO; 　　} 　　} 　　类中自己完成了自身的实例。。 　　<mx:Script> 　　<![CDATA[ 　　import models.ModelLocator; 　　internal function initApp():void{ 　　var instance:ModelLocator = ModelLocator.getInstance(); 　　trace(instance.isLogin);//获得isLogin 　　} 　　]]> 　　</mx:Script> 　　C#中的单例模式 　　#region 用法说明 //保证一个类仅有一个实例，并提供一个访问它的全局访问点 　　// 实现要点 　　// Singleton模式是限制而不是改进类的创建。 　　// Singleton类中的实例构造器可以设置为Protected以允许子类派生。 　　// Singleton模式一般不要支持Icloneable接口，因为这可能导致多个对象实例，与Singleton模式的初衷违背。 　　// Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初衷违背。 　　// Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来讲，我们一般没必要对其销毁进行特殊的管理。 　　// 理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。 　　// 可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。 　　//优点 　　// 实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象都访问唯一实例 　　// 灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程 　　//缺点 　　// 开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题，上面的五种实现方式中已经说过了。 　　// 可能的开发混淆：使用 singleton 对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用 new 关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。 　　// 对象的生存期：Singleton 不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于 .NET Framework 的语言），只有 Singleton 类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除 　　//对象实例，但这样会导致 Singleton 类中出现悬浮引用。 　　//适用性 　　// 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 　　// 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。 　　//应用场景 　　// 每台计算机可以有若干个打印机，但只能有一个Printer Spooler，避免两个打印作业同时输出到打印机。 　　//（摘自吕震宇的C#设计模式（7）－Singleton Pattern） 　　// PC机中可能有几个串口，但只能有一个COM1口的实例。 　　// 系统中只能有一个窗口管理器。 　　// .NET Remoting中服务器激活对象中的Sigleton对象，确保所有的客户程序的请求都只有一个实例来处理。 　　#endregion 　　//regret4hxp add 2011-1-12 　　单例模式的实现要素： 　　至少在目前所有了解的语言中，静态变量(这是c/c++的叫法，其他语言或有不同)是实现单例模式的要素。

那个男人，她认出来岂的确体质

单例模式

设计模式不是对时间长常，更新频繁的项目才用吗？

其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 例如：随处可见，比如Servlet，sprigMVC创建时都是单例多线程的。完美的实例是：private static Singleton instance = new Singleton(); 创建线程的方式有很多种，但是很多都扛不住多线程的检验，上面是简单又实用的例子，多线程下也是安全的。 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 例如：虽然简单工厂（静态工厂）没有进入23种设计模式，但是java web中的很多配置文件玩的还是它。Spring中下面三种方式实例化bean： 1.使用类构造器实例化 <bean id="orderService" class="cn.itcast.OrderServiceBean"/> 2.使用静态工厂方法实例化　　<bean id="personService" class="cn.itcast.service.OrderFactory" factory- method="createOrder"/>　　public class OrderFactory { 　　public static OrderServiceBean createOrder(){ 　　 return new OrderServiceBean(); 　　}　　} 3.使用实例工厂方法实例化: <bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/> <bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/> public class OrderFactory { public OrderServiceBean createOrder(){ return new OrderServiceBean(); } } 第一种方法，IOC容易直接根据配置文件中的class属性通过反射创建一个实例，使用的是该类的默认构造方法。第二种则是调用class指定的工厂类的工厂方法，来返回一个相应的bean实例，值得注意的是工厂类的方法是静态方法，所以不用产生工厂本身的实例。而第三种则不同，它除了配置与第二种相同外，唯一的不同就是方法不是静态的，所以创建bean的实例对象时需要先生成工厂类的实例。实例了bean对象时，需要对其中的属性也进行赋值，这时就是经常被提及的依赖注入。以上其实有错误：Spring很多情况下创建对象很定是反射呀，尤其是注解和DI（依赖注入），小朋友，想什么呢？肯定不是用new()来创建：Class c = Class.forName("cn.itcast.OrderServiceBean");Object bean = c.newInstance(); 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 例如：jdk中的各种容器类的基础模式 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 例如：据说是jdk使用最多的模式,好比邮件订阅或RSS订阅 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 例如：comparator 比较器的实现利用了此模式 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 。此处强调一点就是，链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象例如：struts2 interceptor 用到的就是是责任链模式 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，facade提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问。例如：经典的体现在Spring AOP切面中，Spring中利用了俩种代理类型。其实，代理也分为静态和动态，但是我们一般常用动态，因为静态代理秀不起来 二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。 其中对象的适配器模式是各种结构型模式的起源，分为三种：类，对象，接口的适配器模式。结一下三种适配器模式的应用场景：类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。例如：java io流中大量使用 二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。 对比：适配器模式主要是为了接口的转换，而装饰者模式关注的是通过组合来动态的为被装饰者注入新的功能或行为(即所谓的责任)。 二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。 二十三、Flyweight，享元模式：主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。例如：数据库连接池便是这个原理

C++ 中所有类中的静态变量声明，需要对其进行定义。你需要找一个cpp文件，在你的例子中，最好是CSingleton.cpp 中，加上一行static CSingleton *CSingleton::m_pInstance = NULL;楼下两个说的都不对哦，对C++的理解有问题。并不是需要初始化。类的定义中的变量声明只是声明，并没有“定义”。声明是指明变量的类型，访问修饰等等。而定义是指真正给变量定义其存储空间。类中的非静态成员变量，只需要声明，因为其“定义”也就是定义其真正内存空间的过程，是在类实例对象创建的过程中做的。但是类中的静态成员变量，因为不是类实例对象的结构组成部分，所以需要预先“定义”，也就是为其分配存储空间，因为他是静态变量，所以要在全局空间定义。至于是否初始化，只是影响运行中的逻辑状态，也就是说，如果不初始化，会导致这个变量的初始值是随机的，那么在 if(CSingleton::m_pInstance == NULL) 这个判断的时候会产生不可预测的结果，但是编译时只会报警告，链接也不会报错。

单例模式本身不就是有两种模式可以选择么

1. 抽象工厂模式，Builder模式和Prototype模式可以在他们的实现中使用单例模式2. Facade对象通常是Singleton因为一般之需要一个Facade对象就行了3. 状态Bean通常是Singleton4. 在操作外部资源如打印机或者文件时，需要使用Singleton以保证没有对外部资源的并发操作。单例模式的例子：public class Singleton {// 私有的构造方法可以防止单例在其他类中被构造private Singleton() {}/*** SingletonHolder 在初次执行Singleton.getInstance()后者初次第一次访问SingletonHolder.INSTANCE的时候被加载*/private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}public static Singleton getInstance() {return SingletonHolder.INSTANCE;}}

单例模式实现：class Singleton{private static Singleton s;private Singleton(){};public static Singleton getInstance{if(s==null)s=new Singleton();return s;}}原理：singleton的构造函数私有化导致该类不能直接new内置一个私有静态实例s和公有方法getInstance,保证输出的实例为同一个实例

作用域随便搜搜也就知道了，基本都是用单例，特殊情况可以用每次请求一个实例，还有一个会话一个实例等等搜搜了解下怎么回事需要注意什么，说白了就是要搞清楚单例和非单例的区别，以及什么情况下可以默认单例单例很明显节省内存，而且由spring管理，服务启动时就预加载了，运行时就没有了创建和销毁的消耗，所以肯定是尽量用单例既然用单例就一定要考虑并发情况下安全问题(多线程操纵一个实例会不会有问题，怎么才能没问题)。显然的，并发安全问题在于资源竞争，只要单例的类没有成员变量，对它自己来说就是安全的(通过它去竞争别的资源跟它没关系)说个最简单的例子，controller,service这些，基本都只是操作，不会带成员变量这种有状态的东西，所以就默认单例。但是他们操作的domain，每一个实体都是不一样的，肯定不会把它弄个单例交给spring

给你个代码看下吧。更直观一些<?phpclass db{ private static $instance=false; public static function instance($host,$name,$pass,$dbname) { if(self::$instance===false) { self::$instance=new db(......); } return self::$instance; } private function __construct() { /*这个函数必须是私有的，它保证了只能通过单例生成器来获得实例*/ } public function __clone() { /*什么也不做*/ }}?> 外部调用的时候，调用那个instance函数 ，以保证他的唯一性

class Danli{ String name;//一个公共属性 //私有静态对象并初始化为null private static Danli danli=null; //私有构造方法，确保外部不能调用构造函数 private Danli(){ } //构造一个公用函数，实例化对象，供外部调用 public static Danli get(){ if(danli==null){ danli=new Danli(); } return danli; }}public class test2 { public static void main(String[] args) { //外部调用单例模式 Danli dl=Danli.get(); dl.name="java"; System.out.println(dl.name); }}

class Singleton{public: static Singleton * Instance() { if( 0== _instance) { _instance = new Singleton; } return _instance; }protected: Singleton(void) { } virtual ~Singleton(void) { } static Singleton* _instance;};

你可以使用单例模式public class Singleton{ private static Singleton instance = new Singleton(); private Singleton(){}//私有化构造方法 public static Singleton getInstance() { return instance; }}

单例模式不自带线程安全的功能。你上面的getInstance只是在创建的时候能够防止创建出两个实例。printCount不是线程安全的

去掉public的构造函数。可以去搜索一下单例模式，就是解决你这个需求的

bean就相当于定义一个组件，这个组件是用于具体实现某个功能的。这里的所定义的bean就相当于给了你一个简洁方便的方法来调用这个组件实现你要完成的功能。x0dx0a x0dx0a在Spring中，从BeanFactory或ApplicationContext取得的实例被默认为Singleton，也就是默认每一个Bean名称只维持一个实例。scope属性预设是"singleton",通过将其设置为"prototype"，使得每次指定名称来取得Bean时，都会产生一个新的实例。也可以设置"singleton"属性为true或false，来设置以Singleton的方式产生实例，这种方式主要与以前的版本兼容而保留的。x0dx0ax0dx0a Spring的Singleton主要是针对"一个IoC容器维持一个Bean实例"而言的。与设计模式上谈到的Singleton不同，设计模式上谈到的Singleton，是指对每个ClassLoader所载入的类产生一个实例。x0dx0ax0dx0a Spring2.0中，scope除了可以设置"singleton" 与"prototype"之外，针对Web应用程序环境，还可以设置"request"、"session"与"globalSession"，分别表示请求阶段、会话阶段与基于Portlet的Web应用程序会话阶段。

单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。1、懒汉写法，常用写法class LazySingleton{ private static LazySingleton singleton; private LazySingleton(){ } public static LazySingleton getInstance(){ if(singleton==null){ singleton=new LazySingleton(); } return singleton; } }2、恶汉写法，缺点是没有达到lazyloading的效果class HungrySingleton{ private static HungrySingleton singleton=new HungrySingleton(); private HungrySingleton(){} public static HungrySingleton getInstance(){ return singleton; }}3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazyloadingclass InternalSingleton{ private static class SingletonHolder{ private final static InternalSingleton INSTANCE=new InternalSingleton(); } private InternalSingleton(){} public static InternalSingleton getInstance(){ return SingletonHolder.INSTANCE; }}4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象enum EnumSingleton{ INSTANCE; public void doSomeThing(){ }}5、双重校验锁，在当前的内存模型中无效class LockSingleton{ private volatile static LockSingleton singleton; private LockSingleton(){} //详见： public static LockSingleton getInstance(){ if(singleton==null){ synchronized(LockSingleton.class){ if(singleton==null){ singleton=new LockSingleton(); } } } return singleton; }}参考自：snippet_107039_6062

In shotgun DNA sequencing projects, a contig (from contiguous) is a set of overlapping DNA segments derived from a single genetic source. a single gene or marker that identifies the comparable region in a target genome, but does not cluster with other genes or markers to form a segment is called a singleton.

一、在二叉树中寻找值最大的节点并返回： 给出如下一棵二叉树： 返回值为 3 的节点。 简析：使用了递归的思想；注意为空的判断； 二、单例 单例 是最为最常见的设计模式之一。对于任何时刻，如果某个类只存在且最多存在一个具体的实例，那么我们称这种设计模式为单例。例如，对于 class Mouse (不是动物的mouse哦)，我们应将其设计为 singleton 模式。 你的任务是设计一个 getInstance 方法，对于给定的类，每次调用 getInstance 时，都可得到同一个实例。 样例： 在 Java 中: A a = A.getInstance(); A b = A.getInstance(); a 应等于 b. 挑战： 如果并发的调用 getInstance，你的程序也可以正确的执行么？ } 注意：实现一个单例有两点注意事项，①将构造器私有，不允许外界通过构造器创建对象；②通过公开的静态方法向外界返回类的唯一实例 参考：单例模式的几种写法对比： http://wuchong.me/blog/2014/08/28/how-to-correctly-write-singleton-pattern/ 三、整数排序 给一组整数，按照升序排序，使用选择排序，冒泡排序，插入排序或者任何 O(n2) 的排序算法。 样例： 对于数组 [3, 2, 1, 4, 5], 排序后为：[1, 2, 3, 4, 5]。 答案(java版本)： 选择排序： 冒泡排序： 答案解析： 各个语言的实现请参考维基百科： https://zh.wikipedia.org/wiki/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F ** 四、斐波那契数列** 查找斐波纳契数列中第 N 个数。所谓的斐波纳契数列是指： 前2个数是 0 和 1 。 第 i 个数是第 i-1 个数和第i-2 个数的和。 斐波纳契数列的前10个数字是： 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ... 答案： 注意事项： 1、n是从1开始的，而不是0 2、一般我们都会想到用递归的方式实现，但是这个时间开销很大： 3、题目的引申: 青蛙跳阶梯 ，铺方砖 参考： http://www.bubuko.com/infodetail-1099705.html