NetBeans: The Ultimate Linux IDE

本文只截取最后一部分,想看原文,请点击下面的地址.(偶的翻译能力不够,就看英语原文吧! )

原文:http://netbeans.dzone.com/articles/netbeans-the-ultimate-linux-id

NetBeans vs Eclipse

The current trend is that many are coming out of their own version of Eclipse. The vanilla Eclipse has a lot less to offer. Although there are commercial alternatives, they are too greedy. As I see it, the problem with Eclipse is that it was designed to be a good platform for numerous commercial products. So it lags behind in terms of features. Thus, companies can add more features (I would say basic features) to a commercial version of it and charge money. This is not the case with NetBeans. All the greatest and best features are available to use, right away. There is no need to buy a NetBeans-based commercial IDE to have all the features. If you ask me, Eclipse is a platform, and not an IDE.

NetBeans Face-To-Facts with Eclipse 

In the next article we will do some cool things with NetBeans. NetBeans can be used as an IDE, DB designer, source control tool, unit tester, and many more. And yes, you can write your own plug-ins for it. We will cover one role at a time.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

  NetBeans 现在是越来越强大了! 今天又看到了 Geertjan Wielenga 写的一篇关于如何开始开发SpringRCP
 的文章感觉非常的棒,于是就把它给转载过来了!呵呵! 英文太多了,也就没有翻译了!大家就凑合这看吧,
图文并茂的,我想大家应该不会觉得难了吧!   (不知道这篇文章能否发到论坛里,让大家讨论一下关于在NetBeans下开发SpringRCP ,如果不行就麻烦管理员将这个帖子删除了吧!顺便通知一声,下次就不再发到论坛来了.谢谢!)

PS: 原来SpringRCP的开发这么好玩啊!

插件下载  NetBeans Spring RCP 插件

原文连接:http://java.dzone.com/news/spring-rcp-tutorial?page=0%2C0
作者: Geertjan Wielenga

 Let's familiarize ourselves with the Spring RCP . New life seems to have been blowing into this project: after almost two years of hiatus, the 1.0.0 release came out a few months ago. Let's leave aside the question about its direction and so on and, instead, let's look purely at the technology itself to see exactly what it offers. In that light, I've made available a simple plugin for NetBeans IDE that provides samples and templates to get things started. Below, I walk through a basic scenario using the plugin. However, even those who are not NetBeans users could learn a lot about Spring RCP by reading the steps in this tutorial and the explanations that accompany them.

Table of Contents

• Getting Started
• Creating a View
• Adding Customer Data
• Adding Docking Views
• Enabling Actions
• Adding Context Sensitivity
• Changing the Look & Feel

Getting Started

1. Install the Spring RCP Tooling plugin into NetBeans IDE 6.1.


2. In the New Project wizard (Ctrl-Shift-N), you will find a new project template:

   

3. Complete the wizard and you have a project structure as follows:

   

   A brief overview of the files that you see above:

   File	Explanation
   SimpleApp.java	Provides the application's "main" method and launches the application via the Spring RCP "ApplicationLauncher" class. That class loads the application context XML file and the startup context XML file, where application-level concerns such as the splash screen, initialization sequences, and views are defined.
   SimpleLifecycleAdvisor.java	Provides lifecycle management for the application. This class is registered in the application context XML file. It provides methods such as "onWindowOpened" and "onCommandsCreated", so that you have entry points to customize what happens when the application starts. (For example , you can adjust the application's size in the "onPreWindowOpen" method.)
   richclient-application-context.xml	Provides the application context XML file, which configures the Spring RCP components and services.
   richclient-startup-context.xml	Provides the startup context XML file, which defines the splash screen, but could define anything that you want to have happen specifically at startup.
   images.properties	Provides the image resource. It is registered in the application context XML file.
   splash-screen.jpg	Provides the splash screen image that is used in the startup context XML file.
   commands-context.xml	Provides the application's commands, organized within menu bars and toolbars, and the items within them. This file is declared in the application context XML file.
   messages.properties	Provides the display texts in a centralized location. For example, texts for titles and descriptions are found here.

   
   Note: The template also put most of the Spring RCP JARs on your application's classpath. Look in the Libraries node to see which ones are there. Potentially, more JARs could be included in the plugin as the complexity of the provided tooling increases.

4. Run the application. You should see this:

   

Creating a View

Now we will create a new window in our application.

1. Right-click the project node and choose New | Spring View, as shown here:

   

2. In the New Spring View dialog, type "CustomerView" and set the existing package as your package name:

   

3. Click Finish. You now have a new class that extends the Spring RCP AbstractView class:
   

Open the richclient-application-context.xml file. At the end of the file, notice that your view has been automatically registered for you as follows:

Finally, open ui/messages.properties and notice the new entry for the menu item that will open the view:

  4 . Run the application and go to Window | Show View, from where you can open the new Customer View:

  5.  Let's make our new view open by default whenever the application starts. In other words, our Customer View will be the application's initial view. To do that, open the richclient-application-context.xml file and find the bean that has "lifecycleAdvisor" as its "id" attribute. Add this property to that bean's list of properties:

Notice that the "name" attribute can be completed automatically if you call up code completion (which is Ctrl-Space, by default):

Therefore, the whole bean definition is now as follows:

 6 . Run the application again and notice that the Customer View now appears when the application starts. 

Adding Customer Data

Next, we'll use our new Spring View to display customer data to our users. Nothing in this section is specific to Spring RCP. Nothing more than its seamless integration with standard Swing development is demonstrated below, together with the related benefit of being able to use the associated development tools provided by NetBeans IDE. We'll use one of the databases bundled with the IDE, but we could be using any database at all.

1. Right-click the project node and choose New | JPanel Form. Name the panel "CustomerPanel" and choose "simple" in the package drop-down so that your panel will be created in the same package as where the other classes are found. Click Finish.
2. Open "CustomerView.java". Change the line that instantiates the JPanel so that your new CustomerPanel is created instead:
   public   class  CustomerView  extends  AbstractView {
   
       @Override
        protected  JComponent createControl() {
           JPanel panel  =   new  CustomerPanel();
            return  panel;
       }
   
   }

   Now, whenever you run the application, the CustomerPanel will define the initial view.

3. Open the Services window (Ctrl-5). In the Services window, expand the Databases node, right-click the jdbc:derby node, and choose Connect. The IDE now connects to its bundled Derby database. Expand the jdbc:derby node, expand the Tables node, and notice that there is a table called "CUSTOMER". That's the table we'll show in our application.
4. Open the CustomerPanel in Design mode. Next, drag and drop a table from the Palette onto the CustomerPanel's Design view. Finally, drag and drop the CUSTOMER node onto the table. You should now see this:

   

   Note: Make sure that you click the two arrow buttons on the top right of the screenshot above. Doing that will result in the JTable resizing automatically at runtime, to fit snugly into the size of the JPanel.

5. The related JAR files should automatically be added to your project. If they're not and you see a lot of error messages in the generated code, right-click the Libraries node, choose Add Library, and then add "Beans Binding" and "TopLink Essentials", as well as "derbyclient.jar" from your JDK's db/lib folder.
6. Back in the Projects window, you should see that JPA-related artifacts have been added to your project:

   

7. Run the application and you will see your initial view populated with data from your database:

   

Adding Docking Views

At the moment, we only have one view (i.e., one window). One of the central reasons for desktop developers choosing to use an RCP is the need for a windowing system. As soon as a desktop application starts becoming non-trivial, you need to be able to deal with multiple windows. More than simply showing multiple windows, you also need to provide functionality for maximizing and minimizing them, for opening and closing them, for docking and undocking them. Not much fun to code all of that. Let's see how Spring RCP can help us with this basic requirement.

1. First, we need to add a new view, so that we have two windows. Use the Spring View template, as described earlier in this tutorial, and add a new view with whatever name you like, in the same package as before (or anywhere else). As before, the view is registered for you in the richclient-application-context.xml file, as well as in the messages.properties file.
2. When you run the application, you'll have two menu items under Window | Show View. On selection, the second view replaces the first view, and vice versa. That's not docking, that's replacing. So let's now change that so that both are displayed at the same time, i.e., so that both windows dock within the Spring RCP.
3. Begin by adding this bean to the richclient-application-context.xml file:

  4. Run the application. When you open both views, you should see the following:

 5 . Next, find the beans that declare the two views and change the class that they use in the richclient-application-context.xml to the following:

      org.springframework.richclient.application.docking.vldocking.VLDockingViewDescriptor

So now the bean for the Customer View should be as follows, while the same should be true for the other view you created:

 6 . Let's now look more carefully at how our views are defined. Find the CustomerView bean, place the cursor at the start of the property element's "name" attribute's value, and call up code completion (Ctrl-Space). You should now see the list of possible values displayed:

    Go ahead and take a whole bunch of those names, specifically, the ones shown below, setting them all to "true":

   7. You can do the same for the other view, depending on which of the properties above you would like to make available to that particular window. The names of the above properties are self explanatory, except for "autoHideEnabled", which will add minimize functionality to your view.
  8. Run the application again and notice some small new buttons in the top right of the view:

    If you right-click inside the title bar, you see the same options, this time as menu items together with the keystroke that can    invoke them:

  9. Try out a few of those new features in your application. For example, click the "Detach" button and then you're able to move the whole view out of the application (handy if your user has multiple monitors, for example), as shown below:

1. 

Note: To be able to drag a detached window, your cursor needs to become a hand, which is what happens when you move the mouse over the dotted line at the top of the window's title bar.

10.  Finally, drag the title bar of a view to a position where it could conceivably be dropped and then you will see a shadow where it will appear when you release the view:

  11. Once you have more windows, you can move them around and you can even end up with tabs, if you drag the window to the correct position, as shown below:

1. 

   

   Note: One thing I haven't been able to figure out is how to save window positions at shutdown. In other words, at startup the user would like to have the window positions be restored to where they were when the application last closed. I don't know how this is handled in Spring RCP. I believe it should be done automatically, which doesn't seem to be the case since the application reverts to its default state when I rerun it.

Enabling Actions

Let's now look at the menubar. Several menu items are available by default. Where do they come from? Our simple application contains no Java classes that have anything to do with menu items. So, what's going on here?

Menus and toolbars are all declared in the "command-context.xml" file. That file and its contents, in turn, are declared in the "richclient-application-context.xml" file, which is the application context XML file that is loaded at startup.

1. Open the "richclient-application-context.xml" file and take note of the declaration of the command-context.xml file, as follows:
   

Note: The menubar and the toolbar are also declared above and are then further spelled out in the "command-context.xml" file.

  2.  Notice the third line above and then open that file, i.e., the commands-context.xml file. Let's start by looking at the Help menu:

So, the "Help Contents" item is disabled, while the "About" item is enabled. Why?

 3. Look at the "menuBar" bean in commands-context.xml, where you'll find that one of its members is "helpMenu". Hold down the Ctrl key and move your mouse over the "helpMenu" text and you will see a hyperlink:

Click it and you will jump to the "helpMenu" bean, which is defined as follows:

 4. Now you can see why the "Help Contents" item is disabled, while the "About" item is enabled. In the first case, only a value has been declared, while in the second case there is a reference to a bean, for which a class has been defined that handles the invocation of the menu item. Let's do the same for the "Help Contents" item, starting by creating a new bean for the "Help Contents" item:

Note: We refer above to "help/simple-hs.xml". That's the JavaHelp helpset file that is the entrypoint to our helpset. You could create that by hand, as well as all the files that are needed to set up a JavaHelp helpset. Instead of that, save yourself some time and trouble by going back to the New Project wizard (Ctrl-Shift-N) and in the "Samples" category you will find some Spring Rich Client samples. Complete the wizard for one of them and then copy its "help" package into the "Resource Packages" node of your own application. Hurray you now have the start of your own helpset.

  5. Finally, we need to hook the bean up to our help menu, replacing the value with a reference to the bean, as shown below, in the same way as is done by default for the About item:

 6. Run the application and now the "Help Contents" item is enabled. When you click the item, the JavaHelp from the sample appears.

Adding Context Sensitivity

As your application increases in size, fewer actions remain relevant to all views. Not every menu item should be available to every window, for example. This aspect of large applications is referred to as "context sensitivity" or "selection management". Depending on the current context, certain features should be available while other features are hidden or greyed out or disabled.

So, in this section, we will set things up so that the "New" command is only available if the current view is the Customer view. If the current view is not the Customer view, the "New" menu item and toolbar button (first button in the toolbar in the two following screenshots) will be disabled:

Otherwise, both will be enabled. Below you see the "New" toolbar button enabled because the current view is the Customer view:

To achieve the above result, one simply needs to modify the CustomerView class, as follows:

public   class  CustomerView  extends  AbstractView {

     /**
     * Handler for the "New" action.
      */
     private  ActionCommandExecutor newContactExecutor  =   new  NewExecutor();

    @Override
     protected  JComponent createControl() {
        JPanel panel  =   new  CustomerPanel();
         return  panel;
    }

     /**
     * Register the local command executor to be 
     * associated with named commands. This is called by 
     * Spring RCP prior
     * to making the view visible.
      */
    @Override
     protected   void  registerLocalCommandExecutors(PageComponentContext context) {
        context.register( " newCommand " , newContactExecutor);
    }

     /**
     * Private inner class to create a new customer.
      */
     private   class  NewExecutor  implements  ActionCommandExecutor {
        @Override
         public   void  execute() {
            JOptionPane.showMessageDialog( null ,  " new customer " );
        }
    }
    
}

Notice lines 20-23 in the code above:

Reference is made here to "newCommand". Where's that defined? As always, all commands in Spring RCP are defined in "command-context.xml" file. There, note that the "windowCommandManager" bean declares "newCommand", among other commands, under "sharedCommandIds". In each view, a different target executor could be defined for the same command. In the code above, an "ActionCommandExecutor" is defined in the CustomerView, which produces a JOptionPane with a message as a placeholder for real code. In the OtherView, there could be a different way of handling the "newCommand". In other words, though the "newCommand" is globally visible, it is implemented differently per view.

In addition to commands that are defined in "command-context.xml", there are several that are predefined, which you can simply declare in your code:

As a result, for the view above, the commands declared above will be available and implemented as defined in the second argument to "GlobalCommandIds" (all of which are handled by "newContactExecutor", though that's not very likely in real life). Potentially, you could have all or some of these displayed as toolbar buttons in the toolbar, assuming you declare the related tags in the "command-context.xml" file. They would be enabled if the view in which they're declared is active:

...while being disabled in the context of other views:

Changing the Look & Feel

Since the end result is a standard Swing application, we should be able to change the look and feel. Open the "richclient-application-context.xml" and find the bean that is defined as follows, thanks to the NetBeans project template that created the source structure used in this tutorial:

Let's change the look and feel to Metal:

Now run it again, with this result:

If you remove the bean altogether, you can set the look and feel via the VM option:

-Dswing.defaultlaf=net.sourceforge.napkinlaf.NapkinLookAndFeel

The result, assuming the Napkin look and feel is on your classpath, is then as follows:

Conclusion

There are several other topics that could be discussed in the context of Spring RCP. However, the topics discussed so far should serve as a pretty good basis and give you an understanding of what Spring RCP can do for you and how various pieces fit together. At this point, you certainly should have enough information to build some pretty solid applications on top of Spring RCP.

It is tempting to attempt to compare Spring RCP with similar offerings in the desktop framework domain. It is also tempting to make value judgements. However, that's not the purpose of this article and will be broached at another point in time.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

亲爱的技术支持部门：  
　　自从去年把「男朋友5.0」更新成「老公1.0」之后，我发觉整个计算机的效能下降。特别是在送花与送珠宝的部分，过去在没更新以前一直是用得很顺手 的。还有，就因为装上「老公1.0」，其它许多好用的软件，像是「浓情蜜意9.5」、「眼中只有你6.5」都自动被删除了；相反地，装进了许多莫名其妙的 东西，像是「橄榄球5.0」、「篮球大赛3.0」。现在搞得「枕边细语8.0」已经完全无法使用，「整理家务2.6」甚至每次都让计算机当机。我不想再用 「唠唠叨叨5.3」来修理这个问题，因为根本没有效果。我现在该怎么办呢？  

　　　没指望了敬上

亲爱的没指望了：

　　首先你需要具备一观念，「男朋友5.0」只是一个试用的娱乐软件，而「老公1.0」却是一个实际作业平台。

　　我建议你可以先到计算机档案夹 C:\我以为你一直都很爱我，下载「泪汪汪6.2」，再装上「让他内疚3.0」。试用没问题的话，应该会让「老公1.0」自己启动「珠宝礼物2.0」与「献上鲜花3.5」。

　　不过要记得，千万不要经常使用，不然会触动「老公1.0」的预设装置，全面降级转换到「爱理不理2.5」、「迟滞不归7.0」或是「苦酒满杯6.1」。「苦酒满杯6.1」是个要不得的软件，它每晚会自动播放「鼾声大作.有声档」。

　　还有要记得，不论作什么，就是不能去装「岳母大人1.0」或是其它的「男朋友」软件。一旦装进这些不能兼容的软件，「老公1.0」马上就会报销的，有时连抢救的机会都没有。

　　其实，「老公1.0」是个非常不错的软件，只是它的记忆容量有限，而且学新东西的速度慢了一点。

　　或许你愿意考虑装置一些外围辅助的软件，它们能提升「老公1.0」效能与增加记忆容量，甚至能达到「老公2.0」相仿的功能。我个人觉得「热腾腾晚餐6.0」与「嫚妙睡衣6.9」一定会奏效。

　　祝你成功！

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

亲爱的技术 支持：

我急需您的帮助。我最近将“女朋友7.0”升级到“妻子1.0”，发现这个新程序 意外地启动了孩子生产程序，而且占用了大量的空间 和珍贵的资源。这在产品的使用手册中没有提到。此外“妻子1.0”自动 将自己安装到其他的所有的程序中，它随系统 同时启动，监控整个系统的状态。“男人夜出2.5”和“高尔夫 5.3”无法再运行 ，一旦运行该程序系统即行崩溃。试图运行“周日足球6.3”经常失败，而“周六购物7.1”却代之运行。看来我无法保留“妻子 1.0”，因为它和我喜欢运行的任何程序都不相容。我打算回到“女朋友7.0”，可是这个程序又无法卸载。

请您帮帮我吧！

回信:

亲爱的用户 :

这是个很普通的问题，产生于你对基本原理的不了解。

很多的男人将“女朋友7.0”升级到“妻子1.0”，以为“妻子1.0”是一个“实用与娱乐程序”。然而“妻子1.0”却是个操作系统，是被设计用来运行所有程序的。你不可能清除“妻子1.0”，也不可能回到“女朋友7.0”，因为“妻子1.0”的设计中不具有这个功能 ，无论是卸载、删除或是清除已经安装在系统中的这些程序文件，都是不可能的。

有些人曾试图安装“女朋友8.0”或者“妻子2.0”，结果是产生了更多的问题(参见手册中的赡养费/孩子的养育/律师费用)。我安装过“妻子1.0”，我建议 你保持现在的安装状态，妥善解决 遇到的困难。

当任何错误或问题出现的时候，不论你认为是什么原因引起的，你必须运行“C:＼我道歉”程序，并且避免使用“退出键”。必要时可能需要运行“C：＼我道歉”多次，希望最终能使*作系统恢复到初始状态。

“妻子1.0”虽然是一个需要高保养的程序，但同时对人可能是非常有益的。充分地利用它，需要买些额外的软件 比如“鲜花2.0”和“巧克力5.0”。

不要在任何情况下安装“秘书(短裙版)”，因为“妻子1.0”不支持这种程序，而且系统多数时候肯定会崩溃。

建议使用外挂"情人2.05"版本,可同时运行但不保证稳定性

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

      今天再向大家介绍一款插件 Facelets  , Facelets 也是一个Web 框架.和JSF 有关. 这款插件还提供JBoss Seam 支持.  具体看看Facelets 插件的发展史 .  Facelets提供了NetBeans6.1 FCS 和ML 两个版本的下载!
该项目主页:https://nbfaceletssupport.dev.java.net/

支持 JBossSeam  插件 下载 : http://www.blogjava.net/Files/gml520/org-netbeans-modules-web-nbseamgenintegration.rar

Facelets 特性介绍  :https://nbfaceletssupport.dev.java.net/features.html   (强烈推荐 )
入门教程:  http://wiki.netbeans.org/UsingJSFAndFaceletsInNetbeans (这个是5.5 的教程,但是对于6.x 应该也适用!)

(翻译就免了吧! )

Release Notes

The main goal of this project is to support Facelets in NetBeans IDE.

The 6.1 development snapshot is currently available: 6.1 FCS download here or 6.1 ML download here . This release delivers bundled Facelets 1.1.14 and also provides palettes for facelets files. The majority of the palette was created by Daniel Boekhoff. Thanks to Daniel for the contribution.

This build only works with NetBeans 6.1 because it has an implementation dependency on NetBeans 6.1 FCS/ML. Necessary fixes for the daily builds of NetBeans 6.5 will be provided after the official 6.1 plugin is released. The functionality is still under development and the main goal of this snapshot is to get feedback from real Facelets users. You can read more about the support on the feature page .

下面是Facelets 插件的发展史:

04 June 2008
A lot of requests have been made asking when Facelets support will be available on NetBeans 6.1 and how it will be provided. Yes, there is a plan to officially release the support NBMs through the update center for NetBeans 6.1. We are currently working to resolve several compatibility issues and migrate the internal API usage to NetBeans 6.1. When the plugin is ready for final release, we will announce it and make it available in the Available Plugins list of NetBeans 6.1, but you can currently download the Beta release binary for NetBeans 6.1 FCS here or NetBeans 6.1 ML here .

28 November 2007
Many people have asked me when a version of facelets support will be available for NetBeans 6.0. You can download it here .

No user improvements have been made, but this build works with NetBeans 6.0 and some issues have been fixed. Unfortunately I don't have enough time for deep testing and I also expect some regressions. If you find any problems when evaluating this snapshot, please fill a new issue in the Issue tracker and mark the issue that was found in snapshot06. Thank you for your help.

7 June 2007
Daniel Boekhoff wrote a new tutorial - Running and Facelets Support in Netbeans (with JPA, Glassfish and MySQL 5) . The tutorial is also available on wiki.netbeans.org . Thanks to Daniel for the contribution.

22 May 2007
A new build of the Seam Gen Integration module is now available. This version works with JBoss Seam 1.2.1 GA , which generates a folder structure of the sources that differs slightly from the previous one. This change and some bug fixes are contained in the new build version 0.2. 

随便贴几幅截图,还有好多呢! 具体看看https://nbfaceletssupport.dev.java.net/features.html

Document	Tag Code Completin
Before CC
During CC
After CC

Examples 2: Very similar to the example 1. Only the user doesn't complete a tag, but the value of jsfc attribute of a html tag.

Document	Code Completion of jsfc attribute
Before CC
During CC
After CC

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

这个插件出来已经一段时间了,感觉好像没什么人关注,最近发现还是有人关注这个Web框架的.
今天就发个NetBeans的插件 ,这个插件支持Wicket 1.3.3 . 对于喜欢这个Web 框架的朋友,可以试一试这个插件!
下面是插件的简介(最近比较懒就不翻译了,会用到这个框架的朋友,英语应该不是问题了! ):

What is New in this Version?
 Latest changes: (1) Wicket 1.3.3 is supported, instead of Wicket 1.3.0, (2) a filter is used in web.xml instead of servlet (as requested in the comments in this plugin page), (3) names of generated templates are much simpler, (4) some superfluous options in configuration panel are removed, (5) the HeaderPanel is now always created, (5) no dummy POJO is created, (6) reference to stylesheet in generated BasePage is now done the Wicket way: using org.apache.wicket.markup.html.resources.StyleSheetReference, which means automatic support for localized stylesheets, and (7) there are now three modules instead of two, because the file templates have been split out into a separate module.

Plugin Owner's Notes
This plugin adds Wicket as a framework for a web application project. The zip file contains three plugins; the two framework Wicket provider modules and the Wicket 1.3.3 Library. Create a new web application and choose Wicket in the Frameworks panel:

Then follow the Wicket tutorial for NetBeans IDE:

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

说实在的这个版本的Struts2 plugin for NetBeans 并不怎么样! 功能有限,但是有总比没有的好,至少还可以提高一点生产力!  这个插件带的lib 很少最好还是用自己的lib。

下面是 Struts2 Support Features:

Apache Struts 2 is an elegant, extensible framework for creating enterprise-ready Java web applications. The framework is designed to streamline the full development cycle, from building, to deploying, to maintaining applications over time. You can read more about Struts 2 at http://struts.apache.org/2.x/ .

Installation instructions can be found here .

下载地址 https://nbstruts2support.dev.java.net/servlets/ProjectDocumentList?folderID=9422%26expandFolder=9422%26folderID=8962

Framework Support

***To be added***

Context based Code Completion(基于上下文的代码自动补全)

Code completion assists the programmers/developers to fill in the values for the various attributes. It enlists all possible entries that a attribute/element value can have in a configuration file. By doing so, we improve the ease of use for editing a Struts Configuration file.

Some screen shots of code completion:



Code completion also assists while specifying a fully qualified java name (inclusive of packages)





For an exhaustive list on the code completion scenarios, please visit this link .

Hyperlinking (超连接跳转)

With the help of this plugin, the developer will be able to jump to the point of origin (declaration) of an entity. It would be applicable to all the elements present in the configuration file, right from Interceptors, results,etc. to externally referenced Java files. Some of the hyperlinking scenarios that have been implemented are shown below. 



For an exhaustive list on the hyperlinking scenarios, please visit this link .

Wizards(向导生成)

Wizards assist the programmers by generating a default template for Struts 2 components like Interceptors, Results, Actions and Configuration files. Once, we have a web project with Struts 2 framework, we can add an Interceptor/Action/Result/Configuration file into our project by clicking on 'File -> New File -> Struts 2'. 



The screen shot below shows the scenario of creating a new Interceptor using a wizard:

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

<script type="text/javascript" src="http://www.netbeans.tv/js/swfobject.js"></script>
<script type="text/javascript">
<!--
var so = new SWFObject("http://www.netbeans.tv/images/playerWidget.swf" , "pv", "410", "331", "8", "#666666");
so.addParam("quality", "high");
so.addParam("allowScriptAccess", "sameDomain");
so.addParam("allowFullScreen", "true");
so.addVariable("autoPlay", "false");
so.addVariable("urlFileIdList", "6644");
so.addVariable("show_title", "true");
so.addVariable("PLAY_CALLBACK","emphasize");
so.addVariable("resizeLimitMax","true");
so.addVariable("lang", "en");
so.addVariable("flash_play","true");
so.addVariable("author_name","NetBeans.tv");
so.addVariable("configUrl","http://sun.ora.ma/config.sun.ora.ma.xml");
so.write("videoPlayer");
// -->
</script>
<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,29,0" width="600" height="325"><param name="movie" value="http://www.vimeo.com/moogaloop.swf?clip_id=1195398&server=www.vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1" /><param name="quality" value="high" /><param name="menu" value="false" /><param name="wmode" value="" /><embed src="http://www.vimeo.com/moogaloop.swf?clip_id=1195398&server=www.vimeo.com&show_title=1&show_byline=1&show_portrait=0&color=&fullscreen=1" wmode="" quality="high" menu="false" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" width="600" height="325"></embed></object>

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

国外开发者博客中有一篇有趣的文章，将程序员按水平像软件版本号那样划分为不同的版本。相对于在招聘时分为初级，中级，高级程序员，直接表明需要某种语言N版本的程序员或许更方便直接。根据作者的观点，可将WEB开发者大致分为以下几个版本：

Alpha：阅读过一些专业书籍，大多数能用Dreamweaver或者FrontPage帮朋友制作一些Web页面。但在他们熟练掌握HTML代码以前，你大概不会雇佣他们成为职业的WEB制作人员。

Beta：已经比较擅长整合站点页面了，在HTML技巧方面也有一定造诣，但还是用Tables来制作页面，不了解CSS，在面对动态页面或数据库连接时还是底气不足。

Pre Version 1 (0.1)：比Beta版的开发者水平要高。熟悉HTML，开始了解CSS是如何运作的，懂一点JavaScript，但还是基于业余水准，逐步开始关心动态站点搭建和数据库连接的知识。这个版本的WEB开发人员还远不能成为雇主眼中的香饽饽。

1.0: 能够基本把控整个站点开发，针对每个问题尽可能的找到最直接的解决办法。但对可测性，可扩展性以及在不同(层)框架下如何选择最合适的WEB设计工具尚无概念。这个版本的WEB开发者有良好的技术基础，需要有进一步的帮助和指导。



2.0：懂面向对象的编程语言，理解分层开发的必要性，关注代码分离，对问题寻找更完美的解决方法，偶然也会考虑设计模式的问题，但对此仍然概念不清。属于优秀的初级开发者，能完成较松散的代码开发(相对大型严谨的站点开发而言)，在面对较复杂问题寻找解决办法时需要周边人的帮助。

3.0：开始较为深入的理解面向对象编程和设计模式，了解他们的用途，当看到好的设计模式时能看透其本质，逐步关注分层的架构解决办法和可测试性。理解不同的开发语言并能说出他们的异同(例如各自的优势)。属于优秀的中级别开发者，雇主也确信他们最终能找到问题的解决办法，这个版本的人可以给1.0和2.0的开发者以指导。但他们对架构的理解仍然不够清晰，值得一提的是，只要给予一些指导，他们能很快理解并熟记做出的决定，以及选定方案的优势所在。

4.0：理解模式，重视用户的反馈。着手研究方法论，架构设计和软件开发的最佳入口。头脑中已经形成了超越开发语言，技术架构的整体方案，可根据需求解构程序。能从理论的角度，不同模式如何融合成最佳形态，将多种X-驱动的模式应用到不同的方案中。是精通多语言的高手，理解不同系统和方法论的细微差别，属于高级程序员。这个级别的人能够轻易的辅导2.0和3.0的程序员，将他们推向更高的级别。

5.0：从系统的角度考虑问题。对各种系统结构有深入研究，能对整个代码架构中的问题进行改进。在团队粘合性以及代码安全性方面有杰出贡献。对1.0到4.0版本的开发人员出现的问题能及时察觉，让整个团队保持积极性且保持兴奋的状态创建软件解决办法。举例来说，他们总是对新的技术和信息保持饥渴状态，试图用最简便的方案解决开发任务。在整个IT团队中获得信任，属于高级程序员和架构师。

那么，您属于哪个版本的程序员呢？

查看本文国际来源：开发者版本：你属于哪个版本的程序员？

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

这张照片里有几个是中国人! 佩服他们!而且还有个女的!

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

Netbeans 6.5 M1 已经发布,最新版本的NetBeans 增强了许多功能,同时也引入了许多值得期待的新特性.
其中我比较喜欢的是DataBase 的改进,Eclipse 项目导入变得比以前更方便了,可以正确的区分Web项目
和普通项目,还有Spring   Hibernate 增强. GUI 中新增了JDK1.6 u10 中的look&feel 只要你用的是 JDK1.6 u10
就可以使用这个外观预览.数据绑定功能也改进了!   全新的多线程Debug  功能支持!
 JavaScript  也加入的Debug功能,还加入了好几个Javascript 库,像JQuery ,Yahoo ui dojo 等等!
还新增了一个 "驼峰拼写" 代码补全功能. 很有意思.
JavaEE 的lib path 也变成了可变的了.此外还增加了快速搜索功能. 更方便搜索!   还有好多个特性呢!

还有PHP Groovy Ruby 等都有增强!
具体看下面的介绍! 英文太多了就不翻译了 大家自己看吧!

UNC paths on Windows

Now the NetBeans IDE supports UNC paths like ""computerName"sharedFolder" . It is possible to install the IDE to UNC like folder and also it is possible to create projects and other resources on UNC paths.

File Associations options panel and Open As... action

A new panel in options dialog which allows to say to NetBeans that files with certain extension should be treated as files with a certain MIME type (see #133773 ). You can add a new extension to the list of modify existing one. If you want to restore default setting for selected extension, you just click the Default button.

In connection with the above change there was also added a new Open As... action. It is enabled only for files which are not recognized by the IDE. User can choose one from supplied MIME types and from now on all files with this extension are treated as of choosen MIME type.

Running some IDE distributions on JRE

Certain IDE distributions (e.g. PHP IDE) don't require Java JDK to run on, JRE is enough.

Plugin Manager now checks OpenIDE-Module-Package-Dependencies of all modules which user selects to be installed. If the user's IDE is running on JRE and the unsatified package dependency might indicate that JDK is required, user is warned about it and the plugin installation is not allowed.

QuickSearch

Quickly search for action or type is now easy. Use Ctrl-I.

• wiki: http://wiki.netbeans.org/QuickSearch
• UI spec:http://ui.netbeans.org/docs/ui/quicksearch/index.html

Variable based paths in J2SE/J2EE projects

Since NetBeans 6.1 it is possible to control whether JAR/Folder added to project classpath is referenced via absolute or relative path. Now it is also possible to define a global IDE named variable pointing to a folder and use this variable as a base for referring to JARs/Folders.

This feature further simplifies project sharing between users. In scenario where a project depends on JARs for which:

• it is not desirable to store them in VCS; and which
• can be placed in different locations for different users

a named IDE variable can be used.

The variables are managed via Tools -> Variable menu item:

In above screenshot single variable is defined with these details:

When variable based JAR/Folder is added to project classpath you can see its path starting with variable name (and tooltip showing absolute path):

Variable based JAR/Fodler is added to classpath via standard means of "Add Jar/Folder" button in classpath customizer (or "Add JAR/Folder" action on project's Libraries node in project's view). Custom file chooser is shown with one new option "Use Variable Path":

Just browse for your JAR/Folder and if selected file is under a variable the option gets enabled. Alternatively press "..." button and setup a new variable.

If a user opens project with a variable based path and the variable is not defined in user's IDE then standard broken reference warning is shown to advice user to define variable:

Eclipse project import and synchronization

The Eclipse project import feature facilitates mixed IDE development teams. It allows you to select Eclipse projects from an Eclipse workspace and generate NetBeans projects for them. The generated NetBeans project keeps a link to the original Eclipse project and will update itself after any relevant change: for example, changing the classpath of the Eclipse project. The update is done automatically when the NetBeans project is opened, or can be explicitly requested via a context menu item "Synch with Eclipse" on the project.

This is early preview of the Eclipse import feature which will be fully implemented in Milestone 2. (It supersedes the limited Eclipse import feature available in former NetBeans releases on the update center.) We would appreciate feedback and real-life Eclipse projects for testing; best is to use Issuezilla. (component ide , subcomponent eclipse project import )

Enhanced Java Web Start support

Support for creating applets that can be deployed via Java Web Start was added to NetBeans IDE. Note: the functionality is available in JDK 1.6.0 update 10.

Each application or applet deployed via Java Web Start can specify external resources (usually other JNLP file in internet). Dialog is opened by clicking on 'External Resources' button.

Each applet can have number of properties defined in JNLP file, those properties can be defined in dialog that is opened by clicking 'Applet Parameters'. Also you can set applet dimensions in the dialog.

Platform

Sliding windows support original window sizes

Slided-in windows can keep their preferred size instead of being stretched to the whole height/width of the IDE window.

(see #135318 ).

Possibility to configure some Window System properties for applications based on Platform

Some window system features can be turned off by branding of core.windows module.

TreeTableView replacement introduced

OutlineView is a new replacement for buggy TreeTableView. It supports drag and drop, in-place editing of tree cells, enhanced sorting etc. The data model is fully compatible with TreeTableView.

(see #33281 ).

Opening Options dialog with preselected subcategories

API in options.api module has been changed to allow open Options dialog with preselected subcategory (see #109538 ). In your code you can call OptionsDisplayer.getDefault().open("CategoryID/SubcategoryID"); where CategoryID and SubcategoryID are registration names from layer. For selection a panel under Miscellaneous category use OptionsDisplayer.getDefault().open(OptionsDisplayer.ADVANCED+"/SubcategoryID"); .

Support allowing a user to drop a text into the palette

It is possible to drag and drop any text to the Palette window to create a new code snippet. It works for HTML editor palette only at the moment, more document types will follow soon.

PHP

Features first introduced in Early Access for PHP

The NetBeans IDE Early Access for PHP was released in April at the same time as NetBeans 6.1. Milestone 1 of NetBeans 6.5 now contains all features introduced in this release .

Next, in NB 6.5 M1, PHP features are a part of the "all-in-one" distribution of NetBeans, so they can be used together with all the other NetBeans features. Of course, there is still the slim PHP edition of NetBeans, targeted for PHP development specifically.

See below for more features added in NetBeans 6.5 Milestone 1, that were not present in Early Access. Also, to keep up with the new features added to NetBeans PHP support, make sure to check and bookmark the NetBeans PHP Team Blog .

Database-related code snippets

Generate code to connect to a MySQL database and to display the data in a database table. These snippets are available under the Generate Code action [Alt+Insert], just like in the Java editor.

Find Usages

Available also for PHP development. Right click the item and select "Find Usages" or hit Alt-F7.

Multiple project configurations

• running, debugging either as script or as web page in browser
• index file, arguments ...

Ajax

JavaScript Debugger

• Supported browsers
  • Firefox 2.0.0.X
  • Requires Firebug 1.1beta. An automatic installation is attempted when not found.
• Add & delete breakpoints in JavaScript code
  • Html Files
  • JavaScript Files
  • URL source resulting from server side technologies such as JSP
• Manage debugger session
• View & navigate source artifacts
  • Html Files
  • JavaScript files
  • URL source resulting from server side technologies such as JSP
• View window/frame structure
• View & navigate JavaScript Callstack
• View local variables
• Set & delete watches
• View (static) browser DOM in the IDE
• J2EE & Ruby Project integration
  • Debug Client Session: Run the project and launch a JavaScript debugging session in NetBeans, attached to the Firefox 2.0.0.X browser where the client-side application is running
  • Source Mapping: Correlate a client-side application (browser DOM) identified by a URI with the corresponding source file in the J2EE project (limited mapping in M1) Mapping for:
    • Html files
    • JavaScript files

User Guide

JavaScript Library Manager

• Utilizes NetBeans Library Manager to manage JavaScript libraries
• Wizard to add JS libraries to Java EE, Ruby, or PHP projects (Tools->Add JavaScript Libraries)

Bundled JavaScript Libraries

• Yahoo UI
• WoodStock
• jQuery
• dojo
• scriptaculous
• prototype

Java

Javadoc Analyzer

This plugin provides ability to check and fix Javadoc comments in your source code. Just select project/package/files and invoke "Source | Analyze Javadoc". Auto comment functionality is back.

Call Hierarchy

Show all callers/callees in the search scope of the selected member.

Formatting Settings per Project

You can specify formatting settings individually for each project

CamelCase code completion

Code completion improved. Just write first letters of each word in method to get smart code completion. For instance "iL" stands for invokeLater.

Improved Encapsulate Fields Refactoring

Encapsulate Fields Refactoring Improved. New options available.

Option to remove whitespace at end of line

Top voted enhancement finally implemented

Groovy

Editor

• placeholder

Java SE Project Integration

Database

Improved New Connection dialog

Now the dialog for creating a new database connection does not expect you to know the details of the JDBC URL to open a connection. If you want to modify the URL, however, you can do so, just click on the "Show JDBC URL" checkbox. Changes to the URL are reflected in the fields and vice versa.

SQL history dialog

SQL that has been executed is saved to a file in the userdir and available for viewing in a dialog and also SQL can be selected and reinserted in an existing SQL file.

Server Support

GlassFish V3 integration module.

Is now part of the Web & Java EE and Ruby bundles. No need to get the modules from the update center.

Web frameworks (Spring, Hibernate, JSF, JSF CRUD Generator, JPA)

Spring

• Improved Java class FQN completion

Code completion is now faster than the earlier version. For efficiency, Java class FQN completion is now a two step process. Most of the times, a user will need only classes defined locally in the project (source classpath). Hence the first CTRL+SPACE will list only the items in the source classpath, as shown below:

If the user wishes to add an item not in the source classpath, he can press CTRL+SPACE again. Also, if the typed prefix does not match any local item, the completion will automatically switch to show all items instead of just local items.

• Go to Spring Bean dialog

A Go to Spring Bean dialog is similar to the Go to Type dialog and will allow the user to quickly navigate to a given Spring Bean definition by it's name. The user selects the main menu item Navigate | Go to Spring Bean... or the keyboard short cut Alt + Shift + B to invoke the Go to Spring Bean dialog.