Planet NetBeans

Adam Bien: You Don't Need To Think About Transactions If:

2008-06-29T09:04:23+00:00

Your application has no persistence and do not interact with transactional resources like messaging, legacy interfaces etc.
The application is used only by one user in sequential way in a single thread.
It only reads the data and no one writes or if it only writes the data, and no one reads :-).
The access to persistent storage, backend resources is performed in one (business) method.
You don't need the "Unit Of Work" abstraction. So it is no problem if the application dies between method invocations and the data is partly processed.
It's ok, if other applications, users etc. see the unfinished (uncommitted) activities in their applications.

You know such an application? :-). I hear from time time statements like: "This is just a report - so I don't need transactions - I'm only reading the data". In this particular case you would access the database without a defined transaction and especially isolation - so you will basically see a snapshot of the database (especially uncommitted changes).

Even if you totally ignore the transactions - you will still get the "Green Bar" in most cases. This is probably the reason, why transactions are often in fact ignored ...until the production :-).

cld: Swing Bits : How-to Bind JTable to MySQL Table (no coding), New TreeTable, Matisse, JSlider, JTabs+Components

2008-06-29T08:10:00+00:00

There are bunch of Swing bits that are worth looking at. The first is how-to bind a JTable to a MySQL Table without coding. Second, there is a new TreeTable. Third, learning Matisse. Fourth - JSlider tips. Fifth, putting a component on a tab. more..

Adam Bien: A Beautiful Java Book - Something For Your Lunch Break

2008-06-28T10:53:01+00:00

I missed somehow this book. It is my first IT-book (almost) without technical content. Instead of learning new stuff, I just enjoyed it and remembered the old JDK 1.0 days. It is a "special edition" book for the Ten Year Celebration Of Java: Hello World(s)!: From Code to Culture, a Ten Year Celebration of Java Technology. It comes with lot of pictures and arts - but almost no text. So it is perfect for a lunch break - you can fully read it :-).

NetBeans Community Docs Blog: Wanna play? Play with XML Layer!

2008-06-28T06:47:42+00:00

Hi,

Time to notify you about the latest contributions! Yes, its been a month, where contributions came out-of-the-blue...Seriously, its been a tough time, getting contributions, convincing bloggers, and much more!

However, we still manage to get 14 docs for this month. Still 2 days to go, some more docs coming up! Majority of them being, tips and Tricks. Also, we got a series of docs, based on "optional configuration file" used in NetBeans Module Development- XML Layer! One of them getting reposted from NetBeans Zone! There were numerous tutorials, tips and Tricks, How To's summing up into Eight docs in totality.

If you are interested, then come, join us and contribute! Its really easy, if you learn a trick, while working with NetBeans on any kind of project OR you have some tips to remember...Hey, maybe you want to write a tutorial to help community achieve something in few steps!

What are you waiting for? Just drop a mail to me, about your idea- nvarun AT NetBeans DOT org We would be glad to have your idea turn into a neat documentation for community :-)

Bistro!: Offre combinée MySQL + GlassFish

2008-06-27T20:07:21+00:00

A l'heure ou d'autres augmentent leur prix indexé sur le nombre de coeurs de vos processeurs, Sun vous propose une offre illimitée (plus de problème de nombre de serveurs, de CPU, d'applications). Annonce de presse ici.

Pour une entreprise de moins de 1 000 employés, il en coûtera $65 000/an pour un usage illimité. Pour un support 24/7, $80 000/an.

Si vous n'avez jamais entendu parlé de GlassFish, en 10 minutes de vidéo vous saurez presque tout. Pour MySQL je n'imagine même pas que ce soit le cas!

Geertjan's Blog: User FAQ Search Inside NetBeans IDE

2008-06-27T17:27:18+00:00

Over on NetBeans Zone today, I speculated about one interesting scenario that is possible in relation to the new Quick Search feature—plugging the NetBeans User FAQs into the Quick Search. Well, I figured out how to do it and this would be the result:

So, the user would be curious about CVS in NetBeans IDE. The user would then type "CVS" and get (1) all the related FAQs, as well as (2) the action for opening the CVS window. Many similar results could be imagined, combining actions (and types) in the IDE with FAQs which, when clicked, would open in the browser.

The parsing code is very slightly different, i.e., just the code in bold below is different to that found on NetBeans Zone:

Document doc = tidy.parseDOM(url.openStream(), null); //Get all "a" elements: NodeList list = doc.getElementsByTagName("a"); //Get the number of elements: int length = list.getLength(); //Loop through all the "a" elements: for (int i = 0; i length; i++) { String href = null; if (null != list.item(i).getAttributes().getNamedItem("href")) { //Get the "href" attribute from the current "a" element: href =
    list.item(i).getAttributes().getNamedItem("href").getNodeValue(); } //Get the the node value, i.e., <a href="foo">value</a>: if (null != list.item(i).getChildNodes().item(0)) { String title = list.item(i).getChildNodes().item(0).getNodeValue(); //If the node value matches the requested text: if (title.toLowerCase().indexOf(request.getText().toLowerCase()) != -1) { //Add the runnable and the title to the response //and return if nothing is added: if
    (!response.addResult(new OpenFoundArticle(href), title)) { return; } } } }

Now imagine if we plugged the NetBeans Developer FAQ into the Quick Search feature too. You'd be able to get a lot of information from searches that combined both these FAQs. Then add tutorials, community docs, and NetBeans Zone. For very little work the user would end up with an incredibly powerful search mechanism across all our documentation... and all of it right inside the IDE, with the Quick Search constantly only a Ctrl-I click away.

NetBeans Support Weblog: Silicon Valley Ruby Conference

2008-06-27T17:11:39+00:00

The Third Annual Silicon Valley Ruby Conference: Using Ruby and Rails for Innovation and Creativity

Friday April 18 8:30AM - 5:45PM and Saturday April 19 10:00AM - 6:00PM

Registration Link: http://www.sdforum.org/Ruby

Program Overview:

This two-day conference is a significant Web 2.0 Conference in the Ruby community and within the software development arena. This annual event brings Ruby and Rails developers, interactive engineers, software developers, startups, IT managers, and technical executives together in San Jose. In the past three years, Ruby has become one of the most talked-about programming languages, and Ruby on Rails has become the framework of choice for many new web applications.

Among the topics of the two day conference are How To:

Harness the potential and power of Ruby, including best practices
Optimize the performance of Ruby and related open source technologies
Learn and use the newest features in Ruby 1.9 and Rails 2.0 releases
Build affordable high performance and scalable solutions using Ruby
Learn from experts who build successful Ruby in both the startup and enterprise spaces
Explore the latest Ruby on Rails development in social networking platform
Learn from Ruby Early Adopters and understand what’s happening with Ruby in the enterprise.

Confirmed Speakers Include:

Tim Bray-Sun-“The Rubies in Context”

Blaine Cook- Twitter

Joel Dudley, Stanford

Ryan Garver-*ELC- “Ruby features for Open Social Networking”

Jason Hoffman-Joyent

Anant Jhingran- IBM

Jon Lam- Microsoft--The Borg discovers Ruby and Open Source"

Alex Le, Friends for Sale

James Lindenbaum, Heroku

Parker Thompson, Pivotal Labs - DRYing Up Application Development: Components That Don't Suck

Adam Wiggins, Heroku

Event Logistics

Location: The Tech Museum, 201 South Market St. San Jose, Ca 95113
*Price:* $219 SDForum Members, $269 Non-members, $50 Platinum Pass

Registration Link: http://www.sdforum.org/Ruby

cld: Developer Platform : OpenSolaris (video)

2008-06-27T16:59:00+00:00

This is an interesting presentation by Sun technologist Roman Shaposhnik which has lots of good points and counter-points on developer operating system environments. More....

NetBeans Support Weblog: Binding JTable with MySQL table

2008-06-27T16:55:08+00:00

I got this inquiry recently. I decided to try it myself. Here, I am showing through screen shots how to bind database table to a JTable. I am using MySQL as that is what was requested. I wanted to highlight how easy it is to use NetBeans to do this task. NetBeans takes care of all the persistence part for you. In fact, I did not have to write any code at all for this.

Here are the steps:

Create a Java Application Project. From main menu File -> New Projects. Choose Java category, and Java Application.

Now delete the Main.java file under Source Packages. This file was automatically created by the wizard for you. Add a new JFrame Form . Right Click Project node -> New -> JFrame Form.

Drag and Drop JTable from the palette on to the designer, as shown below.

Now Drag and drop the database Table on to the JTable in the designer. To do this, go to the Services tab , and expand the Databases -> Your MySQL database node -> Table, and select the table you want to bind to the JTable. Drag and drop it on to the JTable on the designer.

Make sure the MySQL driver jar file is under the libraries node of the project. Build and Run the project. when running the project it will ask you to select the main class. This is because we deleted the main class earlier, and we now need to provide the main class to begin execution. Select the default as shown below.

Here's the screen shot on running the application.

That's all there is to it. Not a line of code was written. If you browse in the projects window, you'll see the IDE automatically created the Person.java class and persistence.xml files.

NetBeans Support Weblog: Directories in Sun Studio 12

2008-06-27T16:53:53+00:00

The following are the three (major) directories used by Sun Studio 12 (also referred to as ide in this article).

Installation Directory. The directory where ide is installed and run from.
User Directory. The directory where user settings are stored. (Default: ${HOME}/.sunstudio/sunstudio.conf)
Projects directory. The directory where a project is stored. Each project has its own project directory.

Recommendations:

Keep the directories separate. For instance, it is possible to create the projects in user directory but not advisable. Keeping the directories separate allows you to get rid of any one of them without loosing other data. For instance, if for some reason, the ide install directory gets corrupted, then the ide can be reinstalled but the existing user settings and projects can be reused with the new install. Similarly if the userdir gets corrupted, then the ide can be run with a fresh userdir without the need to reinstall the ide and existing projects can be opened in the ide.
Organize your projects under one master directory. Though the ide itself does not enforce this (and correctly so), you may want to create a top-level folder for all of your projects and arrange your projects within this folder. This may be especially useful when the projects have to be maintained in a source control system.

Keep the sources separate from the project directory, by changing the source folders property in the project properties dialog. This way the project can always be deleted and recreated.

If you reinstall the ide and run into issues while running it, the most probable reason is that the older user directory has some conflicting settings; try running the ide with a different userdir, as specified in the section below.

User Directory

How to find the current user directory? Run the ide and open the about box (Help | About) and switch to 'Details' tab. You will notice an entry for userdir.
If you are unable to run the ide even: Check the [ideinstalldir]/SUNWspro/prod/etc/sunstudio.conf file.
Sometimes the user directory may get corrupted resulting in strange behaviour (like settings not getting saved etc). In such cases, you can delete the user directory. The ide will recreate the directory upon next startup. The downside is all the user settings/options will be lost. All the module updates will also be lost, since updates via update center are usually put in the userdir.

The above information refers to Studio's install and user directories. Studio 12 bundles NetBeans 5.5.1 whose install directory is <studio_install_dir>/netbeans-5.5.1 and whose user directory is specified in <studio_install_dir>/netbeans-5.5.1/etc/netbeans.conf (by default ${HOME}/.netbeans/5.5.1).

It is possible to run the bundled NetBeans 5.5.1 by itself but is not recommended. One should always run Studio 12 which will run the bundled NetBeans. Since Studio and its bundled NetBeans use different directories for saving and restoting settings, running the bundled NetBeans separately will surely lead to conflicts. As a case in point, if bundled NetBeans is run and its AutoUpdate is invoked, then modules will be dowloaded from update center and installed at NB-userdir. But Studio 12 does not use this user directory; So next time Studio 12 is run, it will not see the updates.

If there is a need to have both Studio 12 and NetBeans 5.5.1 on the same machine, then one should have a separate standalone installation of NetBeans 5.5.1.

Note: Ths article is based on a similar article written for standalone NetBeans.

NetBeans Support Weblog: Java Web Start for Java Applications

2008-06-27T16:51:49+00:00

In NetBeans 6.1, the Run panel of project properties dialog for a standard Java application project has a checkbox titled 'Run with Java Web Start'. If this box is checked, then the ide generates all the necessary artificats (jnlp file) with appropriate entries. The ide also supports testing the configuration by running the app using java web start when the app is run from within the ide (by selecting Run command from the project's context menu). But the ide does not support deploying the app to a web or app server; in fact the ide does not generate war files even. The deployment should be done manually.

Notes:

The ide does support generating a war file for NetBeans Rich-Client applications (i.e applications based on NetBeans platform), via the project's 'Build JNLP application' context menu item.
In 5.0, the javawebstart module was developed as a proof-of-concept (experimental mode) and made available on the Development Update Center for 5.0 for cutting edge users. This initial version did support deployment of standard java apps as documented in its tutorial. When the module was integrated into NetBeans itself, the module was re-speced and redesigned; at that point the war-file-generation feature was dropped. Starting with NetBeans 5.5, which had the first integrated support for web start, the feature is not available in NetBeans.
Consider adding your comments and/or votes to issue 137924
The online help for NetBeans 6.1 does clearly say that:
Enable Web Start. If selected, the IDE creates the necessary artifacts to make the application deployable with Java Web Start when you build the application...
All of these properties are used in the creation of the JNLP file, which is file used to launch the application...
But the document doesn't state that deployment should be done manually. This issue is tracked in issue 136069

The following are the manual steps needed to deploy a standard java project application:

Enable Java Web Start support in the project properties dialog's run panel.

If 'codebase' in the above panel is set to 'Local Execution' : Build the application. The ide generates the required files in the project's 'dist' directory. Copy the entire contents of the dist folder to the appropriate directory in the webserver. For instance, if the context of the app should be '/myjnlpapp' , then do a 'cp -r dist/* <server-docs-root>/webapps/myjnlpapp'.
If 'codebase' in the above panel is set to 'User Defined' : Specify the required context (example: 'http://myjnlpapp'). Build the application. The ide generates the required files in the project's 'dist' directory. Copy the entire contents of the dist folder to the appropriate directory in the webserver. For instance, if the context of the app should be '/myjnlpapp' , then do a 'cp -r dist/* <server-docs-root>/webapps/myjnlpapp'. (Or generate the war file manually).
If 'codebase' in the above panel is set to 'Web Application Deployment' : The ide automatically sets the codebase as "$$codebase'. Build the project. Follow the steps documented the tutorial at http://java.sun.com/j2se/1.5.0/docs/guide/javaws/developersguide/downloadservletguide.html

Lukas Hasik's Weblog: [Jazoon] Why I missed it

2008-06-27T08:26:57+00:00

The Jazoon conference ends today. I regret that I couldn't be there. They accepted my proposal for lab session by I had to cancel it. I was really looking forward to give the talk again at Jazoon. And I wanted to see how they improved the conference from last year when it appeared for first time. I was looking forward to meet Carol Hamer who agreed to be proctor in the lab (I stole some code from her book "Creating Mobile Games: Using Java ME Platform to Put the Fun into Your Mobile Device and Cell Phone" for the lab Actually, she approved me the usage of the code then it means I didn't steal it, right?)

But I cannot attend. No money, no fun. It seems that the Jazoon conference occupies really bad date. It is end of fiscal year. Vacations and summer are starting. And the next year it will be even worse when the Javaone conference will move to June.

cld: NetBeans IDE 6.1/MySQL Tutorials : Connecting & Creating a Simple Web App

2008-06-27T07:22:00+00:00

Check out two new NetBeans IDE 6.1 MySQL tutorials that show you how to connect to MySQL via NetBeans and how to use NetBeans within a simple web app. More....

Adam Bien: Is EJB 3 The Solution For The "Multicore Crysis"? (@Stateless and @Stateful)

2008-06-27T06:45:31+00:00

During yesterday's excellent talk of Heinz Kabutz at Jazoon, it turned out, that even the += operator isn't atomic and can cause problems in parallel, multicore, multiprocessor platforms. It doesn't have to be super-parallel - just current commodity hardware can already cause the problems - and you have to synchronized your code (without synchronized :-)).

Nevertheless, because EJB (1.0, 1.1, 2.0, 2.1, 3.0 and probably 3.1) are always executed in a dedicated thread - they appear as single threaded for the developer. For every thread (=user request, transaction) a new EJB instance is created (or reused from pool) - there is actually no shared state, except you access singletons, files etc. - which is not allowed. Actually the spec even prohibits the usage of the synchronization primitives and threading functionality inside EJBs.

Furthermore the programming model is rather procedural (or if you will "service oriented") - so in the @Stateless Session Beans the methods process some input data and give it back to the caller. Even the @Stateful Session Beans do not brake the rule - the container still prohibits concurrent access to the @Stateful instance. Because a @Stateful Session Bean can be only executed in a single thread - you do not have (you shouldn't!) care about the threading either.

The best of all: if you acess the JPA-persistence - the container synchronizes the data for you. Every transaction receives a copy of the JPA-entity (it is often implemented in this way), so nothing bad can happen even in this case.

I'm not sure whether there are actually some corner cases - where EJB programming model breaks in multicore environment (except you are violating the spec). Every EJB-instance can be only executed in a single thread. And every thread is (hopefully) executed in a single core. So if you keep the transactions short, and do not "hack" the EJBs accessing static variables or singletons - you are on the bright side :-).

Janice Campbell's Weblog: NetBeans L10n Community Tshirts

2008-06-26T22:33:34+00:00

They have finally arrived! These were designed by the NetBeans global TranslatedFiles (Localization) Community, which encompasses developers, fans, and students from Africa, Asia, Latin America and Europe! If you are a member of the community, you know how to contact me.

APIDesign - Blogs: Dependencies Are Important Type of API

2008-06-26T20:10:41+00:00

In my yesterday's post I promised to write a note once a week. However, things in real life are never like envisioned in planning phase. Today I stopped in my work and faced a little bit of confusions about wikipedia::NetBeans module dependencies. Some guys wanted the NetBeans Platform to start to depend on wikipedia::batik. Indeed this is not really desirable. If we want the NetBeans Platform to be easily embeddable in other applications, it is not wise to grow our external dependencies over reasonable limit.

As a result I've started the APITypes page and added a section about dependencies there.

--JaroslavTulach 11:56, 16 June 2008 (UTC)

Octavian Tanase's Weblog: Build NetBeans on OpenSolaris

2008-06-26T18:17:52+00:00

OpenSolaris is on path to become a compelling development environment. Once in a while I use my local installation that runs on my MacBook (under Virtual Box) to experiment with different tasks. Yesterday I tried to build NetBeans on OpenSolaris. With that in mind I knew I'll need the JDK (for the compiler), ant to build the sources, mercurial to pull the sources from the NetBeans open source repositories, etc.

In a terminal I became root and started looking for packages (e.g. pkg install mercurial - but this won't work). I found out that at this point the naming is not yet consistent. You can look for software like netbeans or openoffice by name, however for something like mercurial and ant, one has to use SUNWmercurial and SUNWant respectively.

Pulling from the NetBeans repository is simple:

hg clone http://hg.netbeans.org/main

The next step calls for going into the <nbsourcedir>/main/nbbuild/ directory and looking for build targets using ant -projecthelp. "All" seemed an intuitive so I tried it. The bad part is that NetBeans requires ant version 1.7.0 and the version I installed earlier was 1.6.5 . At this point I gave up and I'll ping the NetBeans community for help.

APIDesign - Blogs: Request/Response Pattern Revisited

2008-06-26T16:21:06+00:00

TheAPIBook explains how Request/Response pattern can help to solve the need for growing parameters. However, this is not all the pattern can help with as I have found recently in a discussion with David Šimonek.

David was just designing new Quick Search API for NetBeans which was a natural candidate for using the Request/Response pattern. However he needed more. He needed support for incremental computation, as some of the providers may compute too long. He needed a way to process some of the results as soon as possible, as he wanted to show user first five lines of results as quickly as possible. And also he needed a way to support interruption of already computing tasks, because, as soon as user selects a result of search, it is useless to continue computing additional ones. To our surprise we found the Request/Response naturally suited for these tasks as well.

This also shows the difference between TheAPIBook and this website. The book is printed once, sentenced to contain forever what it contained on the day of publication. But our knowledge is evolving, growing. It is perfect to have a place where we can capture and improve what we know about the Request/Response pattern...

--JaroslavTulach 21:02, 25 June 2008 (UTC)

APIDesign - Blogs: Book is never Written by a Single Person

2008-06-26T16:21:06+00:00

The Practical API Design book has been send for print over the last weekend. I take it as a good opportunity to say thanks to all the people who helped me write it. The first set of ThanksEveryone notes is now available and covers those who "manually" contributed. I still need to thank to all those support "units" around me - something left for next blog entry...

--JaroslavTulach 12:01, 23 June 2008 (UTC)

APIDesign - Blogs: Entering the Blogosphere

2008-06-26T16:21:06+00:00

The publication date for my book is getting closer and closer and to my surprise I am beggining to find out that the work is not over! Quite the opposite is true. I need to do more things now, then I had to during the last month.

Just instead of proof reading the latest versions of book's chapters sent to me by my publisher, I need to create some reasonable online appearance. I've decided to publish the Sources for all the example, polish them to a reasonable state, create a wiki site to allow cooperation between people all around the world interested in API Design and also start a blog.

I am new to the blogosphere and I only envision the rules of proper blog publishing. I doubt I'll be able to publish as often as GeertjanWielenga, one of my beloved editors, however I'll do my best to add at least one note per week. From my current viewpoint a week looks like a reasonable compromise between the needed time to find at least one interesting event in the API design world and between finding enough time to write that note.

Enough for now, I need to finish the blogging infrastructure. And, unless you have done so by now, do not forget to preorder the API book...

--JaroslavTulach 09:33, 15 June 2008 (UTC)

Bistro!: Brussels tomorrow (Friday 27th)

2008-06-26T13:05:25+00:00

Tomorrow is the yearly JavaOne Afterglow at De Montil, Affligem. I'll be presenting on the status of GlassFish and the directions as announced at JavaOne last month. See you there! Register here.

James' Blog: Connecting to a MySQL Database in NetBeans 6.1

2008-06-26T12:20:46+00:00

Hi again,

Another NetBeans tutorial has been updated for 6.1. The Connecting to a MySQL Database tutorial has been updated to reflect the changes in NetBeans IDE 6.1, and there are a lot of changes. The tutorial reflects the increased support for MySQL in NetBeans 6.1 and provides detailed instructions for connecting to a MySQL database, creating a MySQL database, etc. Look for even more changes in NetBeans 6.5.

Have fun with this one.

--James

Lukas Hasik's Weblog: Changing teams - bye, bye, Mobility

2008-06-26T11:16:51+00:00

I used to be the quality assurance engineer and later team lead of the QA for last 5 years. I like the product - NetBeans Mobility. I liked the team that was working on it. Unfortunately, I had to leave the team two weeks ago. No, I haven't left SUN. I just moved to the Core&Platform QA. When I started to lead both QA teams half a year ago it seemed doable. But later on we discovered that there is not enough resources in the QA team in Prague to cover all the functionality we had been responsible for. We had to pass something to different teams in different SUN's offices. Bye, bye, Mobility, my very loved child. I hope that the new team in St. Petersburg will keep the quality on the same level. Actually, they have to I'm still watching the project. (I didn't mean it offensive...) Good luck to Ivan and Andrei.

What this change means for me? I'll have more time to focus on only one thing. For now it will be the NetBeans Platform and the Core NetBeans functionality.

What it means for you? I won't blog about Mobility much in future, probably. I'll blog about more about NetBeans Platform and IDE.

Geertjan's Blog: Quick Search API

2008-06-26T10:42:38+00:00

The 6.5 Milestone 1 New and Noteworthy document (which is a work in progress since 6.5 M1 has not yet been released and is scheduled for release during the coming weeks) talks, among many other things, about something called "Quick Search".

The description says: "Quickly search for action or type is now easy. Use Ctrl-I." The two related documents are in the Wiki and on NetBeans.org. So, wherever you are in the IDE, you're able to press Ctrl-I, then you find that the cursor is in the Quick Search, you type the letter of something you're interested in opening into the Quick Search, and the results are shown:

Select an item and the related action is invoked, in the case of the actions, or the type is opened in the editor, in the case of the types. That's all very nice. What's nicer is that there's a new API that lets you plug your own items into the Quick Search functionality. Even better is the fact that there's a new wizard to support this. Take the following steps (using a build from today or later):

Create a new module.
Click Ctrl-N to bring up the New File dialog and then choose Module Development | Quick Search Provider:
Click Next and then fill out the last step of the template:

Click Finish and then look in the layer.xml file and you should see this:

<filesystem>
    <folder name="QuickSearch"> <folder name="Beatles"> <attr name="command" stringvalue="Beatles"/> <attr name="position" intvalue="0"/> <file name="org-nb-beatles-BeatleSearchProvider.instance"> <attr name="SystemFileSystem.localizingBundle" stringvalue="org.nb.beatles.Bundle"/> </file> </folder> </folder> </filesystem>

Then look at the generated class and you should see this:

package org.nb.beatles; import org.netbeans.spi.quicksearch.SearchProvider; import org.netbeans.spi.quicksearch.SearchRequest; import org.netbeans.spi.quicksearch.SearchResponse; public class BeatleSearchProvider implements SearchProvider { /** * Method is called by infrastructure when search operation was requested. * Implementors should evaluate given request and fill response object with * apropriate results * * @param request Search request object that contains information
    what to search for * @param response Search response object that stores search results. Note that it's important to react to return value of SearchResponse.addResult(...) method and stop computation if false value is returned. */ public void evaluate(SearchRequest request, SearchResponse response) { //sample code //for (SearchedItem item : getAllItemsToSearchIn()) { // if (isConditionSatisfied(item, request)) { // if (!response.addResult(item.getRunnable(), item.getDisplayName(), // item.getShortcut(),
    item.getDisplayHint())) { // break; // } // } //} } }

Now begin working with the generated class so that it will do something useful. Begin by setting a dependency on UI Utilities API so that you can use the URLDisplayer class, which will open the browser with the URL to the Wikipedia entry of the selected Beatle, which is simply the little scenario we'll go through below. Then change the class above to the following:

package
    org.nb.beatles; import java.net.MalformedURLException; import java.net.URL; import java.util.logging.Level; import java.util.logging.Logger; import org.netbeans.spi.quicksearch.SearchProvider; import org.netbeans.spi.quicksearch.SearchRequest; import org.netbeans.spi.quicksearch.SearchResponse; import org.openide.awt.HtmlBrowser.URLDisplayer; public class BeatleSearchProvider implements SearchProvider { public void evaluate(SearchRequest request, SearchResponse response) { String[] beatles = {"john",
    "paul", "ringo", "george"}; for (String beatle : beatles) { if (beatle.toLowerCase().indexOf(request.getText().toLowerCase()) != -1) { if (!response.addResult(new BeatleFoundResult(beatle), beatle)) { return; } } } } private static class BeatleFoundResult implements Runnable { private String beatle; public BeatleFoundResult(String beatle) { if (beatle.equals("john")) { this.beatle = "http://en.wikipedia.org/wiki/John_lennon"; } else if (beatle.equals("paul")) { this.beatle =
    "http://en.wikipedia.org/wiki/Paul_McCartney"; } else if (beatle.equals("ringo")) { this.beatle = "http://en.wikipedia.org/wiki/Ringo_Starr"; } else if (beatle.equals("george")) { this.beatle = "http://en.wikipedia.org/wiki/George_Harrison"; } } public void run() { try { URLDisplayer.getDefault().showURL(new URL(beatle)); } catch (MalformedURLException ex) { Logger.getLogger(BeatleSearchProvider.class. getName()).log(Level.SEVERE, null, ex); } } } }

Install it (do a restart if installing into the development IDE) and then press Ctrl-I anywhere and you'll find the cursor in the Quick Search field where you can start typing. If the letter you type is anywhere in one of the items you added to the Quick Search, the item is shown. So here I typed "o", which is found in "john", "ringo", and "george", but not in "paul":

Select the item, the browser opens, displaying the Wikipedia entry on the selected Beatle.
Once you've selected an item, it is automatically stored in the "Recent Searches" category, so that it is easier to see next time you do a quick search.

How useful is it to be able to search for the Beatles inside NetBeans IDE? Not very. But this is just a simple example. Imagine that this was not NetBeans IDE, but your own application with its own domain-specific data. Being able to plug relevant parts of that data, or ui from the application itself, into the Quick Search feature could be a pretty powerful aid to your end users.

Adam Bien: Embedding Glassfish V3 in Unit Test - Two Jars, Three Lines Of Code And Five Seconds Start With Deployment

2008-06-26T10:02:00+00:00

There is already a great blog entry about using Glassfish v3 in embedded mode (I "reused" some ideaas and even code from the post - this is how web works :-)). It explains the whole process, to install, build and test Glassfish v3 using maven 2. However I just liked to do it without maven - and as easy as possible. To start glassfish you only need two jar:

gf-embedded-api-1.0-alpha-4.jar
web-all-10.0-build-20080430.jar

Having them in the classpath, you can start glassfish v3 just from your code - in process:

GlassFish glassfish = new GlassFish(port);
It is not only possible to start glassfish in embedded code, it is even possible to deploy applications on the fly. The following code does exactly that:

ScatteredWar war = new ScatteredWar(NAME, new File("src/main/resources"), new File("src/main/resources/WEB-INF/web.xml"), Collections.singleton(new File("build/classes").toURI().toURL()));
glassfish.deploy(war);

...and the full test code:

import org.glassfish.embed.GlassFish;
import org.glassfish.embed.ScatteredWar;
//and other obvious imports

public class HelloServletTest{

private final String NAME = "AppTest";
public static int port = 9999;

private GlassFish glassFish;

    @Before
    public void bootGlassfish() throws Exception{
        this.glassFish = newGlassFish(port);
        assertNotNull(this.glassFish);
    }
    @Test
    public void testServlet() throws Exception {
        URL url = new URL("http://localhost:" + port + "/" + NAME + "/HelloServlet");
        BufferedReader br = new BufferedReader(
                new InputStreamReader(
                url.openConnection().getInputStream()));
        assertEquals("Hallo from servlet", br.readLine());
    }

    private GlassFish newGlassFish(int port) throws Exception {
        GlassFish glassfish = new GlassFish(port);
        ScatteredWar war = new ScatteredWar(NAME,
                new File("src/main/resources"),
                new File("src/main/resources/WEB-INF/web.xml"),
                Collections.singleton(new File("build/classes").toURI().toURL()));
        glassfish.deploy(war);
        System.out.println("Ready ...");
        return glassfish;
    }

    @After
    public void shutdown(){
           this.glassFish.stop();
    }

The unit test is only a sample, in general I woul start glassfish in the static @BeforeClass method - for one test it is good enough.
Glassfish v3 is not production ready yet - but it becomes more and more interesting for development. Cannot wait for embeddable EJB 3 containers :-).

I checked in the whole project (with servlet, glassfish jars and the unit test) into the p4j5. The project name is: EmbeddedGlassfishWeb. The remaining question is: from where I have this two jars - the answer is simple: from the maven repository :-).

So, and I'm going to present this stuff now - I'm at Jazoon :-).

Amit Kumar Saha's Blog: NetBeans plugin: Folder to HTML

2008-06-26T07:06:26+00:00

I came across this plugin "Folder to HTML" in a development build of the NetBeans IDE. This plugin dumps your entire project structure into a nice looking HTML representation.

Read more at NetBeans plugin: Folder to HTML

Here is a screencast for the above plugin: http://www.youtube.com/watch?v=cU0O3m0JrWg

Brian Leonard's Blog: Introducing The Observatory

2008-06-25T21:19:53+00:00

Yesterday Gregg Sporar, Roman Strobl and I launched The Observatory, a blog dedicated to those learning to use OpenSolaris.

James' Blog: Securing a Web Application in NetBeans 6.1

2008-06-25T11:32:54+00:00

Hi all,

Another tutorial is ready for users: Securing a Web Application in NetBeans 6.1. It's a short tutorial in which you configure security authentication using a basic login window and also using a login form in a web page. The tutorial takes you through the steps for creating users on the Tomcat server and GlassFish. After creating the users, you then create the security roles by setting the security properties in the deployment descriptor. You also learn how to use JDBC authentication to secure your application when deploying to GlassFish.

You can find the tutorial at http://www.netbeans.org/kb/60/web/security-webapps.html.

It also works for NetBeans 6.0.

See you tomorrow.

--James

Bistro!: Groovy/Grails support in soon-to-come NetBeans 6.5

2008-06-25T08:41:54+00:00

NetBeans 6.5 Milestone 1 is around the corner and the schedule promises a release date in a few months only. Demo extraordinaire Roman announces the integration of the Groovy/Grails plugins in the core of the IDE (not sure how it translates in terms of download bundles) and also tells you about his new job at Sun. Good luck Roman and folks!

Adam Bien: To JSF Or Not To JSF ...This Is The Question - or Why vi is Not Enough

2008-06-25T08:14:16+00:00

Java Server Faces 1.2 are already shipped with every Java EE 5 server - so before you are choosing a more esotheric framework, you should at least evaluate JSF.
JSF are component based - the development model is event-driven and similar to Swing

A backend object (backing bean) receives the events (just a method)
Bi-directional, declarative Data Binding can be used to synchronize the view-components with the backing bean
The backing bean runs on the server - it can access e.g. the EJB 3.0 per Reference. "Fat Client" programming model is possible :-). This is a huge advantage. No value objects, client objects etc. are required.
Model View Presenter / Model View Controller patterns are easy to implement. The presenters / controllers can be even shared with Swing apps (in theory - in practice the views are too different).

Convenient data conversion for the common types (e.g. from String to int) already happens behind the scenes.
Validation support is already built in.
Navigation / Page Flow are provided and standardized.
Visual tool support for JSF is outstanding. Most of the tools are free e.g. Netbeans 6.1, Oracle JDeveloper, Eclipse with Plugins (e.g. Visual Page Designer in WTP 2.0). Some tools (e.g. Netbeans) provide visual support for page flows.
There are already many JSF component providers - many have AJAX support, and are opensource.

JSF programming with good tool support can be very productive (in my opinion - unbeatable). So it is absolutely possible to build from scratch a CRUD app in three minutes (with nice table - sorting included) - without hacking. In case a given JSF provider fully covers your customer's requirements - it's the best choice. Some extensions like Shale or Tiles, help you better structuring your application / page flow. However I would only use them if necessary (every jar increases the complexity...- and makes the deployment harder).

Nevertheless JSF 1.2 has also a "dark side":

The amount of XML-configuration is considerable (therefore tools are absolutely needed - vi, even emacs are not enough :-))
Building custom components requires some deeper knowledge - it is not so simple, as it could be.
Every request is a POST request - you will need some workarounds for bookmarking etc.
For more sophisticated applications - you will need to understand the "6 phases" - this can take a day of experimentation to fully understand it.
You will still need JavaScript / AJAX expertise, regardless how good your framework is.
Customizing the look and feel of the visual components, can be time-consuming. Go with the default if possible.
The whole component tree is cached on the server in memory - you should plan some performance tests to verify the requirements. In general the performance is o.k.

So to JSF Or Not To JSF - I'm a consultant - so the answer is clear: "it depends" :-). If you are building a corporate, enterprise application - JSF are just perfect. On the other hand, if you target is the consumer market, you are probably looking for more flexibility (and probably more effort to build the app then). Already looking forward to JSF 2.0 :-).