java工厂模式JAVA工厂模式和单体模式

java 工厂模式，我不知道谁能告诉我？

转自我曾经看过的一本书！ 设计模式之Factory 定义:提供创建对象的接口. 为何使用? 工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

我们以类Sample为例， 如果我们要创建Sample的实例对象: Sample sample=new Sample(); 可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成: Sample sample=new Sample(参数); 但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。

为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。

还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下: Sample mysample=new MySample(); Sample hissample=new HisSample(); 随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的. 但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了. 工厂方法 你会建立一个专门生产Sample实例的工厂: public class Factory{ public static Sample creator(int which){ //getClass 产生Sample 一般可使用动态类装载装入类。

if (which==1) return new SampleA(); else if (which==2) return new SampleB(); } } 那么在你的程序中,如果要实例化Sample时.就使用 Sample sampleA=Factory.creator(1); 这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵. 使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample： 进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。

抽象工厂 工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory). 这两个模式区别在于需要创建对象的复杂程度上。

如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2. 这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2 那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂: public abstract class Factory{ public abstract Sample creator(); public abstract Sample2 creator(String name); } public class SimpleFactory extends Factory{ public Sample creator(){ ......... return new SampleA } public Sample2 creator(String name){ ......... return new Sample2A } } public class BombFactory extends Factory{ public Sample creator(){ ...... return new SampleB } public Sample2 creator(String name){ ...... return new Sample2B } } 从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2? 抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。

在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用， 举例 我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，现在再讨论其工厂模式: public abstract class ForumFactory { private static Object initLock = new Object(); private static String className = .jivesoftware.forum.database.DbForumFactory"; private static ForumFactory factory = null; public static ForumFactory getInstance(Authorization authorization) { //If no valid authorization passed in, return null. if (authorization == null) { return null; } //以下使用了Singleton 单态模式 if (factory == null) { synchronized(initLock) { if (factory == null) { ...... try { //动态转载类 Class c = Class.forName(className); factory = (ForumFactory)c.newInstance(); } catch (Exception e) { return null; } } } } //Now, 返回 proxy.用来限制授权对forum的访问 return new ForumFactoryProxy(authorization, factory, factory.getPermissions(authorization)); } //真正创建forum的方法由继承forumfactory的子类去完成. public abstract Forum createForum(String name, String description) throws UnauthorizedException, ForumAlreadyExistsException; .... } 因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口: private static String className = .jivesoftware.forum.database.DbForumFactory"; 你可以使用自己开发的创建forum的方法代.jivesoftware.forum.database.DbForumFactory就可以. 在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果. 看看Java宠物店中的CatalogDAOFactory: public class CatalogDAOFactory { /** * 本方法制定一个特别的子类来实现DAO模式。

* 具体子类定义是在J2EE的部署描述器中。

*/ public static CatalogDAO getDAO() throws CatalogDAOSysException { CatalogDAO catDao = null; try { InitialContext ic = new InitialContext(); //动态装入CATALOG_DAO_CLASS //可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码 //的前提下，完成系统的巨大变更。

String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS); catDao = (CatalogDAO) Class.forName(className).newInstance(); } catch (NamingException ne) { throw new CatalogDAOSysException(" CatalogDAOFactory.getDAO: NamingException while getting DAO type : " + ne.getMessage()); } catch (Exception se) { throw new CatalogDAOSysException(" CatalogDAOFactory.getDAO: Exception while getting DAO type : " + se.getMessage()); } return catDao; } } CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。

Java的几个工厂方法解析

Java工厂模式可分为三种： 1.静态工厂模式 2.工厂方法模式 3.抽象工厂模式 一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性 举例如下： Vehicle类： public abstract class Vehicle { private String name; public Vehicle (){ super(); } public Vehicle (String name){ super(); this.name=name; } public abstract void run(); public String getName(){ return name; } public void setName(String name){ this.name=name; } } Bus类： public class Bus extends Vehicle { private String name; public Bus(){} public Bus(String name){ super(name); } @Override public abstract void run(){ System.out.println("Bus is running"); } } Car类： public class Car extends Vehicle { private String name; public Car(){} public Car(String name){ super(name); } @Override public abstract void run(){ System.out.println("Car is running"); } } 静态工厂类： （静态工厂创建一个对象， 静态工厂创建的对象一般都有一个共同的特性， 继承自某一个类， 或者引用一个接口） public class StaticFactory{ public static Object getInstance(String className){ Object instance=null; try{ Class c=Class.forName(className); instance=c.newInstance(); }catch(Exception e){} return instance; } public static Object getInstance(String className,Object ...args){ Class c=null; try{ c=Class.forName(className); }catch(Exception e){} Constructor[] cons=c.getConstructors(); Object instance=null; for(Constructor con:cons){ Class<?>[] cs=con.getParmeterTypes(); if(cs.length>0){ boolean isConstructor=true; for(int i=0;i<cs.length;i++){ Class t=cs[i]; if(!t.isInstance(args[i])){ isConstructor=false; } } if(isConstructor){ try{ instance=con.newInstance(args); break; }catch(Exception e){} }else{ continue; } } } return instance; } } 二、工厂方法模式：主要是对各类东西分类生产，但分类生产的对象仍然具有某一特性。

如果说静态工厂是一个综合的交通工具建造工厂， 那么工厂方法模式就是具体分工，分成Bus与Car的工厂， 各自生产各自的产品，但是造出来的还是交通工具。

交通工具制造接口： public interface VehicleMake{ /**制造交通工具**/ public Vehicle make(); } Bus制造类： public class BusMake implements VehicleMake{ @Override public Vehicle make(){ Vehicle bus=new Bus(); System.out.println("Bus工厂制造了一辆Bus"); return bus; } } Car制造类： public class CarMake implements VehicleMake{ @Override public Vehicle make(){ Vehicle car=new Car(); System.out.println("Car工厂制造了一辆Car"); return car; } } 三、抽象工厂模式：抽象工厂生产的对象可能是没有共同特性的。

比如，一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件，Bus是交通工具，wheel是配件（代码中有部分类没具体写出来只给了类名） 总工厂（抽象工厂总接口）： public interface WheelVehicleMake extends VehicleMake{ /**制造轮胎**/ public Wheel makeWheel(); } 轮子BusMake： public class WheelBusMake implements WheelVehicleMake{ @Override public Vehicle make(){ Vehicle bus=new Bus(); System.out.println("WheelBusMake生产了一辆Bus"); return bus; } @Override public Wheel makeWheel(){ Wheel busWheel=new BusWheel(); System.out.println("WheelBusMake生产了一个Bus轮子"); return busWheel; } } 轮子CarMake： public class WheelCarMake implements WheelVehicleMake{ @Override public Vehicle make(){ Vehicle car=new Car(); System.out.println("WheelCarMake生产了一辆Car"); return car; } @Override public Wheel makeWheel(){ Wheel carWheel=new CarWheel(); System.out.println("WheelCarMake生产了一个Car轮子"); return carWheel; } }

JAVA工厂模式和单体模式

单体模式 很简单，就是将构造函数变为私有，那么就不能通过new 来创建对象。

同时创建一个 共有的静态的方法来获得实例，代码如下： class Test{ private static Test instance = null; private Test(){} public static Test getInstance(){ if( instance == null ){ instance = new Test(); } return instance ; } } 工厂模式有三个参与者，抽象产品(Product)、工厂(Creator)和具体产品(ConcreteProduct)。

客户只会看到工厂和抽象产品。

public interface Product{ public String getName(); } public class ConcreteProduct implements Product{ public String getName(){ return "产品1"; } } public class Creator{ public static Product create1(){ return new ConcreteProduct(); } } 工厂模式的作用在于将创建具体产品的方法由工厂类控制，客户只需要知道产品的抽象类型