两者都pd厂模式?br />
本质都是创建具体对象的职责和过E从代码中提取出来，从而实现调用者和被调用者解耦的Q设计模式）目标?br />
但之所以会存在两个分支Q我们可以从其各自的实质来看Q?br />工厂Ҏ模式(Factory Mehod Pattern) 只生一cd象；
抽象工厂模式(Abstract Factory Pattern)产生一pd对象Q这些对象具有如下特征：相关或者相互依?/font>?br />
工厂Ҏ模式可以通过带参数的变种Q即l合j2ee Service Location Pattern方式Q，从而生多U品（即一cd象的多个不同的实例）?br />
抽象工厂模式更注重是相关或者相互依赖的一pd对象Q?font color="#a52a2a">一旦需要改动，只修Ҏ一个具体工厂即可到达修Ҏ个品系列的目的?br />从这一点，如果是涉及一个系列的产品一起工作，我们应该放弃采用（工厂Ҏ模式的）多个工厂Ҏ来达CQ抽象工厂）相同目的的做法?br />因ؓQ?font color="#ffc0cb">如果一个系列的产品一起工作时Q一个应用一ơ只能用同一个品系列中一个对?/font>Q只需要一个具体工厂类Q抽象工厂模式）Q或?多个具体工场c（工厂Ҏ模式Q。如果这一点可以接受，那修改呢Q！
Thanks very much to visit blog, welcome your feedback, your feedback is the Driver && Power to me
]]>
- Factory Pattern
- Decorator Pattern
- Proxy Pattern
- SingLeton Pattern
- Command Pattern
- 其它
- 介绍点：
- a) 使用一些可与现实结合的生动例子Q引用网上资源）
- 介绍其本质（个h理解Q?
- 要介l其如何使用
<一>开q?/p>
大家好，我是crazycyQ今天我们讨论的主题是Design Pattern
首先感谢千年一叹的安排和付出，虽然他极其的忙?/p>
今天的话题可能不很适合初学?对于初学者的可以看我的文?http://m.tkk7.com/crazycy/archive/2006/07/07/57106.html
<?gt; 设计模式的v?/p>
在谈设计模式之前Q我们想一下：Z么会有设计模式？
Christopher Alexander_每一个模式描qC一个在我们周围不断重复发生的问题以及该问题的解x案的核心?/p>
׃大多是做研发的，往往有自q体会Q遇到问?-解决问题Q这个过E中会发现有一些问题及其解x案不断变换面孔重复出玎ͼ其后面的有着共同的本质。实际上q些本质是模式?br />
从哲学角度说Q设计模式的出现是实늻验的l晶Q是产生于实践ƈ指导实践?br />
<?gt;联想
说到q里Q我们现在用的、谈的比较火爆的是Spring Hibernate之类的框架。是吧？
Struts直接革新了Web Model 2的应用?br />
Hibernate直接解决了持久层的非面向对象的尴?br />
Spring直接挑战了原先的Java EE框架?br />
q些都是源于实践。选择一U架构、一U技术的依据是什么？ Rod Johnson 认ؓQ应该是Z实践的依据、来自历史项目或亲自试验的经验，而不是Q何Ş式的偶像崇拜或者门户之见?q个是@序方法：实践的反复ȝ。（十的哲学）
Z么说Spring是实늚ȝQ大家可以看一下我的blog的一片文?a href="http://m.tkk7.com/crazycy/archive/2006/06/05/50519.aspx">http://m.tkk7.com/crazycy/archive/2006/06/05/50519.aspx 比较略?/p>
<?gt; 哲学
周爱民先生的《大道至 ?软g工程实践者的思想》对Ҏ、方法论有如下描qͼ
============================================================================================================
3. Ҏ
推动q种逻辑向前发展的，?/span> “ Ҏ ” ?/span> “ Ҏ?/span> ” 的出现。长期的~程实践Q自然的归演与ȝQ必L淀为某U?/span> ( 软g开?/span> ) ҎQ于?/span> “ q程 ” 出现了，于是 “ 对象 ” 出现了，于是相关的方法论也就出现了?/span>
q是实践的成果。方法不是某个h或者某个组l创造的。瓜熟而蒂落，实践U篏辑ֈ一定的E度Q微软不提出某个ҎQ?/span> IBM 也会提出q个Ҏ。即便他们都不提出，可能你自己已l在使用q个Ҏ了?/span>
Ҏq不秘Q因为它是你今天正在做的、从事的和实现的。正?/span> “ 模式 ” 是一U方法，而模式就是你昨天书写代码的那个行为。只不过Q?/span> GoF 归纳、抽取、提升了q些行ؓ的内在规律?/span>
你看不到你做事的行ؓQ也׃能理?/span> “ 模式 ” 作ؓ一U方法的价倹{所以大师们众口一词：模式需要一定的~程l验才能理解?/span>
同理Q理解过E也需要编E经验，理解对象也需要编E经验，理解 MDA ?/span> SOA q是需要编E经验?/span>
—?/span> q可能就发生在你d你上一行代码编写的l过Q或者上一个项目失败的l历的那一瞬息。经验来源于回顾、理解与分析Q而不是你要写的下一行代码?/span>
有h在寺院扫了一辈子的落叶而得道，也有人因Z句话而得道?/span>
GoF 因ؓ无数ơ的代码回顾而得道?/span>
感觉不过瘑֏以看一下我的blog文章Q?br /> http://m.tkk7.com/crazycy/archive/2006/05/24/47799.html
而对于方法论Q查了一下大概阐q如下：Ҏ论是一套完整的实践引导体系Q是指导实践的理论基Q是Z在长期社会实践中ȝ和摸索出来的Q符合客观发展规律的Q符合h们对研究对象q行U学分析与判断的C会实践q程或步骤。方法是实践的成果，如同瓜熟蒂落Q实늧累达C定程度，必然会提出方法?/p>
<?gt;DP产生的必要性和目标
׃大家对OO~程都熟悉，OO的三个基本特征：装、ѝ多态?br />
Ac： q样也就辑ֈ了DP的目标，也正是因个目标的提出Q才诞生了IoC?br />
可以参考的我blog文章Q?a href="http://m.tkk7.com/crazycy/archive/2006/03/19/36068.aspx">http://m.tkk7.com/crazycy/archive/2006/03/19/36068.aspx 可参考我的blog文章Q?a href="http://m.tkk7.com/crazycy/archive/2006/04/30/44169.html">http://m.tkk7.com/crazycy/archive/2006/04/30/44169.html 大家都用qStruts吧？
OO解决不了的问?-JavaZ子：
java语言要求一个类实例化时Q必调用这个类的具体类的构造子Q所以java语言l出的类的实例化Ҏ无法做到只依赖抽象类型?br />
q造成了调用者合被调用者的一U紧耦合
设计模式q求的目标是调用者和被调用者之间的解耦?/font>
CZQ?br />
消费一个对象的客户端只依赖于对象的抽象cdQ而不是具体类?/p>
State state = new StartState();
工厂c：
public class StateFactory {
public State static createState() {
State state = new. StartState();
return state;
}
}
Ac：
State state = StateFactory.createState();
q样很Ҏ理解工厂cd是生产对象，也就是创建对象，把对象的创徏q程从类A中摘取出?
q里有朋友问抽象工厂和工厂方法两个模式的区别Q?br />
可以参考我的blog文章Q?a href="http://m.tkk7.com/crazycy/archive/2006/10/08/73858.html">http://m.tkk7.com/crazycy/archive/2006/10/08/73858.html
<?gt;介绍几个模式
Decorator模式?br />
1. 对真实对象进行包?
2. 使其功能扩展
3. 表现形式Qnew 包装c?Qnew 包装c?(真实对象)Q；q样真实对象具备了本n、包装类1、包装类2的功能；
4. 实现时只需要把真实对象做ؓ包装cȝ聚合对象Q?
实在不行想想MLӞ如果带上TT后，原来的不影响Q而且q安全了。主要就是包装原先的对象?/p>
Dynamic Proxy模式?br />
代理模式QProxyQ这里侧重于Dynamic ProxyQ可以理解成l一个对象提供一个代理对象，q个代理对象是把原对象q行包装Q其与调用处理器相兌?br />
因ؓ代理对象和真实对象具有相同的接口Q客戯问时Q通过接口调用代理实例的方法，q个调用会被分发到该实例对应的处理器。处理器在把客户端调用传递给真实的对象之前或者之后，可执行某个操作，也可以选择不把q个调用传递给真实的对象?br />
1. 真实对象包?
2. 使其与调用处理类l定
3. 表现形式QProxy.newProxyInstance(realObject.getClass(). getClassLoader(), realObject.getClass().getInterfaces(), new InvocationHandler(realObj))Q这L实对象就与InvocationHandlerc邦定了Q对外是一个代理类的Ş式；
4. 实现时只需要把真实对象做ؓ调用处理器的聚合对象
实在不行想惻I垂帘听政Q犹如清朝康熙年间的四大府臣Q很多权利不在皇帝手里，必须通过辅佐大臣dQ?br />
具体CZ参加blogQ?br />
http://m.tkk7.com/crazycy/archive/2006/04/29/44006.html
Command模式
本质Q将调用操作的对??知道如何实现Ҏ作的对象 解耦?br />
1 调用?br />
发出h的对象，h被包装成h对象的Ş式（侧重于对象）
2 接收?br />
知道如何处理某个h的对象?br />
3 兌?br />
具备调用者传入的h对象Q?br />
q且l定接收者?/p>
或许Struts的Action是一个很好的说明CZQ?br />
Public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest req, HttpServletResponse res)
Ҏ的action是兌?br />
Ҏ的req可以理解成请求?br />
Ҏ的form 是h对象
Ҏ的mapping是接收?/p>
]]>
1. 首先介绍Ҏ论，参考了《大道至—Y件工E者实c?br />2. DP与Spring、SOAcLQ皆Z实践
3. DP的必要性和要点Q辅助代码简要说?br />4. 抛砖引玉Q介l几个DPQ?br /> a) Factory Pattern
b) Decorator Pattern
c) Proxy Pattern
d) SingLeton Pattern
e) Command Pattern
f) 其它看情?br />介绍点：
a) 使用一些可与现实结合的生动例子
b) 介绍其本质（个h理解Q?br /> c) 要介l其如何使用
具体内容:
]]>
- 对真实对象进行包?
- 使其功能扩展
- 表现形式Qnew 包装c?Qnew 包装c?(真实对象)Q；q样真实对象具备了本n、包装类1、包装类2的功能；实现时只需要把真实对象做ؓ包装cȝ聚合对象Q?
Dynamic Proxy模式?/p>
- 真实对象包?
- 使其与调用处理类l定
- 表现形式QProxy.newProxyInstance(realObject.getClass().getClassLoader(), realObject.getClass().getInterfaces(), new InvocationHandler(realObj))Q这L实对象就与InvocationHandlerc邦定了Q对外是一个代理类的Ş式；实现时只需要把真实对象做ؓ调用处理器的聚合对象
==============以下是引用，2007q?5?1日增?==============
首先我们来明一下动态代理的定义Q?font color=#000080>一个动态代理类在运行期implements一linterfaceQ得interface实现cȝҎ调用被分z至其他的类(另外的interface实现cL者Q意的c?的方?/font>。讲得更通俗一些，要了解动态代理，我们p知道什么东西动态了Q代理了什么？首先Q一个Proxy代理了一linterface的方法。注意，代理的是interfaceQ而不是ClassQ也不是abstract ClassQ其ơ，Proxyh的型别由l定的interface所军_?/font>Q动态就体现在此。也许看着q样的定义，q是会一头雾_那么我们d图来看看吧?
从图中，我们可以看到Dynamic Proxyq没有实现Resourceq个接口Q但是包含了Resource接口实现cȝ实例Q在Dynamic Proxy的createҎ中，通过调用Proxy.newProxyInstance创徏一个ProxyQƈ该Proxy与Resource接口l定Q最后将Proxy昑ּcd转换成Resource接口cdq返回，q样调用者就可以通过Proxy调用interface定义的方法了Q由于Proxy与Resource接口l定了，对Resource接口的方法调用，都会交由Proxy的invokeҎd理。而invokeҎ会根据不同的ҎQ或l以全新的实玎ͼ或直接将Ҏ调用交给Proxy中包含的Resource接口实现cȝ实例d理。综合上面所说的Q作Z个Dynamic ProxyQ它必须满以下三个条gQ?
1、实CInvocationHandler接口Q实现接口中定义的invokeҎQ?
2、包含接口实现类的实例；
3、通过Proxy.newProxyInstanceҎ实现Proxy与接口之间的l定?
以下代码l出了一个简单的Dynamic Proxy实现Q?
public interface Resource {
public void operationA();
public void operationB();
}
public void operationA();
public void operationB();
}
public class ConcreteResource implements Resource {
public void operationA() {
System.out.println("Operation A.");
}
public void operationB() {
System.out.println("Operation B.");
}
}
public void operationA() {
System.out.println("Operation A.");
}
public void operationB() {
System.out.println("Operation B.");
}
}
public class DynamicProxy implements InvocationHandler {
private Resource resource;
public DynamicProxy() {
resource = new ConcreteResource();
}
public Resource create() {
Resource returnResource = null;
returnResource = (Resource) Proxy.newProxyInstance(Resource.class
.getClassLoader(), new Class[] { Resource.class },
this);
return returnResource;
}
public Object invoke(Object obj, Method method, Object[] args) {
Object o = null;
try {
if (method.getName().equals("operationA")) {
System.out.println("OperationA in Proxy");
} else {
o = method.invoke(obj, args);
}
} catch (Exception e) {
e.printStackTrace(); }
return o;
}
}
private Resource resource;
public DynamicProxy() {
resource = new ConcreteResource();
}
public Resource create() {
Resource returnResource = null;
returnResource = (Resource) Proxy.newProxyInstance(Resource.class
.getClassLoader(), new Class[] { Resource.class },
this);
return returnResource;
}
public Object invoke(Object obj, Method method, Object[] args) {
Object o = null;
try {
if (method.getName().equals("operationA")) {
System.out.println("OperationA in Proxy");
} else {
o = method.invoke(obj, args);
}
} catch (Exception e) {
e.printStackTrace(); }
return o;
}
}
public class Test {
public static void main(String[] args) {
DynamicProxy proxy = new DynamicProxy();
Resource resource = proxy.create();
resource.operationA();
}
}
public static void main(String[] args) {
DynamicProxy proxy = new DynamicProxy();
Resource resource = proxy.create();
resource.operationA();
}
}
目前整个开发社区对AOP(Aspect Oriented Programing)推崇备至Q也涌现出大量支持AOP的优UFramework,--Spring, JAC, Jboss AOP {等。AOPg一时之间成了潮。Java初学者不要发出感慨QOOPq没有学通呢Q又来AOP。本文不是要在理Z具体阐述何ؓAOP, Z要进行AOP . 要详l了解学习AOP可以到它老家http://aosd.netȝ瞧。这里只是意N过一个简单的例子向初学者展CZ下如何来q行AOP.
Z单v见，例子没有没有使用MW三方的AOP Framework, 而是利用Java语言本n自带的动态代理功能来实现AOP.
让我们先回到AOP本nQAOP主要应用于日志记录，性能l计Q安全控?事务处理{方面。它的主要意囑ְ要将日志记录Q性能l计Q安全控制等{代码从商业逻辑代码中清楚的划分出来Q我们可以把q些行ؓ一个一个单独看作系l所要解决的问题Q就是所谓的面向问题的编E?不知AOP译作面向问题的编E是否欠?。通过对这些行为的分离Q我们希望可以将它们独立地配|到商业Ҏ中，而要改变q些行ؓ也不需要媄响到商业Ҏ代码?
假设pȝ׃pd的BusinessObject所完成业务逻辑功能Q系l要求在每一ơ业务逻辑处理时要做日志记录。这里我们略d体的业务逻辑代码?
q里处理商业逻辑的代码和日志记录代码混合在一Pq给日后的维护带来一定的困难Qƈ且也会造成大量的代码重复。完全相同的log代码出现在pȝ的每一个BusinessObject中?
按照AOP的思想Q我们应该把日志记录代码分离出来。要这些代码分d涉及C个问题，我们必须知道商业逻辑代码何时被调用，q样我们好插入日志记录代码。一般来说要截获一个方法，我们可以采用回调Ҏ或者动态代理。动态代理一般要更加灉|一些，目前多数的AOP Framework也大都采用了动态代理来实现。这里我们也采用动态代理作Z子?
JDK1.2以后提供了动态代理的支持Q程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理器Q然后通过java.lang.reflect.Proxy得到一个代理对象，通过q个代理对象来执行商业方?在商业方法被调用的同Ӟ执行处理器会被自动调用?
有了JDK的这U支持，我们所要做的仅仅是提供一个日志处理器?
现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了?
客户端调用商业方法的代码如下Q?br>
E序输出如下Q?
x我们的第一ơ小试是完成了。可以看刎ͼ采用AOP之后Q日志记录和业务逻辑代码完全分开了，以后要改变日志记录的话只需要修Ҏ志记录处理器p了，而业务对象本w（BusinessObjectQ无需做Q何修攏Vƈ且这个日志记录不会造成重复代码了，所有的商业处理对象都可以重用这个日志处理器?
当然在实际应用中Q这个例子就昑־太粗p了。由于JDK的动态代理ƈ没有直接支持一ơ注册多个InvocationHandlerQ那么我们对业务处理Ҏ既要日志记录又要性能l计Ӟ需要自己做一些变通了。一般我们可以自己定义一个Handler接口Q然后维护一个队列存放所有Handler, 当InvocationHandler被触发的时候我们依ơ调用自qHandler。所q的是目前几乎所有的AOP Framework都对q方面提供了很好的支?q里推荐大家使用Spring?br>
Z单v见，例子没有没有使用MW三方的AOP Framework, 而是利用Java语言本n自带的动态代理功能来实现AOP.
让我们先回到AOP本nQAOP主要应用于日志记录，性能l计Q安全控?事务处理{方面。它的主要意囑ְ要将日志记录Q性能l计Q安全控制等{代码从商业逻辑代码中清楚的划分出来Q我们可以把q些行ؓ一个一个单独看作系l所要解决的问题Q就是所谓的面向问题的编E?不知AOP译作面向问题的编E是否欠?。通过对这些行为的分离Q我们希望可以将它们独立地配|到商业Ҏ中，而要改变q些行ؓ也不需要媄响到商业Ҏ代码?
假设pȝ׃pd的BusinessObject所完成业务逻辑功能Q系l要求在每一ơ业务逻辑处理时要做日志记录。这里我们略d体的业务逻辑代码?
| public interface BusinessInterface { public void processBusiness(); } public class BusinessObject implements BusinessInterface { private Logger logger = Logger.getLogger(this.getClass().getName()); public void processBusiness(){ try { logger.info("start to processing..."); //business logic here. System.out.println(“here is business logic”); logger.info("end processing..."); } catch (Exception e){ logger.info("exception happends..."); //exception handling } } } |
q里处理商业逻辑的代码和日志记录代码混合在一Pq给日后的维护带来一定的困难Qƈ且也会造成大量的代码重复。完全相同的log代码出现在pȝ的每一个BusinessObject中?
按照AOP的思想Q我们应该把日志记录代码分离出来。要这些代码分d涉及C个问题，我们必须知道商业逻辑代码何时被调用，q样我们好插入日志记录代码。一般来说要截获一个方法，我们可以采用回调Ҏ或者动态代理。动态代理一般要更加灉|一些，目前多数的AOP Framework也大都采用了动态代理来实现。这里我们也采用动态代理作Z子?
JDK1.2以后提供了动态代理的支持Q程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理器Q然后通过java.lang.reflect.Proxy得到一个代理对象，通过q个代理对象来执行商业方?在商业方法被调用的同Ӟ执行处理器会被自动调用?
有了JDK的这U支持，我们所要做的仅仅是提供一个日志处理器?
| public class LogHandler implements InvocationHandler { private Logger logger Q?Logger.getLogger(this.getClass().getName()); private Object delegate; public LogHandler(Object delegate){ this.delegate = delegate; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object o = null; try { logger.info("method stats..." Q?method); o = method.invoke(delegate,args); logger.info("method ends..." + method); } catch (Exception e){ logger.info("Exception happends..."); //excetpion handling. } return o; } } |
现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了?
| public class BusinessObject implements BusinessInterface { private Logger logger = Logger.getLogger(this.getClass().getName()); public void processBusiness(){ //business processing System.out.println(“here is business logic”); } } |
客户端调用商业方法的代码如下Q?br>
| BusinessInterface businessImp = new BusinessObject(); InvocationHandler handler = new LogHandler(businessImp); BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance( businessImp.getClass().getClassLoader(), businessImp.getClass().getInterfaces(), handler); proxy.processBusiness(); |
E序输出如下Q?
| INFO: method stats... here is business logic INFO: method ends... |
x我们的第一ơ小试是完成了。可以看刎ͼ采用AOP之后Q日志记录和业务逻辑代码完全分开了，以后要改变日志记录的话只需要修Ҏ志记录处理器p了，而业务对象本w（BusinessObjectQ无需做Q何修攏Vƈ且这个日志记录不会造成重复代码了，所有的商业处理对象都可以重用这个日志处理器?
当然在实际应用中Q这个例子就昑־太粗p了。由于JDK的动态代理ƈ没有直接支持一ơ注册多个InvocationHandlerQ那么我们对业务处理Ҏ既要日志记录又要性能l计Ӟ需要自己做一些变通了。一般我们可以自己定义一个Handler接口Q然后维护一个队列存放所有Handler, 当InvocationHandler被触发的时候我们依ơ调用自qHandler。所q的是目前几乎所有的AOP Framework都对q方面提供了很好的支?q里推荐大家使用Spring?br>
]]>
产生代理对象的过E就是将原对象和调用处理器邦定的q程Q如下：
Proxy.newProxyInstance(真实对象实例.getClass().getClassLoader(), 真实对象实例.getClass().getInterfaces(), 与真实对象关联的调用处理器实?;
CZQ?br />public interface AnInterface {
void say();
}
public class AClass implements AnInterface {
public AClass() {
System.out.println("AClass:AClass()");
}
public void say() {
System.out.println("AClass:say()");
}
}
public class MyHandler implements InvocationHandler {
private Object realObj;
private MyHandler() {
}
public Object bind(Object realObj) {
this.realObj = realObj;
return Proxy.newProxyInstance(realObj.getClass().getClassLoader(),
realObj.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method md, Object[] args) throws Throwable {
Object obj = null;
System.out.println("invoke()");
obj = md.invoke(realObj, args);
return obj;
}
}
public class Test {
public static void main(String[] args) {
MyHandler handler = new MyHandler ();
AnInterface proxyObj = handler.bind(new AClass());
proxyObj.say();
}
}
]]>