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 = "com.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 = "com.jivesoftware.forum.database.DbForumFactory";

你可以使用自己开发的创建forum的方法代替com.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 : \n" + ne.getMessage());

} catch (Exception se) {

throw new CatalogDAOSysException("

CatalogDAOFactory.getDAO: Exception while getting

DAO type : \n" + se.getMessage());

}

return catDao;

}

}

CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

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

求java工厂模式的一个简单代码例子，尽量简单

这个应该比较简单一点。

某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式。现使用工厂方法模式设计该系统,并写出相应Java代码。

interface Log{

public void writeLog();

}

class FileLog implements Log{

public void writeLog(){

System.out.println("文件记录");

}

}

class DatabaseLog implements Log{

public void writeLog(){

System.out.println("数据库记录");

}

}

interface LogFactory{

public Log createLog();

}

class FileLogFactory implements LogFactory{

public Log createLog(){

return new FileLog();

}

}

class DatabaseLogFactory implements LogFactory{

public Log createLog(){

return new DatabaseLog();

}

}

public class Client{

public static void main(String[] args) {

try{

Log log;

LogFactory factory;

//这里可以改成使用DOM和Java反射机制读取XML文件，获取工厂类名

factory=new DatabaseLogFactory ();

log=factory.createLog();

log.writeLog();

}

catch(Exception e){

System.out.println(e.getMessage());

}

}

}

java工厂模式，懂的人进

举两个例子以快速明白Java中的简单工厂模式：

女娲抟土造人

话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。

女娲造人，这就是简单工厂模式的应用。

首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。

1.）女娲是一个工厂类，也就是简单工厂模式的核心角色。

2.）具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色

3.）抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能）

　其UML类图出下所示：

理解了上面的这些东西，再来理解下面的例子，对照理解，相信看完这篇文章，便对java简单工厂模式有一个很好的理解：

有一个农场公司，专门向市场销售各类水果，在这个系统里需要描述下列水果：

　葡萄　Grape

　草莓　Stuawberry

　苹果　Apple

水果与其他植物不同，最终可以采摘食用，那么一个自然的做法是建立一个各种水果都适用的接口，以便与其他农场里的植物区分开来，

此时，则是为水果类声明了一个接口，表现在代码上：

1 public interface Fruit {

2 // 生长

3 void grow();

4 // 收获

5 void harvest();

6 // 种植

7 void plant();

8 }

9

10

水果接口规定出所有的水果必须实现的接口，包括任何水果类必须具备的方法plant(),grow(),和harvest();

Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另处，由于苹果是多年生植物，因此多出一个treeAge性质，描述苹果的树龄。代码如下所示：

package fac;

public class Apple implements Fruit { // 通过implements实现接口Fruit

private int treeAge;

public void grow() {

log( " Apple is growing " );

}

public void harvest() {

log( " Apple has been harvested " );

}

public void plant() {

log( " Apple ha been planted " );

}

public static void log(String msg) {

System.out.println(msg);

}

public int getTreeAge() {

return treeAge;

}

public void setTreeAge( int treeAge) {

this .treeAge = treeAge;

}

}

同理，葡萄　Grape：

package fac;

public class Grape implements Fruit{

private boolean seedless;

public void grow(){

log("Grape is growing.");

}

public void harvest(){

log("Grape has been harvested");

}

public void plant(){

log("Grape ha been planted");

}

public static void log(String msg){

System.out.println(msg);

}

public boolean isSeedless() {

return seedless;

}

public void setSeedless(boolean seedless) {

this.seedless = seedless;

}

}

草莓　Stuawberry：

package fac;

public class Strawberry implements Fruit{

public void grow(){

log("Strawberry is growing");

}

public void harvest(){

log("Strawberry has been harvested");

}

public void plant(){

log("Strawberry has been planted");

}

public static void log(String msg){

System.out.println(msg);

}

}

农场园丁也是系统的一部分，由一个类来代表，FruitGardener类，代码如下：

package fac;

public class FruitGardener{

public static Fruit factory(String which)throws Exception{

if(which.equalsIgnoreCase("apple")){

return new Apple();

}else if(which.equalsIgnoreCase("strawberry")){

return new Strawberry();

}else if (which.equalsIgnoreCase("grape")){

return new Grape();

}else{

throw new Exception("Bad fruit request");

}

}

}

这时有人来果园玩，和园丁说，给我们介绍下你的水果吧。于是园丁：

package fac;

public class People {

public static void main(String[] args) throws Exception {

FruitGardener fg=new FruitGardener();

Fruit ap=fg.factory("Apple");

ap.grow();

Fruit gp=fg.factory("Grape");

gp.plant();

Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常

}

}

（注：以上代码在JDK5.0，Myeclise3.2下编译通过）

类比两个例子，园丁就相当于女娲，而水果就相当于具体的人，接口水果类就相当于存在于类女娲思想里的人的抽象概念。

由以上两个例子可得出，简单工厂模式需要由以下角色组成：

接口

接口的实现类（简单工厂模式里面的具体产品角色）

工厂

理解了以下两个例子，再来看第三个例子：

注意对比以下三个实例的不同

实例1：

package org.jzkangta.factorydemo01;

//定义接口

interface Car{

public void run();

public void stop();

}

//具体实现类

class Benz implements Car{

public void run(){

System.out.println("Benz开始启动了。。。。。");

}

public void stop(){

System.out.println("Benz停车了。。。。。");

}

}

//具体实现类

class Ford implements Car{

public void run(){

System.out.println("Ford开始启动了。。。");

}

public void stop(){

System.out.println("Ford停车了。。。。");

}

}

//工厂

class Factory{

public static Car getCarInstance(){

return new Ford();

}

}

public class FactoryDemo01 {

public static void main(String[] args) {

Car c=Factory.getCarInstance();

c.run();

c.stop();

}

}

实例二：

package fac;

//定义接口

interface Car{

public void run();

public void stop();

}

//具体实现类

class Benz implements Car{

public void run(){

System.out.println("Benz开始启动了。。。。。");

}

public void stop(){

System.out.println("Benz停车了。。。。。");

}

}

class Ford implements Car{

public void run(){

System.out.println("Ford开始启动了。。。");

}

public void stop(){

System.out.println("Ford停车了。。。。");

}

}

//工厂

class Factory{

public static Car getCarInstance(String type){

Car c=null;

if("Benz".equals(type)){

c=new Benz();

}

if("Ford".equals(type)){

c=new Ford();

}

return c;

}

}

public class FactoryDemo02 {

public static void main(String[] args) {

Car c=Factory.getCarInstance("Benz");

if(c!=null){

c.run();

c.stop();

}else{

System.out.println("造不了这种汽车。。。");

}

}

}

实例三：

interface Car{

public void run();

public void stop();

}

class Benz implements Car{

public void run(){

System.out.println("Benz开始启动了。。。。。");

}

public void stop(){

System.out.println("Benz停车了。。。。。");

}

}

class Ford implements Car{

public void run(){

System.out.println("Ford开始启动了。。。");

}

public void stop(){

System.out.println("Ford停车了。。。。");

}

}

class Toyota implements Car{

public void run(){

System.out.println("Toyota开始启动了。。。");

}

public void stop(){

System.out.println("Toyota停车了。。。。");

}

}

class Factory{

public static Car getCarInstance(String type){

Car c=null;

try {

c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型　

} catch (InstantiationException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalAccessException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return c;

}

}

public class FactoryDemo03 {

public static void main(String[] args) {

Car c=Factory.getCarInstance("Toyota");

if(c!=null){

c.run();

c.stop();

}else{

System.out.println("造不了这种汽车。。。");

}

}

}

对比三个实例：

实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个汽车的类即可，而无需改变工厂。从而达到了工厂分离的效果。