正文内容：
原作：fanix
定义:提供创建对象的接口.
为何使用?
工厂模式是我们最常用的模式了,著名的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实例的工厂:
程序代码:
1. public class factory{
2.
3. public static sample creator(int which){
4.
5. //getclass 产生sample 一般可使用动态类装载装入类。
6. if (which==1)
7. return new samplea();
8. else if (which==2)
9. return new sampleb();
10.
11. }
12.
13. }
那么在你的程序中,如果要实例化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拓展成抽象工厂:
程序代码:
1. public abstract class factory{
2.
3. public abstract sample creator();
4.
5. public abstract sample2 creator(java/lang/string.java.html" target="_blank">string name);
6.
7. }
8.
9. public class simplefactory extends factory{
10.
11. public sample creator(){
12. .........
13. return new samplea
14. }
15.
16. public sample2 creator(java/lang/string.java.html" target="_blank">string name){
17. .........
18. return new sample2a
19. }
20.
21. }
22.
23. public class bombfactory extends factory{
24.
25. public sample creator(){
26. ......
27. return new sampleb
28. }
29.
30. public sample2 creator(java/lang/string.java.html" target="_blank">string name){
31. ......
32. return new sample2b
33. }
34.
35. }
36.
37.
38.
从上面看到两个工厂各自生产出一套sample和sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产sample和sample2?
抽象工厂还有另外一个关键要点，是因为 simplefactory内，生产sample和生产sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫simplefactory。
在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，
举例
我们以jive的forumfactory为例，这个例子在前面的singleton模式中我们讨论过，现在再讨论其工厂模式:
程序代码:
1. public abstract class forumfactory {
2.
3. private static java/lang/object.java.html" target="_blank">object initlock = new java/lang/object.java.html" target="_blank">object();
4. private static java/lang/string.java.html" target="_blank">string classname
5. = "com.jivesoftware.forum.database.dbforumfactory";
6. private static forumfactory factory = null;
7.
8. public static forumfactory getinstance(authorization authorization) {
9. //if no valid authorization passed in, return null.
10. if (authorization == null) {
11. return null;
12. }
13. //以下使用了singleton 单态模式
14. if (factory == null) {
15. synchronized(initlock) {
16. if (factory == null) {
17. ......
18.
19. try {
20. //动态转载类
21. java/lang/class.java.html" target="_blank">class c = java/lang/class.java.html" target="_blank">class.forname(classname);
22. factory = (forumfactory)c.newinstance();
23. }
24. catch (java/lang/exception.java.html" target="_blank">exception e) {
25. return null;
26. }
27. }
28. }
29. }
30.
31. //now, 返回 proxy.用来限制授权对forum的访问
32. return new forumfactoryproxy(authorization, factory,
33. factory.getpermissions(authorization));
34. }
35.
36. //真正创建forum的方法由继承forumfactory的子类去完成.
37. public abstract forum createforum(java/lang/string.java.html" target="_blank">string name, java/lang/string.java.html" target="_blank">string description)
38. throws unauthorizedexception, forumalreadyexistsexception;
39.
40. ....
41.
42. }
因为现在的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:
程序代码:
1. public class catalogdaofactory {
2.
3. /**
4.
5. * 本方法制定一个特别的子类来实现dao模式。
6. * 具体子类定义是在j2ee的部署描述器中。
7. */
8.
9. public static
自己整理的java设计模式模式(袖珍版的哦)
需积分: 10 193 浏览量
2008-10-27
16:39:24
上传
评论
收藏 13KB RAR 举报
java设计模式模式(袖珍版的哦).rar （6个子文件） 
设计模式的原则.txt 3KB 设计模式袖珍版之-Mediator(中介者).txt 2KB 设计模式袖珍版之-Factory.txt 10KB 设计模式袖珍版之-Visitor.txt 4KB 设计模式袖珍版之-Singleton(单态).txt 3KB 设计模式袖珍版之-Decorator(油漆工).txt 3KB资源评论
