中文字幕亚洲精品无码,亚洲黄色三级视频,亚洲第一页中文字幕

设计模式之Observer - Java设计模式

picture talk — Wed, 08 Oct 2008 10:06:00 GMT

Java深入��C��定程�?��׃��可避免的��到设计模式(design pattern)�q�一概念,了解设计模式,��自己对java中的接口或抽象类应用有更��q��理解.设计模式在java的中型系�l�中应用�q�泛,遵��@一定的�~�程模式,才能使自��q��代码便于理解,易于交流,Observer(观察�?模式是比较常用的一个模�?��其在界面设计中应用�q�泛,而本站所��x��的是Java在电子商务系�l�中应用,因此想从电子商务实例中分析Observer的应�?

虽然�|�上商店形式多样,每个站点有自��q��特色,但也有其一般的共�?单就"商品的变�?以便及时通知订户"�q�一�?是很多网上商店共有的模式,�q�一模式�c�M��Observer patern.

具体的说,如果�|�上商店中商品在名称 ��h��{�方面有变化,如果�pȝ��能自动通知会员,��是�|�上商店区别传统商店的一大特�?�q�就需要在商品product中加入Observer�q�样角色,以便product�l�节发生变化�?Observer能自动观察到�q�种变化,�q�能�q�行及时的update或notify动作.

Java的API�q��ؓ为我们提供现成的Observer接口Java.util.Observer.我们只要直接使用它就可以.

我们必须extends Java.util.Observer才能真正使用�?
1.提供Add/Delete observer的方�?
2.提供通知(notisfy) 所有observer的方�?

//产品�c?可供Jsp直接使用UseBean调用该类主要执行产品数据库插�?更新
public class product extends Observable{

　　private String name;
　　private float price;

　　public String getName(){ return name;}
　　public void setName(){
　　 this.name=name;
　　//讄��变化�?
　　 setChanged();
　　 notifyObservers(name);

　　}　　　

　　public float getPrice(){ return price;}
　　public void setPrice(){
　　 this.price=price;
　　//讄��变化�?br />　　 setChanged();
　　 notifyObservers(new Float(price));

　　}

　　//以下可以是数据库更新插入命��o.
　　public void saveToDb(){
　　.....................

}

我们注意�?在product�c�M�� 的setXXX�Ҏ��?我们讄��?notify(通知)�Ҏ��, 当Jsp表单调用setXXX(如何调用见我�?a target="_blank">另外一��文�?/font>),实际上就触发了notisfyObservers�Ҏ��,�q�将通知相应观察者应该采取行动了.

下面看看�q�些观察者的代码,他们�I�竟采取了什么行�?

//观察者NameObserver主要用来对��品名�U?name)�q�行观察�?br />public class NameObserver implements Observer{

　　private String name=null;

　　public void update(Observable obj,Object arg){

　　　　if (arg instanceof String){

　　　　 name=(String)arg;
　　　　 //产品名称改变值在name�?br />　　　　 System.out.println("NameObserver :name changet to "+name);

　　　　}

//观察者PriceObserver主要用来对��品�h�?price)�q�行观察�?br />public class PriceObserver implements Observer{

　　private float price=0;

　　public void update(Observable obj,Object arg){

　　　　if (arg instanceof Float){

　　　　 price=((Float)arg).floatValue();
　　
　　　　 System.out.println("PriceObserver :price changet to "+price);

　　　　}

Jsp中我们可以来正式执行�q�段观察者程�?

<%

if (request.getParameter("save")!=null)
{
　　product.saveToDb();

　　out.println("产品数据变动保存! �q�已�l�自动通知客户");

}else{

　　//加入观察�?br />　　product.addObserver(nameobs);

　　product.addObserver(priceobs);

　　//request.getRequestURI()是��生本jsp的程序名,��是自己调用自己
　　

<%

}

执行�?span lang="EN-US">Jsp�E�序,会出��C��个表单录入界�? 需要输入��品名�U?产品��h��, �Ҏ��Submit�?�q�是执行该jsp�?br />if (request.getParameter("save")!=null)之间的代�?

�׃��q�里使用了数据javabeans的自动赋值概�?实际�E�序自动执行了setName setPrice语句.你会在服务器控制��C��发现下面信息::

NameObserver :name changet to ?????(Jsp表单中输入的产品名称)

PriceObserver :price changet to ???(Jsp表单中输入的产品��h��);

�q�说明观察者已�l�在行动�?span lang="EN-US">.!!
同时你会在执行jsp的浏览器端得��C��?

产品数据变动保存! �q�已�l�自动通知客户

上文�׃��使用jsp概念,隐含很多自动动作,现将调用观察者的Java代码写如�?

public class Test {

　　public static void main(String args[]){

Product product=new Product();

NameObserver nameobs=new NameObserver();
PriceObserver priceobs=new PriceObserver();

//加入观察�?br />product.addObserver(nameobs);
product.addObserver(priceobs);

product.setName("��子�U�了");
product.setPrice(9.22f);

　　}

你会在发��C��面信�?span lang="EN-US">::

NameObserver :name changet to ��子�U�了

PriceObserver :price changet to 9.22

�q�说明观察者在行动�?span lang="EN-US">.!!

来源 �Q?http://book.javanb.com/java-design-patterns/Observer.html

picture talk 2008-10-08 18:06 发表评论

设计模式之Composite - Java设计模式

picture talk — Wed, 08 Oct 2008 08:53:00 GMT

Composite定义 :
��对象以树�Ş�l�构�l�织��h��,以达成“部分－整体�?的层�ơ结构，使得客户端对单个对象和组合对象的使用��h��一致�?

Composite比较�Ҏ��理解�Q�想到Composite��应该想到树形结构图。组合体内这些对象都有共同接�?当组合体一个对象的�Ҏ��被调用执行时�Q�Composite��遍�?Iterator)整个树�Ş�l�构,��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行。可以用牵一动百来�Ş宏V�?o:p>

所�?span lang="EN-US">Composite模式使用到Iterator模式�Q�和Chain of Responsibility模式�c�M��?o:p>

Composite好处 :
1.使客��L��调用��单，客户端可以一致的使用�l�合�l�构或其中单个对象，用户��׃��必关�p�自己处理的是单个对象还是整个组合结构，�q�就��化了客户端代码�?br />2.更容易在�l�合体内加入对象部�g. 客户端不必因为加入了新的对象部�g而更改代码�?o:p>

如何使用Composite?
首先定义一个接口或抽象�c�，�q�是设计模式通用方式了，其他设计模式�Ҏ��口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和��理Composite�l�合体的对象们（或称部�gComponent�Q?

下面的代码是以抽象类定义�Q�一般尽量用接口interface,

public abstract class Equipment
{
　　private String name;
　　//�|�络��h��
　　public abstract double netPrice();
　　//折扣��h��
　　public abstract double discountPrice();
　　//增加部�g�Ҏ��　　
　　public boolean add(Equipment equipment) { return false; }
　　//删除部�g�Ҏ��
　　public boolean remove(Equipment equipment) { return false; }
　　//注意�q�里�Q�这里就提供一�U�用于访问组合体�cȝ��部�g�Ҏ��?br />　　public Iterator iter() { return null; }
　　
　　public Equipment(final String name) { this.name=name; }
}

抽象�c?span lang="EN-US">Equipment��是Component定义�Q�代表着�l�合体类的对象们,Equipment中定义几个共同的�Ҏ��?o:p>

public class Disk extends Equipment
{
　　public Disk(String name) { super(name); }
　　//定义Disk�|�络��h��?
　　public double netPrice() { return 1.; }
　　//定义了disk折扣��h��?.5 �Ҏ��?br />　　public double discountPrice() { return .5; }
}

Disk是组合体内的一个对象，或称一个部�Ӟ��q�个部�g是个单独元素( Primitive)�?br />�q�有一�U�可能是�Q�一个部件也是一个组合体�Q�就是说�q�个部�g下面�q�有'儿子'�Q�这是树形结构中通常的情况，应该比较�Ҏ��理解。现在我们先要定义这个组合体�Q?o:p>

abstract class CompositeEquipment extends Equipment
{
　　private int i=0;
　　//定义一个Vector 用来存放'儿子'
　　private Lsit equipment=new ArrayList();

　　public CompositeEquipment(String name) { super(name); }

　　public boolean add(Equipment equipment) {
　　　　 this.equipment.add(equipment);
　　　　 return true;
　　 }

　　public double netPrice()
　　{
　　　　double netPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　netPrice+=((Equipment)iter.next()).netPrice();
　　　　return netPrice;
　　}

　　public double discountPrice()
　　{
　　　　double discountPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　discountPrice+=((Equipment)iter.next()).discountPrice();
　　　　return discountPrice;
　　}
　　

　　//注意�q�里�Q�这里就提供用于讉K��自己�l�合体内的部件方法�?br />　　//上面dIsk 之所以没有，是因为Disk是个单独(Primitive)的元�?
　　public Iterator iter()
　　{
　　　　return equipment.iterator() ;
　　{
　　//重蝲Iterator�Ҏ��
　　 public boolean hasNext() { return i　　//重蝲Iterator�Ҏ��
　　 public Object next()
　　 {
　　　　if(hasNext())
　　　　　　 return equipment.elementAt(i++);
　　　　else
　　　　　 throw new NoSuchElementException();
　　 }
　　

}

上面CompositeEquipment�l�承了Equipment,同时��己里面的对象们提供了外部讉K��的方�?重蝲了Iterator,Iterator是Java的Collection的一个接口，是Iterator模式的实�?

我们再看�?span lang="EN-US">CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet�Q�箱子里面可以放很多东西�Q�如底板�Q�电源盒�Q�硬盘盒�{�；盘盒里面可以放一些小讑֤��Q�如��盘软驱�{�。无疑这两个都是属于�l�合体性质的�?o:p>

public class Chassis extends CompositeEquipment
{
　　 public Chassis(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

public class Cabinet extends CompositeEquipment
{
　　 public Cabinet(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

��x��我们完成了整�?span lang="EN-US">Composite模式的架构�?o:p>

我们可以看看客户端调�?span lang="EN-US">Composote代码:

Cabinet cabinet=new Cabinet("Tower");

Chassis chassis=new Chassis("PC Chassis");
//��PC Chassis装到Tower�?(��盘盒装到箱子里)
cabinet.add(chassis);
//��一�?0GB的硬盘装�?PC Chassis (��硬盘装到盘盒里)
chassis.add(new Disk("10 GB"));

//调用 netPrice()�Ҏ��;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());

上面调用的方�?span lang="EN-US">netPrice()或discountPrice()�Q�实际上Composite使用Iterator遍历了整个树形结�?��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行.

Composite是个很��y妙体现智慧的模式�Q�在实际应用中，如果��到树�Ş�l�构�Q�我们就可以��试是否可以使用�q�个模式�?o:p>

以论坛�ؓ例，一个版(forum)中有很多帖子(message),�q�些帖子有原始脓�Q�有对原始脓的回应脓�Q�是个典型的树�Ş�l�构�Q�那么当然可以��用Composite模式�Q�那么我们进入Jive中看看，是如何实现的.

我们�?span lang="EN-US">ForumThread看到如下代码�Q?o:p>

public interface ForumThread {
　　 ....
　　 public void addMessage(ForumMessage parentMessage, ForumMessage newMessage)
　　　　　　 throws UnauthorizedException;

　　 public void deleteMessage(ForumMessage message)
　　　　　　 throws UnauthorizedException;

　　
　　 public Iterator messages();
　　　　 ....

}

�c�M��CompositeEquipment, 提供用于讉K��自己�l�合体内的部件方�? 增加删除遍历.

�l�合我的其他模式中对Jive的分析，我们已经基本大体理解了Jive论坛体系的框�Ӟ��如果你之前不理解设计模式�Q�而直接去看Jive源代码，你肯定无法看懂�?br />
:)

来源�Q?http://book.javanb.com/java-design-patterns/Composite.html

picture talk 2008-10-08 16:53 发表评论

The PathProxy pattern : Persisting complex associations

picture talk — Sat, 04 Oct 2008 11:09:00 GMT

PathProxy is a design pattern for persisting complex relationships without cluttering up your database.

When your class relationships require pathing knowledge, that is , knowledge about a number of related objects, then the standard "many - to" associations wont cut it, The PathProxy class is an abstraction of such relationships, allowing you to manage, persist, and extend them without complicating the classes themselves, and without a proliferation of lookup tables.

The fundamental idea is this : create class that can point to any entity in the system, and that also can reference its own class as a parent, With this class, you create a tree structure that maintains the interrelationships outside of the referenced objects. Building a JPA mapping around this class requires some though, but is quite powerful.

Path-Specific relationships

The PathProxy solution applies in any situation where an entity can appear as an association of another entity type, but only for a specific path. I refer to such relationships as path specific. E is a child of D, but only for the path A-->B-->C-->D-->E.On another path, D might have no children (A-->B-->Q-->D) or might have a different child or children(A-->B-->X-->D-->Z)

As an example, imagine a development team consisting of a project manager named Johnie and two developers, Robert and Mukunda. On project A, Johnie leads Robert and on Project B, Johnie leads Mukunda. This is a somewhat contrived example, but not an uncommon scenario in the world of corporate structures. In the real world, you might have the efficiency of the same process in different business locations, or the actions taken in response to the same event by different teams

When to use PathProxy?

You have many entities whose interrelationships are complex and require knowledge of other relationships. Creating explicit objects to represent these types of relationships becomes burdensome. This is expecially true if the objects must be persisted, creating a proliferation of database tables.

Consider PathProxy if , Your system design calls for a number of casses whose sole or primary function is to model the relationships between other objects.

Using PathProxy is more complicated than using simple objects to represent relationships, so consider your particular situation. If you have few relationships to store and they are not too complicated, PathProxy may not be the right choice. On the other hand, once you reach a certain level of relationship complexity, using PathProxy will greatly simplify your overall system design. Beijng able to reuse the same machnaism over and over again is also a huge time-saver.

来自 : http://www.javaworld.com/javaworld/jw-07-2008/jw-07-pathproxy.html?page=1

picture talk 2008-10-04 19:09 发表评论