精华内容
下载资源
问答
  • 多例模式

    万次阅读 多人点赞 2014-08-06 15:32:38
    转载请注明出处!!!http://blog.csdn.net/zhonghuan1992 ...  跟着ZHONGHuan学习设计模式 多例模式 介绍:  所谓的多例模式,实际上就是单例模式(回顾看这里)的自然推广,作为对象的创建模式,

    转载请注明出处!!!http://blog.csdn.net/zhonghuan1992

             所有配套代码均在github上:https://github.com/ZHONGHuanGit/DesignPattern

     

    跟着ZHONGHuan学习设计模式

    多例模式

    介绍:

             所谓的多例模式,实际上就是单例模式(回顾看这里)的自然推广,作为对象的创建模式,多例模式有以下特点:

             1可以有多个实例

             2多例类必须自己创建,管理自己的实例,并向外界提供自己的实例。

     

             从上面的特点中,可以体会多例模式与单例模式的不同。单例模式只允许一个实例的存在。

    单例类图:

    多例类图:

             类图更直观的表示了多例类,该多例类会提供多个实例,实例的数量我们是可以自己控制的,如果数量不多的话,实例就可以当做是类的内部实例变量;如果实例很多,那么可以用数组,或者可变长度的数组来进行存储。下面看有上限的多例类。

     

    有上限多例类:

             有上限的多例类,名字很清楚的说明白了,该类实例数量是有上限的,通常这个上限是由程序员控制的。我们用筛子来举例。

             不知道大家打不打麻将,我想麻将是中国广大群众的一种休闲方式。也许各地的打法会有些许的不同。但一般打麻将都需要置筛子。有时筛子是1个,有时是两个,也有可能是3个。这里假定2个筛子。因为筛子的数量确定是2,所以这是一个上限为2的多例类。

     

    示例程序的类图:

    示例程序代码:

    import java.util.Random;
    
    class Die{
    	private static Die die1=new Die();//筛子1
    	private static Die die2=new Die();//筛子2
    	private Die(){
    		//私有的构造子保证外界无法将此类实例化
    	}
    	//获取筛子方法,类似简单工厂模式,通过tag决定返回哪个筛子
    	public static Die getDie(int tag){
    		if(tag==1)
    			return die1;
    		if(tag==2)
    			return die2;
    		return null;
    	}
    	//掷筛子,返回一个1~6的随机数字。
    	public synchronized int dice(){
    		Random random=new Random();
    		return random.nextInt(6)+1;
    	}
    }
    
    public class Main{
    	private static Die die1,die2;
    	public static void main(String[] args){
    		 die1 = Die.getDie(1);
    		 die2 = Die.getDie(2);
    		 System.out.println("筛子1的值是"+ die1.dice());
    		 System.out.println("筛子2的值是"+ die2.dice());
    	}
    }
    




     

    无上限的多例类:

             顾名思义,就是多例类的实例数量没有上限,笔者暂时没有好的例子,如果你有,请告诉我。

     

     

     

     

     

    展开全文
  • MultitionPattern代理模式细说多例模式多例类场景场景一:场景二:上代码代码一代码二 细说多例模式 提示: 博主:章飞 _906285288的博客 博客地址:http://blog.csdn.net/qq_29924041 ## 细说多例模式 结合单例...

    细说多例模式

    提示:
    博主:章飞 _906285288的博客
    博客地址:http://blog.csdn.net/qq_29924041


    ## 细说多例模式

    结合单例模式来说多例模式,单例模式相对来说比较容易理解一点,也就是在整个应用程序运行过程中,这个类的实例永远都是一个,好比如历朝历代,皇帝在大多数情况下都是只有一个,但是往往在程序运行过程中,我可能为了达到复用的效果,需要在一个池子中去选择对应的实例进行使用,这个时候多例模式也就应运而生了。

    所谓多例模式其实也就是类的对象实例是有多个,但是这个多个也要区别于无限个,当然,如果一个类的对象可以有无限个的话,那能不能叫多例呢??这个可能就需要区别多例模式的特点了

    所谓多例(Multiton Pattern)实际上就是单例模式的自然推广,属于对象
    创建类型的模式,多例模式其实就是限制了对象的数量,并且有可能对对象进行重复使用

    特点:
    1:多例可以有多个实例
    2: 多例类必须能够自我创建并管理自己的实例,并且向外界提供自己的实例

    多例类场景

    场景一:

    引用设计模式之禅中的案例,一般情况下,一个王朝的皇帝其实都是只有一个,但是在历史上,大明王朝在土木堡之变中被瓦刺俘虏的皇帝,皇帝突然有两个,一个执政,另外一个则被俘虏了。当俘虏皇帝获救之后,这个时候王朝有两个皇帝。这两个皇帝其实也就对应了两个对象实例,多例模式下的现实场景。

    场景二:

    在java学习过程中,有一个池子的概念一直存在,好比作线程池,数据库连接池,这个池子是用来对线程,或者数据库连接对象进行管理的,第一,限制了池子中的对象数量,第二就是能够在使用过程中达到复用的效果,线程中的线程在执行完毕后,不会被直接回收掉,而会切换成等待状态,等待下一个任务提交,执行。数据库连接池也是如此,数据库操作在连接的时候,如果对数据库操作完毕后,会把资源释放,然后等待下一个数据库操作进行连接。这种设计其实是将对象的应用最大化了,避免了每次连接的时候都需要去创建一个对象。造成对象冗余或者内存升高。

    上代码

    代码一

    package src.com.zzf.designpattern.multitionpattern.demo1;
    
    
    import java.util.ArrayList;
    import java.util.Random;
    
    public class Emperor {
    	private static final int maxNumberOfEmperor = 2;
    	private static ArrayList emperorInfoList = new ArrayList(maxNumberOfEmperor);
    	private static ArrayList emperorList = new ArrayList(maxNumberOfEmperor);
    	
    	private static int countNumofEmperor = 0;
    	
    	static{
    		for(int i = 0; i < maxNumberOfEmperor ; i++){
    			emperorList.add(new Emperor("第"+i+"皇帝"));
    		}
    	}
    	
    	
    	private Emperor(){
    		
    	}
    	
    	private Emperor(String info){
    		emperorInfoList.add(info);
    	}
    	
    	public static Emperor getInstance(int num){
    		countNumofEmperor = num;
    		if (num == 0) {
    			return (Emperor) emperorList.get(0);
    		}else if(num == 1){
    			return (Emperor) emperorList.get(1);
    		}else{
    			System.out.println("error");
    			return null;
    		}
    	}
    	
    	  public static Emperor getInstance(){  
    	        Random random=new Random();  
    	        countNumofEmperor=random.nextInt(maxNumberOfEmperor);  
    	        return (Emperor)emperorList.get(countNumofEmperor);  
    	  }  
    	
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return (String) emperorInfoList.get(countNumofEmperor);
    	}
    }
    
    
    package src.com.zzf.designpattern.multitionpattern.demo1;
    
    
    /**
     *多例模式
     *所谓多例(Multiton Pattern)实际上就是单例模式的自然推广,属于对象
     *创建类型的模式,多例模式其实就是限制了对象的数量,并且有可能对对象进行重复使用
     *
     *特点:
     *1:多例可以有多个实例
     *2:多例类必须能够自我创建并管理自己的实例,并且向外界提供自己的实例
     * @author Administrator
     *
     */
    public class MultiPatternTest {
    	public static void main(String[] args) {
    		Emperor mEmperor = Emperor.getInstance(0);
    		System.out.println(mEmperor.toString());
    		mEmperor = Emperor.getInstance(1);
    		System.out.println(mEmperor.toString());
    		mEmperor = Emperor.getInstance(2);
    	}
    }
    

    代码二

    package src.com.zzf.designpattern.multitionpattern.demo2;
    
    import java.util.ArrayList;
    import java.util.Random;
    
    public class SQLConnectionPools {
    	private static int maxNumOfConnection= 8;
    	private static ArrayList<String> connectionInfoList = new ArrayList<>(maxNumOfConnection);
    	private static ArrayList<SQLConnectionPools> connArrayList = new ArrayList<>(maxNumOfConnection);
    	private static int currNumOfConnection =0;
    	
    	private SQLConnectionPools() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	private SQLConnectionPools(String info) {
    		connectionInfoList.add(info);
    	}
    	
    	static{
    		for (int i = 0; i < maxNumOfConnection; i++) {
    			connArrayList.add(new SQLConnectionPools(i+"号连接"));
    		}
    	}
    	
    	public static SQLConnectionPools getInstance() {
    		Random random = new Random();
    		currNumOfConnection = random.nextInt(maxNumOfConnection);
    		return connArrayList.get(currNumOfConnection);
    	}
    	
    	public void connectionInfo() {
    		System.out.println(connectionInfoList.get(currNumOfConnection));
    	}
    	
    }
    
    
    package src.com.zzf.designpattern.multitionpattern.demo2;
    
    public class Client {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		 int userNum=10;  
    	        for(int i=0;i<userNum;i++){  
    	            //用户获取到的连接时随机的  
    	            SQLConnectionPools conn= SQLConnectionPools.getInstance();  
    	            System.out.print("第"+i+"个用户获得的连接是:");  
    	            conn.connectionInfo();  
    	        }  
    	}
    
    }
    
    

    多例模式相对来说也是比较简单,现实生活场景中也有很多场景案例。所以也不过多的赘述,案例也简单的一批。如果我想打造一个属于自己的资源池,达到对象复用的效果,结合状态模式等,可以打造出属于自己的复用池。




    欢迎继续访问,我的博客

    展开全文
  • JAVA设计模式-创建模式-多例模式

    千次阅读 2020-07-05 09:06:21
    什么是多例模式?为什么要有多例模式模模式的实现方式鸣谢 为什么要有设计模式? 一个有价值的系统总是会因为需求的变化而变化,可能是原有需求的修改,也可能是新需求的增加。于是可怜的猿们就得修改原来的代码...

    为什么要有设计模式?

    一个有价值的系统总是会因为需求的变化而变化,可能是原有需求的修改,也可能是新需求的增加。于是可怜的猿们就得修改原来的代码。好的架构和设计可以让我们的代码结构具有良好的扩展性,在满足需求变化的同时仅需要修改尽可能少的代码,可以将需求变化对原系统的影响降到很低。设计模式就是人们对于良性架构设计的经验总结。

    什么是多例模式?

    多例模式其实是单例模式的推广,一个类允许有限个实例,并且由这个类自己创建,管理和提供实例。

    为什么要有多例模式?

    还用我在单例模式里的例子,系统需要把配置放在配置文件,并且需要一个读取配置的工具类,但是这次是有多个配置文件,因为很多时候把整个系统的配置全部放在一个配置文件不合理,有些配置是全局模块都会用的,有的配置仅仅是局部一个或几个模块使用。所以每个配置文件应当有一个配置管理器的实例。

    多例模式的实现方式

    /**
     * 枚举发方式的多例配置管理器
     */
    public class ConfigManager {
    
    	public enum ConfigType {
    		DB_CONFIG("db.cfg"),
    		CACHE_CONFIG("cache.cfg"),
    		EMAIL_CONFIG("email.cfg"),
    		;
    
    		private final String        configFileName;
    		private final ConfigManager instance;
    
    		ConfigType(String configFileName) {
    			this.configFileName = configFileName;
    			this.instance = new ConfigManager(configFileName);
    		}
    	}
    
    	/**
    	 * 将配置读取到内存
    	 */
    	private final Properties configs;
    
    	private ConfigManager(String configFileName) {
    		System.out.println("实例化配置管理器:" + configFileName);
    		configs = new Properties();
    		try {
    			configs.load(ConfigManager.class.getClassLoader().getResourceAsStream(configFileName));
    		} catch (IOException e) {
    			throw new RuntimeException(e.getMessage(), e);
    		}
    	}
    
    	/**
    	 * 取得配置文件名
    	 * @return
    	 */
    	public static String getConfigFileName(ConfigType configType) {
    		return configType.configFileName;
    	}
    
    	/**
    	 * 取得实例
    	 * @return
    	 */
    	public static ConfigManager getInstance(ConfigType configType) {
    		return configType.instance;
    	}
    
    	/**
    	 * 取得配置
    	 * @param configKey
    	 * @return
    	 */
    	public String getConfigValue(String configKey) {
    		return configs.getProperty(configKey);
    	}
    }
    
    /**
     * 客户端
     */
    public class CacheClient {
    
    	/**
    	 * 打印配置文件名
    	 */
    	public void printConfigFileName() {
    		System.out.println("配置文件名:" + ConfigManager.getConfigFileName(ConfigManager.ConfigType.CACHE_CONFIG));
    	}
    
    	/**
    	 * 打印配置值
    	 * @param key
    	 */
    	public void printConfigValue(String key) {
    		System.out.println(ConfigManager.getInstance(ConfigManager.ConfigType.CACHE_CONFIG).getConfigValue(key));
    	}
    
    	public static void main(String[] args) {
    		CacheClient client = new CacheClient();
    		client.printConfigFileName();
    		client.printConfigValue("key1");
    	}
    }
    

    运行结果

    这里我仅仅使用了枚举方式,其实其他单例的实现方式都可以扩展为多例。掌握好单例的思想,稍加扩展就可以变为多例模式了。

    鸣谢

    非常感谢你花时间阅读本文章,本人水平有限,如果有什么说的不对的地方,欢迎指正。欢迎各位留言讨论,希望小伙伴们都能每天进步一点点。

    展开全文
  • 多例模式之有上限例类

    千次阅读 2015-03-25 08:36:54
    一个实例数目有上限的例类已经把实例的上限当做逻辑的一部分,并建造了例类的内部,这种模式叫做有有上限的多例模式。 比如在每一麻将牌局都需要两个骰子,因此骰子就应当是双态类,这里就以这个系统为例,说明...

    一个实例数目有上限的多例类已经把实例的上限当做逻辑的一部分,并建造了多例类的内部,这种模式叫做有有上限的多例模式。

    比如在每一麻将牌局都需要两个骰子,因此骰子就应当是双态类,这里就以这个系统为例,说明多例模式的结构,骰子的类图如

    图一所示:

    多例类Die(骰子)的源代码如下所示:

    package Multiton;
    
    import java.util.Date;
    import java.util.Random;
    
    public class Die {
    	private static Die die1=new Die();
    	private static Die die2=new Die();
    	
    	/**
    	 * 私有的构造子保证外界无法直接将此类实例化
    	 */
    	private Die(){}
    	
    	/**
    	 * 工厂方法
    	 * @param whichOne
    	 * @return
    	 */
    	public static Die getInstance(int whichOne){
    		if(whichOne==1){
    			return die1;
    		}else{
    			return die2;
    		}
    	}
    	
    	/**
    	 * 掷骰子,返还一个在1~6之间的随机数
    	 * @return
    	 */
    	public synchronized int dice(){
    		Date d=new Date();
    		Random r=new Random(d.getTime());
    		int value=r.nextInt();
    		value=Math.abs(value);
    		value=value%6;
    		value+=1;
    		return value;
    	}
    	
    }
    
    在多例类Die中,使用了饿汉模式创建了两个Die的实例,根据静态工厂方法的参数,工厂方法返还两个实例中的一个,Die()对象的dice()方法

    代表掷骰子,这个方法会返还1~6之间的随机数,相当与骰子的点数,如代码清单如下所示:

    package Multiton;
    
    public class Client {
    	private static Die die1,die2;
    	public static void main(String[] args) {
    		die1=Die.getInstance(1);
    		die2=Die.getInstance(2);
    		die1.dice();
    		die2.dice();
    	}
    }
    
    由于有上限的多例类对实例的数目有上限,因此有上限的多例类在这个上限等于1 时,多例类就回到了单例类,因此,多例类是单例类的推广,

    而单例类是多例类的特殊情况。

    一个有上限的多例类可以使用静态变量存储所有的实例,特别是在实例数目不多的时候,可以使用一个个静态变量存储一个个的实例,在数目

    较多的时候,就需要使用静态聚集来存储这些实例。

    如上,就是多例模式之有上限多例类。

    展开全文
  • 创建型模式--多例模式

    千次阅读 2014-12-28 02:22:03
    多例模式通常被划分为:有上限多例模式、无上限多例模式。 平时我们通过new一个对象的就是无上限多例模式。 什么叫有上限多例模式,其实就是单例模式的推广,创建>1个的实例(有限)。 代码描述: public class ...
  • 六、创建型模式——多例模式

    千次阅读 2018-04-03 18:16:34
    多例模式顾名思义就是一个类可以有个实例,而且这个类必须自己创建、管理自己的实例,并向外界提供自己的实例。一、多例模式的特点所谓的多例模式(Multiton Pattern),实际上就是单例模式的自然推广。作为对象的...
  • 多例模式
  • 单例模式和多例模式的总结

    万次阅读 多人点赞 2016-07-12 09:05:48
    学习交流关注微信公众号:钟渊博客 ...多例模式(Multiton) 1、例类可以有个实例 2、例类必须能够自我创建并管理自己的实例,并向外界提供自己的实例。 一、单例模式和多例模式说明: 1.单例模式和...
  • 设计模式之多例模式

    千次阅读 2016-04-28 17:29:17
    多例模式:相对单例模式而言的,单例模式仅有一个实例,所以多例模式顾名思义就是允许存在有限个实例(多例模式又分为有上限模式和无上限模式,无上限模式和直接new一个对象差不多,所以这里不讨论)。 二、特点 1...
  • 设计模式学习(十二) 多例模式

    万次阅读 2019-03-14 18:11:08
    定义:作为对象的创建模式,多例模式中的例类可以有个实例,而且例类必须自己创建、管理自己的实例,并向外界提供自己的实例。 特点: 所谓的多例模式(Multiton Pattern),实际上就是单例模式的自然推广。...
  • 最近研究了一下线程在单例、例下的使用,以及安全问题,总结如下:1、先说一下什么是单例模式和多例模式。(1):单例模式:一个对象在内存中只有唯一个实例。它有两个主要的特点:构造函数私有,它的唯一实例...
  • 单例模式和多例模式详解

    千次阅读 2018-03-27 22:40:45
    2.get的方法为静态,由类直接调用 多例模式(Multiton)1 、例类可以有个实例 2 、例类必须能够自我创建并管理自己的实例,并向外界提供自己的实例。 一、单例模式和多例模式说明:1. 单例模式和多例...
  • Java多例模式

    千次阅读 2015-03-26 11:34:50
    多例模式又划分为有上限多例模式和无上限多例模式两种,没上限的多例模式和直接 new 一个对象没什么差别,此处不做记录。 有上限多例模式:实际上是单例模式的推广,如果它的上限是1,那么就成了单例模式了. 多例模式特点...
  • java常用设计模式之多例模式

    千次阅读 2018-06-18 22:45:34
    多例模式: 说明: 多例模式可以看做事单例模式的一个推广,区别在于,单例模式有且只有一个对象,产生,而多例模式则会产生个我们所需要的对象。使用方法: 1.私有化构造方法,使其在外部无法被调用,构造相应...
  • 23种设计模式-多例模式《柒个我》

    万次阅读 2018-08-20 11:59:47
    对于许久不用的东西,容易忘记。百度许久,也未能找到自己所要。 从今日起,有些东西就记载下来,不仅方便自己,希望能帮到他人吧 ...首先明确一点,多例模式是有数量限制的,否则跟直接new没有区别,那就失去了...
  • Java多例模式笔记

    千次阅读 2013-01-24 14:29:10
    多例模式又划分为有上限多例模式和无上限多例模式两种,没上限的多例模式和直接 new 一个对象没什么差别,此处不做记录... 有上限多例模式:实际上是单例模式的推广,如果它的上限是1,那么就成了单例模式了. 多例模式...
  • Java Java实现的多例模式

    千次阅读 2018-10-29 20:53:00
    Java 多例模式实际就是单例模式的一个扩展,下面给出一个多例模式的实现    需要引入的Java包  &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; ...
  • Spring 的单例模式和多例模式

    千次阅读 2018-03-14 19:33:23
    在Spring中,Bean的scope属性中存在着两种模式既单例模式(singleton)和多例模式(prototype)。 singleton 单例模式: 对象在整个系统中只有一份,所有的请求都用一个对象来处理,如service和dao层的对象一般是...
  • @Component @Service等这些注解默认是单例模式,在spring初始化的时候建立对象, 想使用多例模式时,多加一个@Scope(“prototype”)注解,就成了多例模式,在使用对象的时候初始化对象。
  • 单例模式和多例模式

    万次阅读 2009-09-29 18:33:00
    一、单例模式和多例模式说明:1. 单例模式和多例模式属于对象模式。2. 单例模式的对象在整个系统中只有一份,多例模式可以有个实例。3. 它们都不对外提供构造方法,即构造方法都为私有。4. 单例模式和多例模式...
  • 多例模式与单例模式都禁止外界直接将之实例化,同时通过静态工厂方法向外界提供循环使用的自身的实例。它们的不同在于单例模式仅有一个实例,而多例模式则可以有个实例。 多例模式往往具有一个聚集属性,通过向这...
  • 多例模式例子

    千次阅读 2018-11-13 13:55:54
    例子来源于秦小波的《设计模式之禅》 1、主类 /** * @author zhaojianbo */ public class Emperor { private static int maxNumberOfEmperor = 2; private static ArrayList emperorInfoList = new ArrayList...
  • spring通过注解的方式使用多例模式

    千次阅读 2020-10-20 21:00:12
    spring通过注解的方式使用多例模式 说明:spring容器实例化对象时默认使用单例模式,初学时也知道实现多例模式可以在容器文件中给bean添加prototype,再通过applicationContext获取不同的实例。 那么,如何只使用...
  • 原文章出自:http://www.cnblogs.com/zhangliang88/p/5388472.html ... 单例模式是所有的请求都用一个对象来处理,例如service、dao层的对象,通常都是单例的;而多例模式则是new一个新的对象来处...
  • 单例、多例模式&&工厂模式

    千次阅读 2017-02-22 15:20:19
    单例、多例模式假设,老张开车去东北public class Car { public void run(){ System.out.println("冒着烟奔跑中car........."); } }public class Test { public static void main(String[] args) { //如果把new...
  • 单例模式与多例模式

    千次阅读 2009-09-25 22:45:00
    设计模式C#描述——单例与多例模式 作为对象的创建模式,单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式有以下特点: 单例类只能有一个实例。 单例类必须...
  • spring ioc 单例 和多例模式学习

    千次阅读 2018-05-09 16:43:35
    spring ioc中默认为单例,当scope设置为prototype的时为例,设置为例时,对象的...时创建对象多例模式例子:package zju_001.maven_test_1; import org.springframework.context.ApplicationContext; impor...
  • java单例模式和多例模式概念详解

    千次阅读 2019-08-21 16:50:22
    数据库连接池就是单例模式,有且仅有一个连接池管理者,管理个连接池对象。 单例和多例的区别: 什么是单例多例: 所谓单例就是所有的请求都用一个对象来处理,比如我们常用的service和dao层的...
  • 多例模式应用场景举例

    千次阅读 2014-01-23 22:25:43
    多例模式应用场景举例  并发请求环境下,系统需要为每个客户端的独立请求提供单独服务的资源,但是系统总的开销是有限的,系统在并发量很大时也不可能为所有的并发请求同时提供相应的资源,否则不但系统...
  • springboot多例模式的实现

    千次阅读 2019-07-09 14:13:20
    在bean类中加注解@Scope(“proptype”) 发现仍然是单例模式。 代码如下: service /** * @author Kern * @Title: ExcelTemplateServiceImpl * @ProjectName swms-java * @Description: TODO * @date 2019-7-815:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 729,268
精华内容 291,707
关键字:

多例模式