public final static DateFormat getDateInstance(int style)

dateformat.date.support = MM/dd/yy;MM/dd/yyyy
dateFormat.time.show = hh:mm

List<DateFormat> getSupportedFormats(boolean withTime) {
ResourceMap rm = context.getResourceMap(getClass());
		String timeFormat = rm.getString("dateFormat.time.show");
		List<DateFormat> formats = new ArrayList<DateFormat>();
		for (String format : rm.getString("dateformat.date.support").split(";")) {
			formats.add(new SimpleDateFormat(format));
			formats.add(new SimpleDateFormat(format + " "
					+ timeFormat));
		}
		formats.add(DateFormat.getInstance());
		return formats;
}

List<DateFormat> getSupportedFormats(boolean withTime) {
ResourceMap rm = context.getResourceMap(getClass());
		String timeFormat = rm.getString("dateFormat.time.show");
		List<DateFormat> formats = new ArrayList<DateFormat>();
		for (String format : rm.getString("dateformat.date.support").split(";")) {
		  if (withTime) {
                     formats.add(new SimpleDateFormat(format + " "
					+ timeFormat));
                     formats.add(new SimpleDateFormat(format));

                } else {
                     formats.add(new SimpleDateFormat(format));
		     formats.add(new SimpleDateFormat(format + " "
					+ timeFormat));
                  }
		}
		formats.add(DateFormat.getInstance());
		return formats;
}

dateformat.date.support = MM/dd/yyyy;MM/dd/yy
dateFormat.time.show = hh:mm

List<DateFormat> getSupportedFormats(boolean withTime) {
		ResourceMap rm = context.getResourceMap(getClass());
		String timeFormat = rm.getString("dateFormat.time.show");
		List<DateFormat> formats = new ArrayList<DateFormat>();
		// withTime = true -> date with time format will be added first. Otherwise 
		// the date format first
		int i = withTime ? 1 : 0;
		formats.add(DateFormat.getInstance());
		for (String format : rm.getString("dateformat.date.support").split(";")) {
			formats.add(i % 2 , new SimpleDateFormat(format));
			formats.add((i + 1) % 2, new SimpleDateFormat(format + " "
					+ timeFormat));
		}
		return formats;
	}

public class FormattedTextFieldFactoryTest {

	private static DateFormatHelper helper;

	@BeforeClass
	public static void init() {
		Locale.setDefault(Locale.US);
		helper = new DateFormatHelper();
	}

	public void addSupportedFormats() {
		List<DateFormat> list = helper.getSupportedFormats(false);
		assertEquals(list.size(), 5);
		assertEquals(list.get(0).format(createDate(2008, 10, 16)),
				"10/16/08");

		list = helper.getSupportedFormats(true);
		assertEquals(list.size(), 5);
		assertEquals(list.get(0).format(createDate(2008, 10, 16)),
				"10/16/08 12:00");
	}

	private Date createDate(int year, int month, int date) {
		GregorianCalendar cal = new GregorianCalendar();
		cal.clear();
		cal.set(Calendar.YEAR, year);
		cal.set(Calendar.MONTH, month - 1);
		cal.set(Calendar.DATE, date);
		return cal.getTime();
	}
}

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

请注意：本文的版权归作者所有，如转载请注明出处。

这段时间真是忙得要死，一方面要开发公司项目的系统框架，要将项目分成不同的子项目，编写核心代码；另一方面要将极限编程（XP）引入团队开发，部署各类XP需要的服务例如subversion啦，ant+ivy啦，Hudson啦等等。顺便说句题外话，ubuntu还真是不是一般的好用，建议有能力的全部转到ubuntu上去开发。

我目前开发的这个框架的客户端是具肥的客户端，也就是Swing客户端了。Swing应用相对于Web应用有很多优势，因为它更肥。数据验证就是其中一个。当然现在的Web应用通过使用Ajax也要比以前强很多了，但是还是避免不了在验证数据时向服务段发出请求，至少你无法避免验证结果从Web服务器传输到用户浏览器上这段过程。而Swing这类肥客户端可以实现完全在本地对数据进行验证，甚至可以断网继续工作（这也是Web应用目前在研发的一个重要课题）。

前段时间开发出了一个可以应用于所有Swing应用的通用数据验证模块，发现它在项目中使用后，对于普通的数据验证,程序员几乎不需要编码，效率提高了不少，就写了一篇博文拿出来和大家分享。原文是用英文写的，在这里：http://polygoncell.blogspot.com/2008/07/validation-module-for-swing-application.html 。英文好的朋友可以直接去那里看。

编写这个模块使用了很多不同的开源框架和类库，其中很重要的一个就是JXLayer。文章写完后，我就跑去邀请JXLayer的作者Alexp来指点一下，然后就在我的文章后面开始了一段讨论，挺有意思的，他不愧为是Swing team里面的牛人啊！厉害啊！呵呵。

ok，回到今天这篇文章的正题。今天的主要目的是将我的英文博文翻译成中文（自己的文章，我就不逐字逐句翻译了，意思到了就行了，可能还会随兴展开一番讨论）在这里展示给大家，与大家分享开发经验，希望大家能够从中获益，也希望能够以文会友，广交朋友。废话少说，切入正题。

数据验证（Validation）一直是软件开发中非常重要的一环，有了它，你的系统会让客户感到更加友善，同时你的系统也得到了一定程度的保护。一般来说，数据验证既可以在客户端也可以在服务端。默认的JSF数据验证就是在服务端，数据只能在被提交以后才能够被验证，然后把错误信息传递回用户的浏览器。后来大规模使用Ajax后，基本可以实现对修改的数据“即时”验证，注意这里是个打了引号的即时，数据事实上还是要在浏览器和服务端之间进行传递的，只不过Ajax将这种传递改为隐式了而已，理论上并没有真正实现（断网）即时验证。而在Swing应用上就能够达成这种愿望。

事实上，开发Swing应用时，数据验证一直比较棘手，需要手工编码的地方太多，效率不高。后来出了JGoodies Validation 结合JGoodies binding后，好了一些。这个JGoodies Validation既可以实现model层面的验证，也可以实现Bean层面的验证，但是多年使用下来，发现其实它比较适用于中小项目，而且要编写的代码其实一点不比自己手动编写的少。

JGoodies流行了一段时间后，sun开始推出自己的bean绑定方案：beansbinding（JSR 295），我个人感觉要比JGoodies binding好用（JGoodies的作者Karsten也在专家组里，这个人我以前和他一起共事过，我的msn space里面还有跟他的合影，绝对是Swing界的牛人）。这个beansbinding也提供数据验证，但是它的这个数据验证只是在target被改动后，数据被同步回source之前才会起作用，使用起来局限性比较大，而且编码量也不小。

由于目前绝大部分项目是基于POJO的，Hibernate validator已经提供了一个很好的数据验证框架，我们完全没必要再重复发明轮子，我们应该努力站在巨人的肩膀上，这样我们才能站得更高，看得更远。于是我考虑结合beansbinding和Hibernate Validator开发数据验证。还有一个重要的问题，那就是数据错误的时候，需要在用户界面上展示相应的信息，例如Error icon和错误提示，这部分我考虑使用JXLayer。

你可以在如下链接中找到相关框架的具体信息：

1. Hibernate Validator： http://www.hibernate.org/hib_docs/validator/reference/en/html_single/
2. Beansbinding: https://beansbinding.dev.java.net/
3. JXlayer: http://weblogs.java.net/blog/alexfromsun/

阅读这篇文章，不需要你熟悉这些类库，不过了解这些类库能够帮助你更好地理解这篇文章。

我的这个通用模块是参考JXLayer里面的一个demo类TextValidationDemo的，这个JXlayer是由Alexander Potochkin开发的，我很喜欢，使用起来很顺手，强烈推荐使用。

下面开始介绍代码。首先是建立一个java项目，对于这个小项目，我使用netbeans。这里说句题外话，中型和大型的Swing应用，建议最好还是不要使用netbeans的GUI Builder，一方面它生成的代码超级烂，另一方面很难测试。目前市面上有很多好用的layout的框架，例如 JGoodies form和MigLayout，开发效率绝对不比netbeans的GUI builder差，你还不需要面对令人头疼的机器成的代码。

项目创建好后，加入类库：



然后写一个persistence bean:

package de.jingge.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import org.hibernate.validator.Length;
import org.hibernate.validator.NotEmpty;

@Entity
public class Country extends AbstractBean {

private static final long serialVersionUID = 5341382564159667599L;
public static final String PROPERTYNAME_NAME = "name";
public static final String PROPERTYNAME_CODE = "code";
private String name;
private String code;
private Long id;

public Country() {
}

public Country(String code, String name) {
    super();
    setCode(code);
    setName(name);
}

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

@NotEmpty
public String getName() {
    return name;
}

public void setName(String name) {
    firePropertyChange(PROPERTYNAME_NAME, this.name, this.name = name);
}

@Length(min=2, max= 2, message="Code length must be 2")
@NotEmpty
public String getCode() {
    return code;
}

public void setCode(String code) {
    firePropertyChange(PROPERTYNAME_CODE, this.code, this.code = code);
}
}

这里我为了强调可以在Swing客户端直接使用和验证persistence bean，故意写了一个persistence bean，实际应用中，这个类只需要是一个pojo就行了。

这个Country类代表一个国家，它有两个属性，code和name，我给他们分别加上个各自的验证限制。code不能为空，且必须正好是两个字符，例如CN，DE，US。name不能为空。这些annotaion均出自Hibernate Validator。那个父类AbstractBean出自SwingX类库，我们的Country类继承了它之后就可以支持property change event了。

ok, 下面可以开始编写这个模块的核心代码了。前面说过，我会使用JXlayer。使用它的好处是：所有JXlayer的painting event都会被转到UI类来，我们只需要编写一个集成Hibernate Validator的UI类就可以了，我称这个类为HibernateValidationUI，代码如下：

package de.jingge.view;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;

import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.text.JTextComponent;

import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.jdesktop.beansbinding.ELProperty;
import org.jdesktop.beansbinding.PropertyStateEvent;
import org.jdesktop.beansbinding.PropertyStateListener;
import org.jdesktop.jxlayer.JXLayer;
import org.jdesktop.jxlayer.plaf.AbstractLayerUI;

/**
* Header:
* Description: A layerUI which will validate the referenced property value of
* the object each time when the paint(...) method is called.

* The value of the given object property will be observed.
* Note: This UI works only with {@link JXLayer}. Any change of the property
* will force repainting the UI. The work process looks like: property changed ->
* jxlayer will be repainted -> the paint(...) method of this UI will be called.
* The logic of validation will be handled by the Hibernate validator
* framework.
*
*/
public class HibernateValidationUI extends AbstractLayerUI<jTextComponent> {

private Object object;
private String propertyName;
private ClassValidator validator;
private ELProperty elProperty;
private PropertyStateListener propertyChangeHandler;

public HibernateValidationUI(Object obj, String propertyName) {
    this.object = obj;
    this.propertyName = propertyName;
    propertyChangeHandler = new PropertyChangeHandler();
    validator = new ClassValidator(obj.getClass());

    elProperty = ELProperty.create("${" + propertyName + "}");
}

public void installUI(JComponent c) {
    super.installUI(c);
    elProperty.addPropertyStateListener(object, propertyChangeHandler);
}

public void uninstallUI(JComponent c) {
    super.uninstallUI(c);
    elProperty.removePropertyStateListener(object, propertyChangeHandler);
}

protected void paintLayer(Graphics2D g2, JXLayer<jTextComponent> l) {
    super.paintLayer(g2, l);
    InvalidValue[] validationMessages = validator.getInvalidValues(object,
            propertyName);
    if (validationMessages.length > 0) {
        BufferedImage image = Java2DIconFactory.createErrorIcon();
        g2.drawImage(image, l.getWidth() - image.getWidth() - 1,
                l.getHeight() - 8, null);
        l.getView().setToolTipText(validationMessages[0].getMessage());

        return;
    }
    l.getView().setToolTipText(null);
}

boolean isValid() {
    return validator.getInvalidValues(object, propertyName).length == 0;
}

class PropertyChangeHandler implements PropertyStateListener {

    @Override
    public void propertyStateChanged(PropertyStateEvent pse) {
        setDirty(true);
    }
}
}

这个HibernateValidationUI类只有一个构建器，它接收两个参数，一个是source object，也就是我们要修改的那个Bean类的实例，另外一个是这个bean的一个属性，这个HibernateValidationUI就负责验证这个属性。

在installUI()方法中，我们启动对属性变化的观察类，而在uninstallUI()方法里面，我们需要卸载这个观察类。

当给定对象的属性值发生变化时，PropertyChangeHandler的propertyStateChanged（）方法就会被调用，这个功能是通过elProperty和PropertzChangeHandler相结合来实现的。在propertyStateChangeed()方法里UI类的方法setDirty()会被调用，该方法的调用会导致UI类的状态变化，进而引发(re)painting，之后经过一系列的方法调用传递，paintLayer(Graphics2D g2, JXLayer<jTextComponent> l)这个方法将会被调用，这个方法要做的就是我们这个数据验证模块的核心功能：

1. 调用Hibernate Validator验证该属性。
2. 如果数据不正确，则在GUI上显示一个error icon，并且将错误信息作为tooltip展示给用户。

在第二点里面产生了一个问题，谢谢Alexp对我的指点。Swing team里面有一些规定，其中之一就是，在paint()方法里面最好不要改变Component的状态，而setTooltip()方法将会改变component的状态，因此需要在paint()方法之外调用。我目前使用下来，还没有发现什么严重的错误，决定暂时不改了，回头有时间在将这个代码翻新一下。

类中用到的Java2DIconFactory代码如下：

package de.jingge.view;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;

public class Java2DIconFactory {

public static BufferedImage createErrorIcon() {
    return createErrorIcon(7, 8);
}



public static BufferedImage createErrorIcon(int width, int height) {
    BufferedImage icon = new BufferedImage(width, height,
            BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2 = (Graphics2D) icon.getGraphics();
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
            RenderingHints.VALUE_STROKE_PURE);
    g2.setColor(Color.RED);
    g2.fillRect(0, 0, width, height);
    g2.setColor(Color.WHITE);
    g2.drawLine(0, 0, width, height);
    g2.drawLine(0, height, width, 0);
    g2.dispose();
    return icon;
}
}

没什么太多好解释的，就是使用Java 2D画一个Error icon。

接着，我们需要编写一个Factory类，构建一个JTextField，尽量把复杂技术封装起来，这样程序员开发起来可以提高效率，代码如下：

package de.jingge.view;

import javax.swing.JTextField;
import javax.swing.text.JTextComponent;
import org.jdesktop.beansbinding.AutoBinding;
import org.jdesktop.beansbinding.BeanProperty;
import org.jdesktop.beansbinding.BindingGroup;
import org.jdesktop.beansbinding.Bindings;
import org.jdesktop.beansbinding.ELProperty;
import org.jdesktop.jxlayer.JXLayer;
import static org.jdesktop.beansbinding.AutoBinding.UpdateStrategy.*;

public class GuiComponentFactory {

public static JXLayer<jTextComponent> createTextField(
        BindingGroup bindingGroup, Object sourceObject,
        String sourceProperty) {
    JTextField field = new JTextField();
    AutoBinding binding = Bindings.createAutoBinding(READ_WRITE,
            sourceObject, ELProperty.create("${" + sourceProperty + "}"),
            field, BeanProperty.create("text"));
    bindingGroup.addBinding(binding);
    bindingGroup.bind();
    return new JXLayer<jTextComponent>(field, new HibernateValidationUI(
            sourceObject, sourceProperty));
}
}

createTextField()方法主要将给定对象属性的值与JTextField的text绑定，然后将JTextField纳入到JXLayer的管理之下。这样一来，一旦用户在JTextField里面修改数据，这个改变就会同步到该对象属性上，然后就引发了前面描述的一系列逻辑，最终改变的数据就会被Hiberante Validator加以验证。

最后，我们可以编写一个Demo application来看看效果如何，代码如下：

package de.jingge.main;

import de.jingge.domain.Country;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.text.JTextComponent;
import net.miginfocom.swing.MigLayout;
import org.jdesktop.beansbinding.BindingGroup;
import org.jdesktop.jxlayer.JXLayer;
import static de.jingge.view.GuiComponentFactory.*;

public class ValidationApplicaton {

private BindingGroup bg;
private Country country;
private JXLayer<jTextComponent> codeField;
private JXLayer<jTextComponent> nameField;

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    try {
        UIManager.setLookAndFeel(
                "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
    } catch (UnsupportedLookAndFeelException ex) {
        System.err.println(
                "Nimbus L&F does not support. Default L&F will be used.");
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (InstantiationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    ValidationApplicaton app = new ValidationApplicaton();
    JFrame frame = new JFrame("Demo Validation Application");
    frame.setPreferredSize(new Dimension(360, 150));
    frame.getContentPane().add(app.buildPanel(), BorderLayout.CENTER);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setCenter(frame);
    frame.setVisible(true);
    frame.pack();

}

private static void setCenter(JFrame frame) {
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Dimension screenSize = toolkit.getScreenSize();

    // Calculate the frame location
    int x = (screenSize.width - (int) frame.getPreferredSize().getWidth()) / 2;
    int y = (screenSize.height - (int) frame.getPreferredSize().getHeight()) / 2;

    // Set the new frame location
    frame.setLocation(x, y);
}

public ValidationApplicaton() {
    country = new Country();
    bg = new BindingGroup();
}

private JPanel buildPanel() {

    codeField = createTextField(bg, country, Country.PROPERTYNAME_CODE);
    nameField = createTextField(bg, country, Country.PROPERTYNAME_NAME);
    JPanel panel = new JPanel(new MigLayout("",
            "[50px, right]10[200px:250px:300px]", "[center]"));
    panel.add(new JLabel("Code:"), "cell 0 0");
    panel.add(codeField, "cell 1 0, w 200px:250px:300px");
    panel.add(new JLabel("Name:"), "cell 0 1");
    panel.add(nameField, "cell 1 1, w 200px:250px:300px");
    return panel;
}
}

这个类比较简单了，我简单解释一下：

在main()方法里面，我们创建了一个JFrame，然后放入一个JPanel

setCenter()方法负责将窗口至于屏幕的正中间。

在构建器里面，我们创建了Country和BindingGroup的对象实例。

在buildPanel()方法里面，我们使用MigLayout构建了一个Panel，其中codeField和nameField对应各自的对象属性。更多关于MigLayout的信息看这里：http://www.miglayout.com/ 。这也是一个例子，大家可以看到使用MigLayout开发Swing真的是非常方便。

从这个Demo里面也可以看出，编写好pojo后，程序员只需要调用createTextField(bg, country, Country.PROPERTYNAME_CODE); 就可以创建一个支持数据验证的JTextField，编码量已经可以说是最大限度的降低了。

运行程序，你会看到：



这个code和name的数据都不合法，用户看到了error icon。

将鼠标移到Text field上，你会看到：



填好合法数据后，Error icon就不见了：



总结：

使用这个通用数据验证模块有很多好处：

1. 如果项目使用ORM，例如Hibernate，这个方案应该是解决数据验证的最好方案之一。
2. 对于普通的数据验证，例如非空，email，长度等等，程序员根本不需要编码，只要在POJO上使用相应的Hibernate Validator annotation就可以了。
3. 对于复杂的数据验证，Hibernate Validator提供了很好的扩展机制，只要写一个annotation外加一个Validator就可以了。Swing应用这边仍然不需要编写任何代码。

综上所述，可以看出通过使用这个通用数据验证模块，开发效率会提高很多。

对这个项目感兴趣的朋友可以给我留言，人数够多的话，我会考虑将整个netbeans项目上传到javaeye上来。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

选这 4 个模式在一起讨论首先是因为她们的功能比较类似，都是用来制造对象实例的，从归类来说，他们都属于制造类模式 (creational patterns) ，其次她们们在工作中比较常用，由于功能太过相似，往往导致在某个实际问题上让人举棋不定，似乎选哪个都可以解决问题，可是真的选择某个模式后，又会发现不是完全合适。今天我们就来讨论讨论在什么情况下选择什么模式来解决问题比较合适。

考虑到不是所有的朋友都对以上提到的 4 种模式都了如指掌，在开始讨论之前先简单的介绍一下这 4 个模式，对这 4 种模式熟悉的朋友也可以顺便回顾一下。请注意，这里我只会做简短的介绍，如果要比较深入地了解她们的话，还请去看模式相关的书籍，比较浅显易懂的我推荐 “Head First Design Patterns” 。如果要在工作中反复参考的我推荐 “ Applied Java Patterns ”。那本经典的 GOF Design Patterns 由于写的时间比较早，举的例子不太适合现在的软件开发，我个人认为初学者或者是没有太多时间的朋友没有必要去读那本书，尽管她的确是经典。

Factory Pattern

中文叫工厂模式 , 这个是我们在面向对象编程中最常用的模式之一了，她的主要功能就是制造对象，也正是这个原因才叫她为工厂模式，工厂干什么？生产产品。通常情况而言某个工厂所生产的产品总是一个系列的不同种类，大体上相同，细节上有差异。

图 1 展示了一个非常简单的例子，通常 CarFactory 类会提供下列方法来生产车辆 , 如代码片断 1 所示：

public class CarFactory {

       public Car createBusinessCar() {….}

       public Car createSportCar() {…}

}

代码片断 1

图 1 Factory Pattern

Abstract Factory Pattern

中文叫抽象工厂模式，顾名思义，就是把工厂模式在进一步抽象化，进一步细化。我们继续沿用上面的例子，不过这次增加产品的种类，如图 2 所示。由于我们增加了一层分类，当我们要生产某种车的时候就需要询问要哪种车 , 商用还是跑车？不然的话就要增加 create 方法，如果分类多了， create 方法就会成几何数量增长。

public class CarFactory {

       public Car createBusinessBMWCar() {….}

       public Car createBusinessBenzCar() {…}

       public Car createSportBMWCar() {….}

       public Car createSportBenzCar() {…}

}

代码片断 2

图 2 bad Factory Pattern

从面向对象的角度来讲，不是很好的解决方法，需要进一步抽象。结果就是把 CarFactory 进行抽象，然后针对不同品牌的车产生不同的工厂。 如图 3

图 3 Abstract Factory Pattern

这个时候每个工厂类仍然只需要 2 个方法，如代码片断 1 所示，用户会在不同需要的情况下得到不同的工厂对象，进而生产出需要的 Car 。不论这里工厂类如何实现，客户端的代码可以始终不变，类似这样： getCarFactory().createBusinessCar() 。

以上两个模式多用于：  

1 。 客户端需要依赖制造对象的细节。
  2. 一系列类似的对象需要被制造出来。
3.      同种对象不同实体需要在不同的地点不同是时间被制造出来。  

Factory Method Pattern

中文叫工厂方法模式， 通 常是用于当某个类的功能主要是针对生产出来的对象提供一些相关服务，而且这些对象有共同的接口，至于对象具体是什么，留给她的子类来决定。这样解释起来比 较晦涩难懂，我们还是沿用生产汽车的例子，不过不再用工厂，而是改用销售部门，因为销售部门主要为生产出来的车提供相关服务的，比方说，折扣，售后服务等 等。代码如代码片断 3 所示 , 这里 CarStore 是个抽象类，如何生产需要的车将由子类来进一步实现， 比方说 BMWStore 就会生产出 BMW 。图 4 展示了相关的 UML 图 , 总体看起来图 4 和图 3 非常相似， 但是从实现原理和实际应用上来说两者是完全不同的， 图 3 Abstract Factory 是针对 Interface 的多种不同的实现，具体使用的

时候是“组和”，用英语术语表达就是“ composition ”。 而图 4 Factory Method 是子类对抽象父类继承，进而实现父类的抽象方法， 具体使用的时候是 ” 继承 ” ， 用英语术语表达就是 ”inheritance” 。 也就是很多 OO 书里说谈到的“ is a? or has a? ”的问题， composition 指的就是 has a, 而 inheritance 指的就是 is a 。

public abstract class CarStore {

       // Factory method

       protected abstract Car createBusinessCar();

       protected abstract Car createSportCar();

public void sell() {

  createBusinessCar();

  discount(…);

....

}

       public double discount(Customer customer) {….}

       public void service() {…}

}

代码片断 3

这个模式多半会和另一个模式 Template Method 一起使用，事实上代码片断 3 中方法 sell() 就是 template Method 。具体关于 template method pattern 的详细讲解已不属于本文的讨论主题 ，感兴趣的朋友请看相关书籍。

图 4 Factory Method

Builder Pattern

中文叫生成器模式，我觉得叫构造模式更贴切，通常用于提供尽可能简单的接口来生成比较复杂的对象，这个复杂的对象通常包含有很多其他的对象。有些人认为 Builder 和 Factory Method 很相似，有时候是可以互换的，这样理解是错误的。这两个模式的侧重点是不同的， Builder 侧重的是构造复杂对象，而且经常是使用到 composite 模式 ; Factory Method 侧重的是生产各种各样不同的对象，这些对象通常都是比较简单的，一般而言， Factory Method 不会和 composite 联合使用。总的来说这两个模式是相辅相成的，决不能视为同类。具体原因我会在讨论中加以阐述。图 5 展示了 Builder 概念图。

 

图 5 Builder Pattern

考虑到使用 composite 模 式，我们使用另外一个例子，做饭，比较简单，常见，人人都做过，解释起来应该比较好懂。我们先定义好“食品”是对所有吃的物品的概括，做好的炸酱面是食 品，煮好的面条是食品，做好的酱是食品，做酱用的料也是食品。当我们去餐馆叫吃炸酱面时，我们只希望要一碗做好的炸酱面， 我们可不会希望对小二说煮面，切黄瓜丝，打鸡蛋，剁肉末，熬酱，等等。我们只希望说：“小二，来碗炸酱面。” 这时候就需要用到 builder,  builder 会提供一个简单的方法 createNoodleWithSource() — 做炸酱面，当顾客点吃炸酱面后， builder 就会在内部制造一系列的食品，比方说，煮面，切黄瓜丝，打鸡蛋，剁肉末，熬酱，等等。而这些细节，作为顾客是不需要费心的。

讨论

4 种模式都已经简要的介绍完了，到这里大家应该对她们有了大概地了解。从根本上来说，每一个模式都不难理解，真正困难的是选择，在什么情况下用哪个模式才是正确的？ 每一个初学者碰到了实际的问题都会产生疑问，好像用那个模式都可以解决问题。我对以上 4 种模式进行了一番对比，并结合工作中的实际问题进行了思考，并且和同事们展开了讨论（这真是人生一大快事啊！）。我的建议是“毛主席教导我们要用发展的眼光来看待这个问题“ 。

一般来说，在软件开发过程中，总是把大的问题进行细化，然后从小处入手，逐渐发展壮大。也就是说最开始的时候遇到的问题往往很小，一个类就可以解决了，对于只需要生成简单对象的情况，使用 Factory 模式；对于需要生成复杂对象的情况，用 builder 模式，只需要写一个类，借口拉，抽象类拉，完全不需要！目前不需要担心松紧耦合的问题。进一步优化的话，可以写两个类， builder 负责生成复杂的对象，而将所有关于生成简单对象的工作转交给 Factory ，用英语术语来表达的话叫“ delegate ” , 对应的模式叫 Business Delegate （ core J2EE Patterns ）。

当系统发展壮大后 , 需要生成很多种类的复杂对象，导致了需要很多 builder 来负责生成她们，这个时候就需要做两件事，第一是使用 Abstract Factory 模式，负责生成相对应的 builder 类，进而对各种复杂的对象生成进行系统的管理。第二是为各种类别的 builder 和 Factory 编写接口，然后利用 refactoring 将使用类的地方尽可能的替换为使用借口，也就是面向对象编程基本原理之一的“尽量针对接口编程，而不是针对实现类”。如果希望优化系统，减少对象实体的生成，可以视情况而定，采用 Singleton 模式。

请注意到目前为止，我们没有用到继承，这也是符合面向对象编程的原理的 — 组合优先于继承（ composition ， not inheritance ）。但是当系统再进一步发展长大后，她已经不能再称为模块，而是成长为框架（ framework ）时，我们就要考虑适当的使用 Factory Method 模式了。基本的功能将在父类中加以实现，而具体的对象生成交由子类来完成。如果结合其他模式来理解的话，就是子类中生成对象的工作将转交给其他 3 中模式类们来完成。如果希望在运行状态（ runtime ）时动态切换相关的 Builder 或 Factory 的话，可以采用 Strategy 模式。不过，就像很多介绍面向对象编程的书籍建议的那样，不到万不得已不要使用继承，也就是说，切忌在系统还非常简单的情况下就贸然使用 Factory Method 。

图 6 Big picture

到此为止所有 4 种模式都用上了，整个系统有如下优点：

1. 健壮，易于扩展，易于维护。
2. 针对接口，系统内部松散，解耦合。
3. 基本上避免了代码重复。

这样构件的系统里，我们用到了下列模式：

1.      Factory Pattern

2.      Abstract Factory Pattern

3.      Builder Pattern

4.      Singleton Pattern

5.      Template Method Pattern

6.      Composite Pattern

7.      Strategy Pattern

8.      Business Delegate Pattern

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

javaeye开始支持google广告了，这使我下定决心搬家来这里，以后我会将技术类文章在这里发表，我的MSN Space老家那里将只会出现非技术类的文章。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

 public class Foo {

    private boolean a;
    private boolean b;

    @inject
    public Foo(boolean a, boolean b) {
        this.a = a;
        this.b = b;
    }
} 

public class FooContainer {

    @inject
    private Foo foo;

} 

 public class Foo {
           @inject
           private Object o;
     } 

 public class Foo {

    @inject
    private String a;

    public Foo(String a) {
        this.a = a;
    }
} 

public class Foo {

    private Bar bar;

    public Foo() {
        bar = new Bar(this);
    }

public class Bar {

    private Foo foo;

    public Bar(Foo foo) {
      this.foo = foo;
    }

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

花了一年多的时间， 这本书终于出版了。这是我编写的第一本专业书籍，它是对我自大学毕业之后到目前为止整个职业经历的一个总结。这里面包括了，我在研究生期间从事的科研项目中获取的知识，以及硕士毕业后在德国各类公司参与开发和主持开发的各类项目中获取的实践经验。因此，这本书融合了学院派的理论知识和实践派的一线经验，我希望将自己多年学习和工作获取的知识和经验拿出来与国内的同行分享，并借这个机会与大家多多交流。

这本书不单单局限在Hibernate 3和JPA上，而是强调知识的含金量。本书在以Hibernate为中心的前提下，尽可能地扩展到各类在软件开发中需要使用到的理论和技术上去。因此在阅读本书的过程中，读者除了掌握Hibernate3和JPA，理解它们的内部构架，还会同时了解诸如极限编程，测试驱动开发，Java SE 5的新特性，JUnit 4的全新构架，以及Log4j，ant和Hudson等一系列开源框架的使用方法。

这里是本书的简介：本书介绍Hibernate开发知识。全书主要介绍信息持久化、对象持久化、对象关系映射等概念，以及Java SE5中最重要的新特性，初始化Hibernate的核心类，使用JPA提供的标准注释将实体类的不同属性映射到关系型数据库的表格，对象关系映射所要面对的两种复杂关系，使用Hibernate的扩展注释映射各类复杂的集合接口和集合类，实体对象在Hibernate中存在的4种状态，Session接口，Hibernate建立的一套完善的查询框架(Criterion)，Hibernate中封装SQL的策略，Hibernate EntityManager模块的内部构架。

全国各大书店有售，各大网上书店有售，欢迎大家批评指正。