程序博客网 > log4j不打印sql语句

OOAD之设计模式-创建模式

来源：互联网 发布：log4j不打印sql语句 编辑：程序博客网 时间：2024/05/21 22:48

http://blog.csdn.net/mudeer2012/article/details/8453062

先来说说模式的概念吧。

模式就是：具有代表性的某些重复问题的解决方案，是进过多次证实，与业务无关的方案。

它们都有特定的名称和适用的环境。模式的使用为我们带来了复用性的提高和可维护性的提高，同时可以增强表达能力。因为它是整个解决方案的总结。

一、模式的主要分类

模式分为两大类：设计模式和架构模式。

根据group of four 定义的23种模式和MVC模式，总共有24种。

其中设计模式又分为三小类：设计模式是系统局部出现的某一核心问题的解决方案

1.1创建型模式

创建模式：是用于创建对象。

包括单列、工厂、建造者、原型四种模式。

1.2结构型模式

结构模式：是用于组织类和对象之间关系的，形象的说就是对象间的组织形式。

包括桥梁、装饰器、适配器、外观、代理模式等。

1.3行为型模式

行为模式：是用于对象交换和职责分配的，形象的说就是方法的组织形式。

包括方法模板、策略、观察者、命令模式等。

另外架构模式是用于指导整个系统的整体的组织结构，规划，指南，用来组织预定义的职责分明的子系统。

二、创建模式

2.1单列模式singleton

顾名思义：这种设计模式是为了保证整个类只会产生一个对象，它是唯一的存在，通常用于独一无二的最高控制者。

在应用系统开发时，经常需要让系统管理一些软件内外部资源，这些内外部资源中有些只能有一个实例。

共有3种方法实现，各有不同的效果：

2.1.1预加载

构造方法私有，有一个静态属性是本身的一个对象。加载类时直接赋值构造一个对象。有静态方法可以获取该对象的引用。

 

[java] view plaincopy
  1. //单例(态)模式一  
  2. //优点：线程绝对安全,多线程情况下不排队  
  3. //缺点：预加载导致不使用也产生了对象  
  4. //public class Singleton {  
  5. //    
  6. //  //静态的对象，保证了全类共享一个对象  
  7. //  private static Singleton instance;  
  8. //    
  9. //  static{  
  10. //      instance = new Singleton();  
  11. //  }  
  12. //    
  13. //  //私有的构造方法  
  14. //  private Singleton(){  
  15. //        
  16. //  }  
  17. //    
  18. //  public static Singleton getInstance(){  
  19. //      return instance;  
  20. //  }  
  21. //    
  22. //}  


2.1.2延时加载

构造方法私有，有一个静态属性是本身的一个对象。用一个静态同步方法来赋值，第一次调用给静态属性赋值，之后直接提取值。

[java] view plaincopy
  1. //单例模式二  
  2. //优点：延迟加载（当真正需要对象的时候才产生）  
  3. //缺点: 多线程情况下要排队  
  4. //public class Singleton{  
  5. //  private static Singleton instance = null;  
  6. //    
  7. //  private Singleton(){  
  8. //        
  9. //  }  
  10. //    
  11. //  public synchronized static Singleton getInstance(){  
  12. //      if(instance == null){  
  13. //          instance = new Singleton();  
  14. //      }  
  15. //      return instance;  
  16. //  }  
  17. //}  
2.1.3高并发延时加载

构造方法私有，有一个静态属性是本身的一个对象。有一个静态方法给它赋值，代码块中使用双锁机制来控制。

[java] view plaincopy
  1. //单例模式三（Java不支持）  
  2. //别名：双锁机制  
  3. //实现延迟加载、并支持高并发！  
  4. public class Singleton{  
  5.       
  6.     private static Singleton instance = null;  
  7.       
  8.     private Singleton(){  
  9.           
  10.     }  
  11.       
  12.     public static Singleton getInstance(){  
  13.         if(instance == null){  
  14.               
  15.             synchronized(Singleton.class){  
  16.                 if(instance == null){  
  17.                     instance = new Singleton();  
  18.                 }  
  19.             }  
  20.         }  
  21.         return instance;  
  22.     }  
  23.       
  24. }  

2.2工厂模式factory

2.2.1简单工厂

简单工厂中，工厂是单一的。产品有一种，有一个抽象父类，下面是各种产品。工厂有只能制造同一种类型产品的方法。不支持开闭。

对于消费者来说，同样的产品需求只有一种选择。
当工厂只生产同一品种的具体产品，而且产品数量有限的时候，可以考虑使用简单工厂模式。

[java] view plaincopy
  1. package com.lovo.factory.simplefactory;  
  2.   
  3. /** 
  4.  * @author Administrator 
  5.  *  简单工厂：静态的工厂，动态的产品 
  6.  */  
  7. public class KFCFactory {  
  8.       
  9.     public static KFCProduct order(String msg){  
  10.         if(msg.equals("汉堡")){  
  11.             return new Humburger();  
  12.         }else if(msg.equals("薯条")){  
  13.             return new Chips();  
  14.         }else{  
  15.             return null;  
  16.         }  
  17.     }  
  18.       
  19. }  


 

[java] view plaincopy
  1. package com.lovo.factory.simplefactory;  
  2.   
  3. public abstract class KFCProduct {  
  4.       
  5.     public abstract void tasty();  
  6.       
  7. }  


 

[java] view plaincopy
  1. package com.lovo.factory.simplefactory;  
  2.   
  3. public class Chips extends KFCProduct {  
  4.   
  5.     @Override  
  6.     public void tasty() {  
  7.         // TODO Auto-generated method stub  
  8.         System.out.println("KFC的薯条！");  
  9.     }  
  10.   
  11. }  


 

[java] view plaincopy
  1. package com.lovo.factory.simplefactory;  
  2.   
  3. public class Humburger extends KFCProduct{  
  4.   
  5.     @Override  
  6.     public void tasty() {  
  7.         // TODO Auto-generated method stub  
  8.         System.out.println("鸡腿堡！！！");  
  9.     }  
  10.       
  11.       
  12.       
  13.       
  14. }  


 

2.2.2工厂方法

工厂方法中，工厂有多种，都有抽象类。只有一种类型的产品即一个产品族，下面有该类产品的具体实现子类。有工厂抽象父类，该类中定义所有工厂的公共方法，子类工厂可以有不同的实现，兼容各自的特色。

对于消费者来说，同样的产品需求有不同的选择。它只能生产同一种类的具体产品。

[java] view plaincopy
  1. package com.lovo.factory.factorymethod;  
  2.   
  3. /** 
  4.  * @author Administrator 
  5.  *  工厂是动态的，产品是不动的 
  6.  */  
  7. public abstract class HumburgerFactory {  
  8.     public abstract Humburger order();  
  9. }  


 

[java] view plaincopy
  1. package com.lovo.factory.factorymethod;  
  2.   
  3. public class KFCFactory extends HumburgerFactory{  
  4.   
  5.     @Override  
  6.     public Humburger order() {  
  7.         // TODO Auto-generated method stub  
  8.         System.out.println("KFC汉堡");  
  9.         return new Humburger();  
  10.     }  
  11.   
  12. }  
[java] view plaincopy
  1. package com.lovo.factory.factorymethod;  
  2.   
  3. public class MCDFactory extends HumburgerFactory {  
  4.   
  5.     @Override  
  6.     public Humburger order() {  
  7.         // TODO Auto-generated method stub  
  8.         Humburger hum = new Humburger();  
  9.         System.out.println("MCD汉堡");  
  10.         return hum;  
  11.     }  
  12.   
  13. }  



 

2.2.3抽象工厂

抽象工厂中工厂和产品都具有抽象类，工厂和产品都可以多样化。产品有2个及以上的产品族，并且这些产品相互间有。抽象工厂集成了多个产品族的生产方法，具体的工厂实现自己的产品生产方法。消费者自由选择各种搭配。

工厂类层次与具体的产品类层次通常是平行的（即一一对应的）。
增加一个具体类，一般也要相应地增加一个工厂类，增加了系统复杂度。

在以下情况下，应当考虑使用抽象工厂模式：
1-这个系统的产品有多于一个的产品族。
2-同属于同一个产品族的产品是设计成在一起使用的。产品之间有特殊的相关或依赖关系。产品之间应该最少应该有两种关系，纵向来看每种产品组内部产品之间有继承关系，例如产品AbstractProductA与ProductA1和ProductA2之间有继承关系，是同一产品族产品；横向来看两个产品族之间的产品也应该有一一对应关系，例如ProductA1与ProductB1之间，或ProductA2与ProductB2之间的对应关系。
 

2.3建造者模式builder

建造模式（Builder Pattern）的定义为：把复杂对象的构造过程从对象的表示中分离出来，其直接效果是将一个复杂的对象简化为一个比较简单的目标对象。
一个产品经常由不同的组成成分作为产品的部件，不同的产品可以有不同的部件。使用建造模式，可以使客户端不需要知道所生成的产品有哪些部件、每个产品的对应部件有什么不同、是如何建造出来的、以及如何组装产品。
建造模式的使用时机：
当创建一个复杂对象的算法应该独立于组成该对象的部分以及如何组装时。
当构造过程必须允许要创建的对象有不同的表示时。
当我们想要将客户与实际创建过程或者结果产品隔离时
被创建的对象不需要知道其创建细节。
创建的代码与表示的代码分离，二者都很容易被替代而不至于相互影响。
我们可以控制创建过程。
我们可以独立地重用或者更改创建过程或产品。
[java] view plaincopy
  1. public abstract class Builder {  
  2.       
  3.     private PartA pa;  
  4.       
  5.     private PartB pb;  
  6.       
  7.     private PartC pc;  
  8.       
  9.     private Result result;  
  10.       
  11.     public abstract void buildA();  
  12.       
  13.     public abstract void buildB();  
  14.       
  15.     public abstract void buildC();  
  16.       
  17.     public Result getResult(){  
  18.         return this.result;  
  19.     }  
  20. }  
[java] view plaincopy
  1. public abstract class Director {  
  2.       
  3.     private Builder builder;  
  4.   
  5.     public Builder getBuilder() {  
  6.         return builder;  
  7.     }  
  8.   
  9.     public void setBuilder(Builder builder) {  
  10.         this.builder = builder;  
  11.     }  
  12.       
  13.     public abstract void contact();  
  14.       
  15. }  

2.4原型模式prototype

原型模式是通过拷贝一个现有对象生成新对象的。
为了实现深度克隆，经常要使用流来读取拷贝对象，在读出一个新的对象。

[java] view plaincopy
  1. package com.lovo.prototype;  
  2.   
  3. import java.io.ByteArrayInputStream;  
  4. import java.io.ByteArrayOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.   
  10. //public class BasketballStar implements Cloneable {  
  11.   
  12. public class BasketballStar implements Serializable{  
  13.     private String name;  
  14.   
  15.     private int age;  
  16.   
  17.     private float height;  
  18.   
  19.     private Skill theSkill;  
  20.   
  21.     public BasketballStar() {  
  22.   
  23.     }  
  24.   
  25.     public BasketballStar(String name, int age, float height) {  
  26.         super();  
  27.         this.name = name;  
  28.         this.age = age;  
  29.         this.height = height;  
  30.     }  
  31.   
  32.     public int getAge() {  
  33.         return age;  
  34.     }  
  35.   
  36.     public void setAge(int age) {  
  37.         this.age = age;  
  38.     }  
  39.   
  40.     public float getHeight() {  
  41.         return height;  
  42.     }  
  43.   
  44.     public void setHeight(float height) {  
  45.         this.height = height;  
  46.     }  
  47.   
  48.     public String getName() {  
  49.         return name;  
  50.     }  
  51.   
  52.     public void setName(String name) {  
  53.         this.name = name;  
  54.     }  
  55.   
  56.     public Skill getTheSkill() {  
  57.         return theSkill;  
  58.     }  
  59.   
  60.     public void setTheSkill(Skill theSkill) {  
  61.         this.theSkill = theSkill;  
  62.     }  
  63.       
  64.     public BasketballStar deepClone(){  
  65.         BasketballStar bs = null;  
  66.         //序列化  
  67.         ObjectOutputStream oos = null;  
  68.         ByteArrayOutputStream bos = null;  
  69.           
  70.         try {  
  71.             bos = new ByteArrayOutputStream();  
  72.             oos = new ObjectOutputStream(bos);  
  73.             oos.writeObject(this);  
  74.         } catch (IOException e) {  
  75.             // TODO Auto-generated catch block  
  76.             e.printStackTrace();  
  77.         } finally{  
  78.             if(oos != null){  
  79.                 try {  
  80.                     oos.close();  
  81.                 } catch (IOException e) {  
  82.                     // TODO Auto-generated catch block  
  83.                     e.printStackTrace();  
  84.                 }  
  85.             }  
  86.         }  
  87.         //反序列化  
  88.         ObjectInputStream ois = null;  
  89.         ByteArrayInputStream bis = null;  
  90.           
  91.         try {  
  92.             bis = new ByteArrayInputStream(bos.toByteArray());  
  93.             ois = new ObjectInputStream(bis);  
  94.             bs = (BasketballStar)ois.readObject();  
  95.               
  96.         } catch (IOException e) {  
  97.             // TODO Auto-generated catch block  
  98.             e.printStackTrace();  
  99.         } catch (ClassNotFoundException e) {  
  100.             // TODO Auto-generated catch block  
  101.             e.printStackTrace();  
  102.         } finally{  
  103.             if(ois != null){  
  104.                 try {  
  105.                     ois.close();  
  106.                 } catch (IOException e) {  
  107.                     // TODO Auto-generated catch block  
  108.                     e.printStackTrace();  
  109.                 }  
  110.             }  
  111.         }  
  112.         return bs;  
  113.     }  
  114.       
  115.   
  116. //  public Object clone() throws CloneNotSupportedException {  
  117. //      BasketballStar bs = (BasketballStar)super.clone();  
  118. //      bs.setTheSkill((Skill)this.getTheSkill().clone());  
  119. //      return bs;  
  120. //  }  
  121.   
  122.     @Override  
  123.     public String toString() {  
  124.         // TODO Auto-generated method stub  
  125.         return this.name + "  " + this.age + "   " + this.height;  
  126.   
  127.     }  
  128.   
  129. }  


 

[java] view plaincopy
  1. package com.lovo.prototype;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. //public class Skill implements Cloneable{  
  6. public class Skill implements Serializable{  
  7.     private int shooting;  
  8.   
  9.     private int passing;  
  10.   
  11.     private int crossing;  
  12.   
  13.     private int jumping;  
  14.   
  15.     public Skill() {  
  16.   
  17.     }  
  18.   
  19.     public Skill(int shooting, int passing, int crossing, int jumping) {  
  20.         super();  
  21.         this.shooting = shooting;  
  22.         this.passing = passing;  
  23.         this.crossing = crossing;  
  24.         this.jumping = jumping;  
  25.     }  
  26.   
  27.     public int getCrossing() {  
  28.         return crossing;  
  29.     }  
  30.   
  31.     public void setCrossing(int crossing) {  
  32.         this.crossing = crossing;  
  33.     }  
  34.   
  35.     public int getJumping() {  
  36.         return jumping;  
  37.     }  
  38.   
  39.     public void setJumping(int jumping) {  
  40.         this.jumping = jumping;  
  41.     }  
  42.   
  43.     public int getPassing() {  
  44.         return passing;  
  45.     }  
  46.   
  47.     public void setPassing(int passing) {  
  48.         this.passing = passing;  
  49.     }  
  50.   
  51.     public int getShooting() {  
  52.         return shooting;  
  53.     }  
  54.   
  55.     public void setShooting(int shooting) {  
  56.         this.shooting = shooting;  
  57.     }  
  58.   
  59.     @Override  
  60.     public String toString() {  
  61.         // TODO Auto-generated method stub  
  62.         return this.shooting + "  " + this.passing + "  " + this.crossing + "  " + this.jumping;  
  63.     }  
  64.       
  65.       
  66.       
  67.       
  68. //  @Override  
  69. //  public Object clone() throws CloneNotSupportedException {  
  70. //      // TODO Auto-generated method stub  
  71. //      return super.clone();  
  72. //  }  
  73.       
  74.       
  75.   
  76. }  
log4j不打印sql语句 log4j不打印sql语句
原创粉丝点击
热门IT博客
mac的子弹头mac的子弹头
win32核心编程 pdfwin32核心编程 pdf
七层网络
数据库 功能函数
链接数据库接口
冲量的意义知乎
三维矩阵svd分解
车辆参数修改软件
成都网站制作龙兵网络
mac中文字怎么打
2016淘宝手机店铺装修
西门子plc编程软件xp
南宋灭亡知乎
西成高铁 知乎
js 双向绑定
e4a获取网络图片
齐鲁大学生软件大赛
淘宝定制店在哪里
知乎 三体问题
多点触摸软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 脊椎有一节用手一按就疼 鱼竿手把节断了怎么修 长节手竿 短节手杆 手串节 手节骨疼是怎么回事 皲手茧足 手茧怎么去除 手茧 一双布满老茧的手图片 手茧怎么去掉 手起茧怎么消除 水泡型手癣传染吗 手癣怎么止痒 手癣传染别人吗 手癣 足光粉 手藓可以自愈吗 手藓是什么 手藓传染吗 足藓会传染吗 藓会传染吗 脸藓 手足癣吧 癣传染吗 癣传染人吗 蜀缘手游 天天魏蜀吴手游 电话手表 罗西尼手表 西铁城手表 手表牌子 飞亚达手表 绿水鬼手表 手表调时间 雷诺手表 小天才手表 手表英语 手表等级 手表种类 手表类型 浪琴女手表

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里