Java Me Games

几个小故事

2007-04-02T12:26:00.000+08:00

一.後生可畏
小男孩问爸爸：“是不是做父亲的总比做儿子的知道得多？” 　　
爸爸回答：“当然啦！” 　　
小男孩问：“电灯是谁发明的？” 　　
爸爸：“是爱迪生。” 　　
小男孩又问：“那爱迪生的爸爸怎麽没有发明电灯？” 　　
（很奇怪，喜欢倚老卖老的人，特别容易栽跟斗。权威往往只是一个经不起考验的空壳子，尤其在现今这个多元开放的时代。）
二.不必紧张
小明洗澡时不小心吞下一小块肥皂，他的妈妈慌慌张张地打电话向家庭医生求助。
医生说：“我现在还有几个病人在，可能要半小时後才能赶过去。” 　　
小明妈妈说：“在你来之前，我该做甚麽？” 　　
医生说：“给小明喝一杯白开水，然後用力跳一跳，你就可以让小明用嘴巴吹泡泡消磨时间了。” 　　
（take it easy，放轻松放轻松些，生活何必太紧张？事情既然已经发生了，何不坦然自在的面对。担心不如宽心，穷紧张不如穷开心。）
三.钥匙
一把坚实的大锁挂在大门上，一根铁杆费了九牛二虎之力，还是无法将它撬开。钥匙来了，他瘦小的身子钻进锁孔，只轻轻一转，大锁就“啪”地一声打开了。　　
铁杆奇怪地问：“为什麽我费了那麽大力气也打不开，而你却轻而易举地就把它打开了呢？” 　　
钥匙说：“因为我最了解他的心。” 　　
（每个人的心，都像上了锁的大门，任你再粗的铁棒也撬不开。唯有关怀，才能把自己变成一只细腻的钥匙，进入别人的心中，了解别人。）
四.理由充份
一辆载满乘客的公共汽车沿着下坡路快速前进着，有一个人後面紧紧地追赶着这辆车子。
一个乘客从车窗中伸出头来对追车子的人说：“老兄！算啦，你追不上的！”
“我必须追上它，”这人气喘吁吁地说：“我是这辆车的司机！” 　　
(注：有些人必须非常认真努力，因为不这样的话，後果就十分悲惨了！然而也正因为必须全力以赴，潜在的本能和不为人知的特质终将充份展现出来。）

John W. Backus, Fortran语言的发明者逝世，享年82

2007-03-24T09:26:00.000+08:00

John W. Backus, 82, Fortran Developer, Dies

元宵猪

2007-03-22T23:13:00.000+08:00

看看今年元宵留下的照片，贴一个！
猪啊

java中的MVC设计

2007-03-10T10:58:00.000+08:00

什么是MVC
什么是MVC，MVC是Trygve Reenskaug(一个SmallTalk)在1979年提出的一种分离数据和界面的模式。由三个部分组成

Model(模型)：存储数据和规则，通常模型更接近现实模型

View(视图)：模型的展示，它描述模型数据应该如何被展示，假如模型发生变化，视图也要相应的变化。通常有“推模式”和“拉模式”，推模式是注册到视图上的模型会通知数据发生变化，更新相应的视图；而拉模式中视图会在需要的时候重新获取模型中的数据。

Control(控制器)：控制器会根据视图上用户的交互调用相应的动作执行。在一个独立的GUI程序中，可能这些交互就是按钮按下，滚动条拖动，在Web应用中，可能就是GET/POST的请求，控制器也能控制转换到新的视图。

传统的MVC结构
当然不同的MVC结构会让M,V,C三者间有不同的交互，第一个图就是Sun BluePrints Catalog中提到的一个通用的结构。下边我们进一步分析一下SUN模式的MVC。当M,V,C三者构造时会发生以下一些动作：

视图会注册一个监听器到模型，模型所有的改变都会通知所有的监听器，视图也能收到。这就是前边提到的推模式，当然，模型并不关心监听器是来自视图还是控制器，它只是简单的通知所有监听器。

控制器绑在(be bound to)视图上，视图上的任何交互都会调用执行控制器注册的一个监听器。
控制器有保存一个模型的引用，用来更新操作模型。

假如一个交互事件发生时候，会发生以下的动作：

视图辨认出什么样的交互发生－比如按钮按下、滚动条拖动，相应的调用控制器注册的监听器执行。

视图调用相应的监听器执行。

控制器调用模型，通过合适的方法更新模型数据。

数据模型发生变化，通知注册的监听器，比如视图。在其他一些结构中，控制器会负责更新视图。在Java的企业应用中常用到这一方法。

在这个图二中展示更详细调用过程。
正如前面所提到的，模型并不保存视图的引用，而是用模型变更事件通知，这样的一个好处就是一个模型能有多个视图，在模型变化的时候每一个视图都会得到更新，左图就表示了这么一个过程。

修改的MVC结构
在现代的一些MVC结构中，把控制器放在模型和视图中间。和传统的结构的最大的区别就是模型的改变是通过控制器转到视图的，控制器协调了视图->模型和数据->视图的双向的通信。视图的事件通过控制器来更新模型，模型的更新也通过控制器转到视图。所以在三者构造的时候，模型和视图都注册到控制器，当视图发生交互事件的时候发生的过程几乎是一样的。

视图辨认出什么样的事件发生。对应的监听器调用。

视图调用控制器注册的监听器。

控制器访问模型，更新模型数据。

数据发生变化，通知监听器，不一样的是这次的监听器是来自控制器的。

为什么要做这样的修改设计？这样的设计更好的分离了模型和视图，允许多个模型注册到一个控制器，控制器可以从多个模型中获取数据，和传统的一样，它也提供了同一个模型多个视图的办法。
使用修改后的MVC结构
都说事件是最好的老师，这一章节一起来把这中MVC结构事件一下。
设想为了显示一段需要五个属性控制的文字。

代码片断 一：
public class TextElementModel extends AbstractModel{
private String text;
private Font font;
private Integer x;
private Integer y;
private Integer opacity;
private Integer rotation;
/**
* Provides the means to set or reset the model to
* a default state
*/
public void initDefault() {
setOpacity(89);
setRotation(0);
setText("Sample Text");
setFont(new Font("Arial", Font.BOLD, 24));
setX(50);
setY(50);

}
//  Accessors
public String getText() {
return text;
}
public void setText(String text) {
String oldText = this.text;
this.text = text;
firePropertyChange(
 DefaultController.ELEMENT_TEXT_PROPERTY,
 oldText, text);
}
public Font getFont() {
return font;
}
public void setFont(Font font) {
Font oldFont = this.font;
this.font = font;
firePropertyChange(
 DefaultController.ELEMENT_FONT_PROPERTY,
 oldFont, font);
}
//  The remaining accessors for properties are omitted.
}

代码片断 二：
public abstract class AbstractModel{
  protected PropertyChangeSupport propertyChangeSupport;
  public AbstractModel(){
  propertyChangeSupport = new PropertyChangeSupport(this);
  }
  public void addPropertyChangeListener(PropertyChangeListener listener) {
  propertyChangeSupport.addPropertyChangeListener(listener);
  }
  public void removePropertyChangeListener(PropertyChangeListener listener) {
  propertyChangeSupport.removePropertyChangeListener(listener);
  }
  protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
  propertyChangeSupport.firePropertyChange(propertyName, oldValue, newValue);
  }
}


代码片断 三：
public abstract class AbstractController implements PropertyChangeListener {
 private ArrayList registeredViews;
 private ArrayList registeredModels;
 public AbstractController() {
   registeredViews = new ArrayList();
   registeredModels = new ArrayList();
 }
 public void addModel(AbstractModel model) {
   registeredModels.add(model); 
   model.addPropertyChangeListener(this);
 }
 public void removeModel(AbstractModel model) {
   registeredModels.remove(model);
   model.removePropertyChangeListener(this);
 }
 public void addView(AbstractViewPanel view) {
   registeredViews.add(view);
 }
 public void removeView(AbstractViewPanel view) {
   registeredViews.remove(view);
 }
 //  Use this to observe property changes from registered models
 //  and propagate them on to all the views.
 public void propertyChange(PropertyChangeEvent evt) {
   for (AbstractViewPanel view: registeredViews) {
     view.modelPropertyChange(evt); 
 }
}
/**
* This is a convenience method that subclasses can call upon
* to fire property changes back to the models. This method
* uses reflection to inspect each of the model classes
* to determine whether it is the owner of the property
* in question. If it isn't, a NoSuchMethodException is thrown,
* which the method ignores.
*
* @param propertyName = The name of the property.
* @param newValue = An object that represents the new value
* of the property.
*/
protected void setModelProperty(String propertyName, Object newValue) {
for (AbstractModel model: registeredModels) {
try {         
Method method = model.getClass().             
getMethod("set"+propertyName, new Class[] {
newValue.getClass()
});
method.invoke(model, newValue);
} catch (Exception ex) {
      //  Handle exception.     
} 
}  
}
}

控制器中有两个ArrayList分别用来保存注册的模型和视图。不论何时一个模型注册，控制器也同时把自己注册到模型来监听模型变化。在最后一个方法setModelProperty中用到了一些java反射的操作，是为了把控制器和模型完全分离开来。

代码片断 四
public class DefaultController extends AbstractController
{

public static final String ELEMENT_TEXT_PROPERTY = "Text";
public static final String ELEMENT_FONT_PROPERTY = "Font";
public static final String ELEMENT_X_PROPERTY = "X";
public static final String ELEMENT_Y_PROPERTY = "Y";
public static final String ELEMENT_OPACITY_PROPERTY = "Opacity";
public static final String ELEMENT_ROTATION_PROPERTY = "Rotation";

//  Code omitted

public void changeElementText(String newText) {
 setModelProperty(ELEMENT_TEXT_PROPERTY, newText);
}

public void changeElementFont(Font newFont) {
 setModelProperty(ELEMENT_FONT_PROPERTY, newFont);
}

public void changeElementXPosition(int newX) {
 setModelProperty(ELEMENT_X_PROPERTY, newX);
}

public void changeElementYPosition(int newY) {
 setModelProperty(ELEMENT_Y_PROPERTY, newY);
}

public void changeElementOpacity(int newOpacity) {
 setModelProperty(ELEMENT_OPACITY_PROPERTY, newOpacity);
}

public void changeElementRotation(int newRotation) {
 setModelProperty(ELEMENT_ROTATION_PROPERTY, newRotation);
}

}

视图部分
这里视图部分有两个，可以用Netbeans来创建，一个是属性配置的方式，一种是格式化显示。

代码片断 五
public PropertiesViewPanel(DefaultController controller) {
 this.controller = controller;
 initComponents();
 localInitialization();
}
/**
* Used to provide local initialization of Swing components
* outside of the NetBeans automatic code generator
*/
public void localInitialization() {
 opacitySpinner.setModel(new SpinnerNumberModel(100, 0, 100, 1));
 opacitySlider.setModel(new DefaultBoundedRangeModel(100, 0, 0, 100));
 rotationSpinner.setModel(new SpinnerNumberModel(0, -180, 180, 1));
 rotationSlider.setModel(new DefaultBoundedRangeModel(0, 0, -180, 180));
 text.getDocument().addDocumentListener(new DocumentListener() {
     public void insertUpdate(DocumentEvent e) {
         textDocumentChanged(e);
     }
     public void removeUpdate(DocumentEvent e) {
         textDocumentChanged(e);
     }
     public void changedUpdate(DocumentEvent e) {
         textDocumentChanged(e);
     }
 });
}
public void modelPropertyChange(final PropertyChangeEvent evt) {
 if (evt.getPropertyName().equals(
            DefaultController.ELEMENT_X_PROPERTY)) {
     String newStringValue = evt.getNewValue().toString();
     xPositionTextField.setText(newStringValue);
 } else if
    (evt.getPropertyName().equals(
            DefaultController.ELEMENT_Y_PROPERTY)) {
     String newStringValue = evt.getNewValue().toString();
     yPositionTextField.setText(newStringValue);
 } else if
    (evt.getPropertyName().equals(
            DefaultController.ELEMENT_OPACITY_PROPERTY)) {
     int newIntegerValue = (Integer)evt.getNewValue();
     opacitySpinner.setValue(newIntegerValue);
     opacitySlider.setValue(newIntegerValue);
 } else if
     (evt.getPropertyName().equals(
            DefaultController.ELEMENT_ROTATION_PROPERTY)) {
     int newIntegerValue = (Integer)evt.getNewValue();
     rotationSpinner.setValue(newIntegerValue);
     rotationSlider.setValue(newIntegerValue);
 } else if
    (evt.getPropertyName().equals(
            DefaultController.ELEMENT_TEXT_PROPERTY)) {
     String newStringValue = evt.getNewValue().toString();
     text.setText(newStringValue);
 } else if
    (evt.getPropertyName().equals(
            DefaultController.ELEMENT_FONT_PROPERTY)) {
     Font f = (Font)evt.getNewValue();
     String fontString = f.getFontName() + " " + f.getSize();
     font.setText(fontString);
     currentFont = f;
 }
 //  Remainder of the code omitted
}

代码片断 六
//  Code omitted
private void yPositionTextFieldFocusLost(java.awt.event.FocusEvent evt) {
 try {
     controller.changeElementYPosition(
         Integer.parseInt(yPositionTextField.getText()));
 } catch (Exception e) {
     //  Handle exception.
 }
}
private void yPositionTextFieldActionPerformed(java.awt.event.ActionEvent evt) {
 try {
     controller.changeElementYPosition(
         Integer.parseInt(yPositionTextField.getText()));
 } catch (Exception e) {
     //  Handle exception.
 }
}
//  Code omitted -- code for xPosition
//  is nearly the same as for yPosition.
private void changeFontButtonActionPerformed(java.awt.event.ActionEvent evt) {
 JFontChooserDialog fontChooser = new
     JFontChooserDialog((Dialog)this.getTopLevelAncestor());
 fontChooser.setSelectedFont(currentFont);
 fontChooser.setVisible(true);
 Font returnedFont = fontChooser.getSelectedFont();
 if (returnedFont != null) {
     controller.changeElementFont(returnedFont);
 }
}
private void opacitySliderStateChanged(javax.swing.event.ChangeEvent evt) {
 controller.changeElementOpacity((int)opacitySlider.getValue());
}
private void rotationSliderStateChanged(javax.swing.event.ChangeEvent evt) {
 controller.changeElementRotation((int)rotationSlider.getValue());
}
private void opacitySpinnerStateChanged(javax.swing.event.ChangeEvent evt) {
 controller.changeElementOpacity((Integer)opacitySpinner.getValue());
}
private void rotationSpinnerStateChanged(javax.swing.event.ChangeEvent evt) {
 controller.changeElementRotation((Integer)rotationSpinner.getValue());
}
private void textDocumentChanged(DocumentEvent evt) {
 Document document = evt.getDocument();
 try {
     controller.changeElementText(document.getText(0,
     document.getLength()));
 } catch (BadLocationException ex) {
     //  Handle exception.
 }
}

程序中的问题
程序运行起来，你马上会发现这样的问题：

一旦视图接受到事件，真实的用户操作。

控制器里面的对应的方法被调用。

模型改变，通知控制器模型改变。

视图接收到模型改变事件，更新相应的组件，设置正确的值。

视图改变，控制器相应的方法又被调用，模型又开始更新。

这种情况下有三种处理方式可以使用：

视图组件在通知更新的时候拒绝任何的更新。这种方式主要用在文本组件里面。

第二种方式是模型检查数据是否有变化，新的值和原来的值是一样的就不再发变更通知。

假如在视图和模型都没有检查，那么程序进入无限循环。

发生这些问题是因为Swing组件是自主的，举个例子，当用户按了JSpinner中的上箭头，JSpinner的数值+1,然后监听器被调用，模型更新。
在传统的模式中，视图仍然是上一个值的数据，依赖于模型的更新来把视图更新到正确的数值来。尽管如此，还是没有必要更新Swing组件，因为Swing组件已经把自己设置成正确的值了，甚至在视图更新事件发出之前就完成了。
那么如何来规避这样的事件呢，一种机制是让模型或是控制器不要传播这样的更新事件，但这不是一个好的办法。有可能有多个视图在监听这样的事件。假如关闭了这样的传播，就会导致其他的视图得不到更新。
理想的每一个视图组件都应该关系当前的值和新付的值，假如没有改变，就不发送通知。当然有些Swing组件已经包含了这样的逻辑，也有一些没有。有个办法来对付模型检查的，在设置模型的值的时候，检查一下新的值和老的值是否一样，假如是相同的就忽略这样的通知。


代码片断 七
public void modelPropertyChange(final PropertyChangeEvent evt) {
  if (evt.getPropertyName().equals(DefaultController.ELEMENT_X_PROPERTY)) {
      String newStringValue = evt.getNewValue().toString();
      if (!xPositionTextField.getText().equals(newStringValue))
          xPositionTextField.setText(newStringValue);
  }
  //  Remaining code omitted
}

图是最后运行的结果。

Second Life照片

2007-03-09T23:01:00.000+08:00

有几个朋友在玩Second Life的游戏。我也去看了看。发现这是一种全新的虚拟人生的游戏，人与人之间交流，可以用你的知识和能力为别人工作，帮人写脚本，盖楼。也有雇佣，你可以获得相应的报酬。
可惜我的机器太慢了，一步一顿的，很是不爽。
还有他们那些不知道到什么语言的英语，我这个教科书的英语无法跟上节奏了。于是还是回来逛论坛了。

Blogger开户了

2007-03-08T23:24:00.000+08:00

以前一直都在断断续续的写点豆腐渣，现在Google的股票换来的现金给我们带来了很多的方便，努力了，先贴一块。

路由器如何工作－路由表

2007-03-08T20:32:00.001+08:00

以前对于路由器总是似懂非懂的，今天花了点时间看看，在这里做一个记录。[摘自tcp/ip详解]

基本的网络环境

包如何在网络上转发参看tcp/ip协议详解第三章

路由表

srv4的路由表，详细参考tcp/ip协议详解第10章

sun的路由表，详细参考tcp/ip协议详解第10章

关于路由表的说明
对于一个给定的路由器，可以打印出五种不同的标志（ f l a g）：
U 该路由可以使用。
G 该路由是到一个网关（路由器）。如果没有设置该标志，说明目的地是直接相连的。
H 该路由是到一个主机，也就是说，目的地址是一个完整的主机地址。如果没有设置该
标志，说明该路由是到一个网络，而目的地址是一个网络地址：一个网络号，或者网
络号与子网号的组合。
D 该路由是由重定向报文创建的（ 9 . 5节）。
M 该路由已被重定向报文修改（ 9 . 5节）。

路由表的搜索

搜索匹配的主机地址；
搜索匹配的网络地址；
搜索默认表项（默认表项一般在路由表中被指定为一个网络表项，其网络号为0）。
匹配主机地址步骤始终发生在匹配网络地址步骤之前。

关键的说明，需要仔细理解，可以多看几遍

标志G是非常重要的，因为由它区分了间接路由和直接路由（对于直接路由来说是不设置标志G的）。其区别在于，发往直接路由的分组中不但具有指明目的端的I P地址，还具有其链路层地址（见图3 - 3）。当分组被发往一个间接路由时， I P地址指明的是最终的目的地，但是链路层地址指明的是网关（即下一站路由器）。我们在图3 - 4已看到这样的例子。在这个路由表例子中，有一个间接路由（设置了标志G），因此采用这一项路由的分组其I P地址是最终的目的地（1 4 0 . 2 5 2 . 1 3 . 6 5），但是其链路层地址必须对应于路由器1 4 0 . 2 5 2 . 1 3 . 3 5。
理解G和H标志之间的区别是很重要的。G标志区分了直接路由和间接路由，如上所述。但是H标志表明，目的地址（ n e t s t a t命令输出第一行）是一个完整的主机地址。没有设置H标志说明目的地址是一个网络地址（主机号部分为0）。当为某个目的I P地址搜索路由表时，主机地址项必须与目的地址完全匹配，而网络地址项只需要匹配目的地址的网络号和子网号就可以了。另外，大多数版本的n e t s t a t命令首先打印出所有的主机路由表项，然后才是网络路由表项。

不理解的一个问题

在sun的路由表上为什么会有140.252.1.183 140.252.1.29 uh 0 0 sl0这么一条路由，它什么时候有用呢？