• public void setErrorMessage(String newErrorMessage)：显示传入的错误信息。（我们把用这个方法设置的信息叫做error message。）当前显示的信息会被保存起来，等到error message清空之后会再次显示，而清空error message要传入null，而不是传入空字符串。
  
• setMessage(String newMessage)：显示传入的信息，等同于setMessage(String newMessage, IMessageProvider.NONE)。如果当前显示的是error message，那么newMessage会被保存起来，等到error message清空后再显示。
  
• setMessage(String newMessage, int newType)：显示传入的信息，并显示指定的信息类型。可用的类型有NONE、INFORMATION、WARNING和ERROR。需要注意的是， setMessage(String newMessage, int IMessageProvider.ERROR)和setErrorMessage(String newErrorMessage)并不相同。后者会覆盖当前的任何信息，而前者只会覆盖当前的非error message，不会影响到error message（也就是说当error message清空后才会显示）。
  

这样，我们就可以为一些文本框添加ModifyListener，然后在其中设置TitleArea的信息了。

接着，再让我们来看看Button Bar。有些时候，我们希望把OK和Cancel这种默认的Button放置在Button Bar的右侧，而把其他Button放置在Button Bar的左侧，如下图中的Customize... Button：



这又如何实现呢？有人可能想到在 createButtonsForButtonBar方法中做一些手脚，但是遗憾的是这行不通，我们真正要覆写的是createButtonBar方法，下面是一个简单的例子：

/*
 * (non-Javadoc)
 * 
 * @see org.eclipse.jface.dialogs.TrayDialog#createButtonBar(org.eclipse.swt.widgets.Composite)
 */
protected Control createButtonBar(Composite parent) {
    Composite composite = new Composite(parent, SWT.NONE);
    GridLayout layout = new GridLayout();
    layout.numColumns = 0;
    layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
    layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
    layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
    layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);

    composite.setLayout(layout);
    composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

    if (isHelpAvailable()) {
        createHelpControl(composite);
    }

    createButton(composite, MyConstants.IMPORT_BUTTON_ID, "Import", false).addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            MessageDialog.openInformation(MaintainModuleDialog.this.getShell(), "Information",
                "\"Import\" button has not been implemented.");
        }
    });

    createButton(composite, MyConstants.EXPORT_BUTTON_ID, "Export", false).addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            MessageDialog.openInformation(MaintainModuleDialog.this.getShell(), "Information",
            "\"Export\" button has not been implemented.");
        }
    });

    createButton(composite, MyConstants.OTHER_BUTTON_ID, "Other", false).addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            MessageDialog.openInformation(MaintainModuleDialog.this.getShell(), "Information",
            "\"Other\" button has not been implemented.");
        }
    });

    Label filler = new Label(composite, SWT.NONE);
    filler.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
    layout.numColumns++;

    super.createButtonsForButtonBar(composite);

    return composite;
}

正如你所见，我们实际上创建了自己的Button Bar，然后在上面添加了3个Button：Import、Export和Other，最后 super.createButtonsForButtonBar会创建OK和Cancel Button。filler是用来在两组Button见占位的。代码中用到的两个convert方法来自 org.eclipse.jface.dialogs.Dialog类，你还可以在这个类中找到一个getButton(int)方法，它可以根据传入的 ID返回用createButton创建的Button。这些都是非常实用的方法。

回头看一下上面那个完整的 TitleAreaDialog图片，你会看到在Dialog左下角有一个问号符号，这其实是一个Button，点击它可以显示帮助信息，当然帮助信息是由你来创建的。让我们看看Eclipse Search的TitleAreaDialog中的帮助信息吧：



如果我们也想实现这种帮助机制，那么就要实现如下方法：

/*
 * (non-Javadoc)
 * 
 * @see org.eclipse.jface.dialogs.TrayDialog#createHelpControl(org.eclipse.swt.widgets.Composite)
 */
protected Control createHelpControl(Composite parent) {
    // TODO Auto-generated method stub
    return super.createHelpControl(parent);
}

如果不想实现帮助机制，那么最好不要在Dialog中显示出那个问号符号，你可以覆写如下方法并永远返回false，这样就不会显示问号符号了。

/*
 * (non-Javadoc)
 * 
 * @see org.eclipse.jface.dialogs.TrayDialog#isHelpAvailable()
 */
public boolean isHelpAvailable() {
    return false;
}

那么这个酷酷的帮助机制到底是个什么东西呢？实际上，它的学名叫做DialogTray。TitleAreaDialog继承了

org.eclipse.jface.dialogs.TrayDialog类，而TrayDialog就可以显示这种 DialogTray，是不是有点儿拗口呢？实际上，我们不仅仅可以添加帮助信息这一种DialogTray，还可以添加任意的DialogTray，现在就让我们动手实现一个最简单的吧。代码很简单，最主要的就是要实现一个DialogTray，代码如下：

import org.eclipse.jface.dialogs.DialogTray;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;

public class MyDialogTray extends DialogTray {

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.dialogs.DialogTray#createContents(org.eclipse.swt.widgets.Composite)
     */
    protected Control createContents(Composite parent) {
        Composite container = new Composite(parent, SWT.NONE);
        final GridLayout gridLayout = new GridLayout();
        gridLayout.numColumns = 2;
        container.setLayout(gridLayout);

        final Label label = new Label(container, SWT.NONE);
        label.setText("Name:");

        final Text text = new Text(container, SWT.BORDER);
        text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

        return container;
    }

}

我们只在其中创建了一个Label和一个Text，这就足够了。最后，我们为MyTitleAreaDialog添加两个Button，用来打开和关闭MyDialogTray，代码如下：

final Button openTrayButton = new Button(container, SWT.NONE);
openTrayButton.setText("Open Tray");

final Button closeTrayButton = new Button(container, SWT.NONE);
closeTrayButton.setText("Close Tray");
closeTrayButton.setEnabled(false);

openTrayButton.addSelectionListener(new SelectionAdapter() {
    public void widgetSelected(final SelectionEvent e) {
        // this method is from TrayDialog
        openTray(new MyDialogTray());
        openTrayButton.setEnabled(false);
        closeTrayButton.setEnabled(true);
    }
});

closeTrayButton.addSelectionListener(new SelectionAdapter() {
    public void widgetSelected(final SelectionEvent e) {
        // this method is from TrayDialog
        closeTray();
        openTrayButton.setEnabled(true);
        closeTrayButton.setEnabled(false);
    }
});

最后我们会得到如下对话框：



好了，就讲这么多吧。如果能把这些东东适当地用在你的Application中，那么效果一定非常棒。

其中有个很头疼的问题是，那就是无法读取打包好的插件jar中的xml文件，最后没有办法，只好把这些xml文件分离出来不打包进去，而是放到了eclipse/plugins/目录下的一个文件夹中，这样顺利的解决了访问问题。不知道有没有更好的办法

另一个问题是，我使用xalan去做XLST transform,但是它转换完的xml节点是不带namespace前缀的

而恰恰恼人的是，xalan的XPATH解析器selectSingleNode()是需要namespace前缀的，即使使用的默认namespace，如<beans xmlns=http://org.w3c.....">

在做XPATH解析的时，也需要带上前缀，如 :beans/:bean, 只有不声明任何namespace时，才可以使用beans/bean, 否则就会抛异常，没办法解决，

1. 前提是你已经下载解压并设置好Eclipse工具，比如解压在E:\OpenSource\Eclipse\目录下，以下这个目录以%ECLIPSE_HOME%来进行表示；
2. 此时默认的插件是在%ECLIPSE_HOME%\plugins目录中的；
3. 在%ECLIPSE_HOME%下建立一个PlugInsNew的目录；
   　　比如：E:\OpenSource\Eclipse\PlugInsNew
   
4. 如果你下载了一个新的插件，比如叫做：XYZ
   
   那么就在%ECLIPSE_HOME%\PlugInsNew\目录下建立XYZ目录，目录里面是eclipse目录，eclipse目录包含有features与plugins两个子目录；结构如下图所示：
   
   
   
5. 把下载的新插件的文件放在以下相应目录中；
   　　%ECLIPSE_HOME%\PlugInsNew\XYZ\eclipse\features
   
   　　%ECLIPSE_HOME%\PlugInsNew\ XYZ\eclipse\plugins
   
   
6. 建立相关的.link的文件；
   
   　　然后在%ECLIPSE_HOME%\links目录里建立一个XYZ.link的文件
   
   　　内容如是：
   
   　　path=E:/OpenSource/Eclipse/PlugInsNew/XYZ
   
   　　就一行这样的路径指示而已。
   
   　　这样，如果你下载了多个插件就可以如法炮制建立多个Link文件，想加载哪个插件就把哪个插件的Link文件放到%ECLIPSE_HOME%\links的目录中即可，使用与管理都很方便，建议千万不要放在默认的安装目录中，这样对于升级Eclipse主程序也方便一些；当然如果你喜欢用Find and Install…进行安装的话也可以的；
   
   　　如果上面你的%ECLIPSE_HOME%与此不同，请修改XYZ.link文件里的路径。
   
   
7. 删除插件，先关闭Eclipse；
   　　删除%ECLIPSE_HOME%\links\XYZ.link文件即可
   
   　　删除%ECLIPSE_HOME%\PlugInsNew\XYZ整个目录及文件
   
   
8. 重新启动Eclipse，这样就可以了。如果插件没有生效或者没有删除，请加上-clean进行启动Eclipse，即Eclipse.exe –clean
   
   
9. 插件安装验证及记录详见：Eclipse的workspace下面的.metadata\.log文件，比如：%ECLIPSE_HOME%\workspace\.metadata\.log文件，有问题的话，打开这个文件看看并进行解决。

　确认安装

　　此插件安装方法采用上一节的《Eclipse使用技巧之插件管理》

　　重新启动Eclipse后，在Help è About Eclipse SDK è Plug-in Details你可以看到由“Spring IDE Developer”提供的“Spring IDE”版本为“1.3.2”插件及相关的Graph、UI及UI Search插件，如下图所示：


　
　　相关要求

　　注意：为了让Spring IDE插件能够显示可视化的Bean结构图形及Bean之间的依赖关系，需要Eclipse GEF(Graphical Editing Framework)的支持，自己下载并解压安装，安装技巧同上《Eclipse使用技巧之插件管理》。

　　Spring 1.2系列当前最新的稳定版本为1.2.8，下载时可以选择包含Spring所依赖的一些开源包的文件spring-framework-1.2.8-with-dependencies.zip，如果你已经清楚并有了Spring所依赖的相关开源包，就单独下载spring-framework-1.2.8.zip即可。建议下载前者。

　　解压后目录结构及包的说明如下：



　　dist目录下是Spring的发布包，关于发布包下面会详细进行说明；

　　docs目录下是相关的文档，包括有Spring api的javadoc、reference参考指南、Spring的taglib标签使用文件及Spring MVC的MVC-step-by-step讲解与示例；

　　lib目录下是Spring所依赖的第三方开源包；

　　mock目录下是Spring辅助应用测试的Mock源程序；

　　samples目录下是Spring的示例源程序及简单的webapp示例框架的示例配置，值得好好学习的有jpetstore及petclinic，当然其它的countries、imagedb、tiles-example也可以好好参考一下；

　　src目录下是Spring的源程序；

　　test目录下Spring的单元测试源程序；

　　tiger目录下是Java 1.5 Tiger方面的相关及测试源程序。

　　Spring包结构说明

　　接下来详细说说dist目录下jar包的相关内容

　　spring.jar是包含有完整发布的单个jar包，spring.jar中除了spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。

　　除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。

　　spring-core.jar

　　这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。

　　spring-beans.jar

　　这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring-beans.jar文件就可以了。

　　spring-aop.jar

　　这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。

　　spring-context.jar

　　这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。

　　spring-dao.jar

　　这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。

　　spring-hibernate.jar

　　这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。

　　spring-jdbc.jar

　　这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。

　　spring-orm.jar

　　这个jar文件包含Spring对DAO特性集进行了扩展，使其支持 iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都要依赖spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar包。

　　spring-remoting.jar

　　这个jar文件包含支持EJB、JMS、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方面的类。

　　spring-support.jar

　　这个jar文件包含支持缓存Cache（ehcache）、JCA、JMX、邮件服务（Java Mail、COS Mail）、任务计划Scheduling（Timer、Quartz）方面的类。

　　spring-web.jar

　　这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。

　　spring-webmvc.jar

　　这个jar文件包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、Tiles、Velocity、XSLT相关类。当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。

　　spring-mock.jar

　　这个jar文件包含Spring一整套mock类来辅助应用的测试。Spring测试套件使用了其中大量mock类，这样测试就更加简单。模拟HttpServletRequest和HttpServletResponse类在Web应用单元测试是很方便的。

　　如何选择这些发布包，决定选用哪些发布包其实相当简单。如果你正在构建Web应用并将全程使用Spring，那么最好就使用单个全部的spring.jar文件；如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar与spring-beans.jar即可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的Spring依赖类，然后合并所需的类与包就可以了。Eclispe有个插件叫ClassPath Helper可以帮你找找所依赖的类。

　　Spring包依赖说明

spring-core.jar需commons-collections.jar，spring-core.jar是以下其它各个的基本。
spring-beans.jar需spring-core.jar/cglib-nodep-2.1_3.jar
spring-aop.jar需spring-core.jar/spring-beans.jar/cglib-nodep-2.1_3.jar/aopalliance.jar
spring-context.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/commons-collections.jar/aopalliance.jar
spring-dao.jar需spring-core.jar/spring-beans.jar/spring-aop.jar/spring-context.jar
spring-jdbc.jar需spring-core.jar/spring-beans.jar/spring-dao.jar
spring-web.jar需spring-core.jar/spring-beans.jar/spring-context.jar
spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar
spring-hibernate.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-jdbc.jar/spring-orm.jar/spring-web.jar/spring-webmvc.jar
spring-orm.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-jdbc.jar/spring-web.jar/spring-webmvc.jar
spring-remoting.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-context.jar/spring-web.jar/spring-webmvc.jar
spring-support.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-context.jar/spring-jdbc.jar
spring-mock.jar需spring-core.jar/spring-beans.jar/spring-dao.jar/spring-context.jar/spring-jdbc

public interface     IHelloWorld
{
      String sayHelloWorld();
}

public class HelloWorld1 implements IHelloWorld
{
public HelloWorld1()
{
     super();
}
public String sayHelloWorld()
{
     return "Hello World HelloWorld1";
}
}

public class HelloWorld2 implements IHelloWorld
{
public HelloWorld2()
{
     super();
}
public String sayHelloWorld()
{
     return "Hello World HelloWorld2";
}
}

＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC     "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="beanFactory" class="org.springframework.context.support.ClassPathXmlApplicationContext"＞
＜constructor-arg＞
＜list＞
＜value＞beanRefDataAccess.xml＜/value＞
＜value＞beanRefService.xml＜/value＞
＜value＞beanRefMVC.xml＜/value＞
＜/list＞
＜/constructor-arg＞
＜/bean＞
＜/beans＞

　　＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC     "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="helloWorldDAO1" class="HelloWorld1"/＞
＜bean id="helloWorldDAO2" class="HelloWorld2"/＞
＜/beans＞

　　＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC     "-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="helloWorld1" class="HelloWorld1"/＞
＜bean id="helloWorld2" class="HelloWorld2"/＞
＜bean id="springDemoConstructor" class="SpringDemoConstructor"＞
     ＜constructor-arg＞
      ＜value＞Spring IDE Constructor＜/value＞
     ＜/constructor-arg＞
     ＜property name="helloWorld"＞
      ＜ref bean="helloWorld1"＞＜/ref＞
     ＜/property＞
＜/bean＞
＜bean id="springDemoSetter" class="SpringDemoSetter"＞
     ＜property name="hello" value="Spring IDE Setter"/＞
     ＜property name="helloWorld"＞
      ＜ref bean="helloWorld2"＞＜/ref＞
     ＜/property＞
＜/bean＞
＜/beans＞

　　＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC    
"-//SPRING//DTD BEAN//EN"    
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="helloWorldMVC1" class="HelloWorld1"/＞
＜bean id="helloWorldMVC2" class="HelloWorld2"/＞
＜/beans＞

　　public interface ISpringDemo
{
IHelloWorld getHelloWorld();
String getHello();
}

　　public class SpringDemoConstructor implements ISpringDemo
{
private String hello;
private IHelloWorld helloWorld;
   
public SpringDemoConstructor(String hello)
{
    this.hello = hello;
}
   
public String getHello()
{
    return hello;
}
public IHelloWorld getHelloWorld()
{
    return helloWorld;
}
public void setHelloWorld(IHelloWorld helloWorld)
{
    this.helloWorld = helloWorld;
}
}

　　public class SpringDemoSetter implements ISpringDemo
{
private String hello;
private IHelloWorld helloWorld;
public String getHello()
{
    return hello;
}
public void setHello(String hello)
{
    this.hello = hello;
}
public IHelloWorld getHelloWorld()
{
    return helloWorld;
}
public void setHelloWorld(IHelloWorld helloWorld)
{
    this.helloWorld = helloWorld;
}
}

　　＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC   
"-//SPRING//DTD BEAN//EN"   
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="helloWorld1" class="HelloWorld1"/＞
＜bean id="helloWorld2" class="HelloWorld2"/＞
＜bean id="springDemoConstructor" class="SpringDemoConstructor"＞
    ＜constructor-arg＞
     ＜value＞Spring IDE Constructor＜/value＞
    ＜/constructor-arg＞
    ＜property name="helloWorld"＞
     ＜ref bean="helloWorld1"＞＜/ref＞
    ＜/property＞
＜/bean＞
＜bean id="springDemoSetter" class="SpringDemoSetter"＞
    ＜property name="hello" value="Spring IDE Setter"/＞
    ＜property name="helloWorld"＞
     ＜ref bean="helloWorld2"＞＜/ref＞
    ＜/property＞
＜/bean＞
＜/beans＞

　　＜ref local="helloWorld2"＞＜/ref＞

　　＜ref bean="helloWorld2"＞＜/ref＞

　　public interface ISpringDemo
{
IHelloWorld getHelloWorld();
String getHello();
}

　　public class SpringDemoConstructor implements ISpringDemo
{
private String hello;
private IHelloWorld helloWorld;
   
public SpringDemoConstructor(String hello)
{
    this.hello = hello;
}
   
public String getHello()
{
    return hello;
}
public IHelloWorld getHelloWorld()
{
    return helloWorld;
}
public void setHelloWorld(IHelloWorld helloWorld)
{
    this.helloWorld = helloWorld;
}
}

　　public class SpringDemoSetter implements ISpringDemo
{
private String hello;
private IHelloWorld helloWorld;
public String getHello()
{
    return hello;
}
public void setHello(String hello)
{
    this.hello = hello;
}
public IHelloWorld getHelloWorld()
{
    return helloWorld;
}
public void setHelloWorld(IHelloWorld helloWorld)
{
    this.helloWorld = helloWorld;
}
}

　　＜xml version="1.0" encoding="UTF-8"＞
＜!DOCTYPE beans PUBLIC   
"-//SPRING//DTD BEAN//EN"   
"http://www.springframework.org/dtd/spring-beans.dtd"＞
＜beans＞
＜bean id="helloWorld1" class="HelloWorld1"/＞
＜bean id="helloWorld2" class="HelloWorld2"/＞
＜bean id="springDemoConstructor" class="SpringDemoConstructor"＞
    ＜constructor-arg＞
     ＜value＞Spring IDE Constructor＜/value＞
    ＜/constructor-arg＞
    ＜property name="helloWorld"＞
     ＜ref bean="helloWorld1"＞＜/ref＞
    ＜/property＞
＜/bean＞
＜bean id="springDemoSetter" class="SpringDemoSetter"＞
    ＜property name="hello" value="Spring IDE Setter"/＞
    ＜property name="helloWorld"＞
     ＜ref bean="helloWorld2"＞＜/ref＞
    ＜/property＞
＜/bean＞
＜/beans＞

　　＜ref local="helloWorld2"＞＜/ref＞

　　＜ref bean="helloWorld2"＞＜/ref＞

＜file＞
＜pub＞-//SPRING//DTD    BEAN//EN＜/pub＞
＜abs＞http://www.springframework.org/dtd/spring-beans.dtd＜/abs＞
＜rel＞spring-beans.dtd＜/rel＞
＜/file＞

# Set root logger level to ERROR and its only appender to R.
log4j.rootLogger = INFO,R
# R is set to be a DailyRollingFileAppender.
log4j.appender.R = org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File = Application.log
log4j.appender.R.DatePattern = yyyy-MM-dd'.log'
log4j.appender.R.layout = org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.access.BeanFactoryLocator;
import org.springframework.beans.factory.access.BeanFactoryReference;
import org.springframework.beans.factory.access.SingletonBeanFactoryLocator;
public final class ServiceFactory
{
private static BeanFactoryLocator bfLocator = null;
private static BeanFactoryReference bfReference = null;
private static BeanFactory factory = null;
static
{
    bfLocator = SingletonBeanFactoryLocator.getInstance();
    bfReference = bfLocator.useBeanFactory("beanFactory");
    factory = bfReference.getFactory();
}
   
private ServiceFactory()
{
    super();
}
public static Object getBeanByName(final String beanName)
{
    return factory.getBean(beanName);
}
}

import junit.framework.TestCase;
public class SpringIDETest extends TestCase
{
private IHelloWorld helloWorld = null;
private ISpringDemo springDemo = null;
private final static String hello1 = "Hello World HelloWorld1";
private final static String hello2 = "Hello World HelloWorld2";
private final static String helloset = "Spring IDE Setter";
private final static String hellocon = "Spring IDE Constructor";
public void testSpringBeans()
{
    helloWorld = (IHelloWorld)ServiceFactory.getBeanByName("helloWorld1");
    assertEquals(hello1,helloWorld.sayHelloWorld());
    helloWorld = (IHelloWorld)ServiceFactory.getBeanByName("helloWorld2");
    assertEquals(hello2,helloWorld.sayHelloWorld());
}
public void testIoCConstructor()
{
    //Constructor
    springDemo = (ISpringDemo)ServiceFactory.getBeanByName("springDemoConstructor");
    assertEquals(hellocon,springDemo.getHello());
    assertEquals(hello1,springDemo.getHelloWorld().sayHelloWorld());
}
public void testIoCSetter()
{
    //Setter
    springDemo = (ISpringDemo)ServiceFactory.getBeanByName("springDemoSetter");
    assertEquals(helloset,springDemo.getHello());
    assertEquals(hello2,springDemo.getHelloWorld().sayHelloWorld());
}
}

• org.eclipse.jdt.core - defines the classes that describe the Java model.
• org.eclipse.jdt.core.compiler - defines an API for the compiler infrastructure.
• org.eclipse.jdt.core.dom - supports Abstract Syntax Trees (AST) that can be used for examining the structure of a compilation unit down to the statement level.
• org.eclipse.jdt.core.dom.rewrite - supports rewriting of Abstract Syntax Trees (AST) that can be used for manipulating the structure of a compilation unit down to the statement level.
• org.eclipse.jdt.core.eval - supports the evaluation of code snippets in a scrapbook or inside the debugger.
• org.eclipse.jdt.core.formatter - supports the formatting of compilation units, types, statements, expressions, etc.
• org.eclipse.jdt.core.jdom - supports a Java Document Object Model (DOM) that can be used for walking the structure of a Java compilation unit.
• org.eclipse.jdt.core.search - supports searching the workspace's Java model for Java elements that match a particular description.  
• org.eclipse.jdt.core.util - provides utility classes for manipulating .class files and Java model elements.