In this chapter, we will cover how to get started with NetBeans; topics covered in this chapter include:
Starting NetBeans for the first time
Configuring NetBeans for Java EE development
Deploying our first application
NetBeans tips for effective development
NetBeans is an Integrated Development Environment (IDE) and platform. Although initially the NetBeans IDE could only be used to develop Java applications, as of version 6 NetBeans supports several programming languages, either by built-in support or by installing additional plugins. Programing languages natively supported by NetBeans include Java, JavaFX, C, C++ and PHP. Groovy, Scala, Ruby and others are supported via additional plugins
In addition to being an IDE, NetBeans is also a platform. Developers can use NetBeans' APIs to create both NetBeans plugins and standalone applications.
For a brief history of Netbeans, see http://netbeans.org/about/history.html.
Although the NetBeans IDE supports several programming languages, because of its roots as a Java only IDE it is a lot more popular with this language. As a Java IDE, NetBeans has built-in support for Java SE (Standard Edition) applications, which typically run in the user's desktop or notebook computer; Java ME (Micro Edition), which typically runs in small devices such as cell phones or PDAs; and for Java EE (Enterprise Edition) applications, which typically run on "big iron" servers and can support thousands of concurrent users.
Some of the features we will cover include how NetBeans can help us speed up web application development using JSF or the Servlet API and JSPs by providing a starting point for these kind of artifacts, and how we can use the NetBeans palette to drag and drop code snippets into our JSPs, including HTML and JSP markup. We will also see how NetBeans can help us generate JPA entities from an existing database schema (JPA is the Java Persistence API, the standard Object-Relational mapping tool included with Java EE).
In addition to web development, we will also see how NetBeans allows us to easily develop Enterprise JavaBeans (EJBs); and how to easily develop web services. We will also cover how to easily write both EJB and web service clients by taking advantage of some very nice NetBeans features.
Before taking advantage of all of the above NetBeans features, we of course need to have NetBeans installed, as covered in the next section.
NetBeans can be obtained by downloading it from http://www.netbeans.org.
To download NetBeans, we need to click on the button labeled Download Free NetBeans IDE 7.0 (the exact name of the button may vary depending on the current version of NetBeans). Clicking on this button will take us to a page displaying all of NetBeans download bundles.
NetBeans download includes different NetBeans bundles that provide different levels of functionality. The following table summarizes the different available NetBeans bundles and describes the functionality they provide:
Allows development of Java desktop applications.
Allows development of Java Standard Edition (typically desktop applications), and Java Enterprise Edition (enterprise application running on "big iron" servers) applications.
Allows development of applications written in the C or C++ languages.
Allows development of web applications using the popular open source PHP programming language.
Includes functionality of all NetBeans bundles.
To follow the examples on this book, either the Java EE or the All bundle is needed.
The screenshots in this book were taken with the Java EE bundle. NetBeans may look slightly different if the All Pack is used, particularly, some additional menu items may be seen.
Mac OS X
Additionally, NetBeans can be executed in any platform containing Java 6 or newer. To download a version of NetBeans to be executed in one of these platforms, an OS independent version of NetBeans is available for download.
Although the OS independent version of NetBeans can be executed in all of the supported platforms, it is recommended to obtain the platform-specific version of NetBeans for your platform.
The NetBeans download page should detect the operating system being used to access it, and the appropriate platform should be selected by default. If this is not the case, or if you are downloading NetBeans with the intention of installing it in another workstation on another platform, the correct platform can be selected from the drop down labeled, appropriately enough, Platform.
Once the correct platform has been selected, we need to click on the appropriate Download button for the NetBeans bundle we wish to install. For Java EE development, we need either the Java EE or the All bundle. NetBeans will then be downloaded to a directory of our choice.
Java EE applications need to be deployed to an application server. Several application servers exist in the market, both the Java EE and the All NetBeans bundles come with GlassFish and Tomcat bundled. Tomcat is a popular open source servlet container, it can be used to deploy applications using the Servlets, JSP and JSF, however it does not support other Java EE technologies such as EJBs or JPA. GlassFish is a 100 percent Java EE-compliant application server. We will be using the bundled GlassFish application server to deploy and execute our examples.
Since this book is aimed at experienced Java Developers, we will not spend much time explaining how to install and configure the JDK, since we can safely assume the target market for the book more than likely has a JDK installed. Installation instructions for JDK 6 can be found at http://www.oracle.com/technetwork/java/javase/index-137561.html.
Readers wishing to use Mac OS X can get installation instructions and the JDK download for their platform at http://developer.apple.com/java/.
NetBeans installation varies slightly between the supported platforms. In the following few sections we explain how to install NetBeans on each supported platform.
For Microsoft Windows platforms, NetBeans is downloaded as an executable file named something like netbeans-7.0-ml-java-windows.exe, (exact name depends on the version of NetBeans and the NetBeans bundle that was selected for download). To install NetBeans on Windows platforms, simply navigate to the folder where NetBeans was downloaded and double-click on the executable file.
For Mac OS X, the downloaded file is called something like netbeans-7.0-ml-java-macosx.dmg (exact name depends on the NetBeans version and the NetBeans bundle that was selected for download). In order to install NetBeans, navigate to the location where the file was downloaded and double-click on it.
The Mac OS X installer contains four packages, NetBeans, GlassFish, Tomcat, and OpenESB, these four packages need to be installed individually, They can be installed by simply double-clicking on each one of them. Please note that GlassFish must be installed before OpenESB.
For Linux and Solaris, NetBeans is downloaded in the form of a shell script. The name of the file will be similar to netbeans-7.0-ml-java-linux.sh, netbeans-7.0-ml-java-solaris-x86.sh, or netbeans-7.0-ml-java-solaris-sparc.sh, depending on the version of NetBeans, the selected platform and the selected NetBeans bundle.
Before NetBeans can be installed in these platforms, the downloaded file needs to be made executable. This can be done in the command line by navigating to the directory where the NetBeans installer was downloaded and executing the following command:
chmod +x ./filename.sh
Substitute filename.sh with the appropriate file name for the platform and the NetBeans bundle.
Once the file is executable it can be installed from the command line:
Again substitute filename.sh with the appropriate file name for the platform and the NetBeans bundle.
For other platforms, NetBeans can be downloaded as a platform-independent zip file. The name of the zip file will be something like netbeans-7.0-201007282301-ml-java.zip (exact file name may vary, depending on the exact version of NetBeans downloaded and the NetBeans bundle that was selected).
To install NetBeans on one of these platforms, simply extract the zip file to any suitable directory.
Even though the way to execute the installer varies slightly between platforms, the installer behaves in a similar way between most of them.
One exception is the Mac OS X installer, under Mac OS X, each individual component (NetBeans, GlassFish, Tomcat, and OpenESB) comes with its own installer and must be installed individually. GlassFish must be installed before OpenESB.
Another exception is the platform-independent zip file. In this case there is essentially no installer, installing this version of NetBeans consists of extracting the zip file to any suitable directory.
After executing the NetBeans installation file for our platform, we should see a window similar to the one illustrated in the following screenshot:
The packs shown may vary depending on the NetBeans bundle that was downloaded; the above screen shot is for the "Java EE" bundle.
At this point we should click on the button labeled Next> to continue the installation.
NetBeans is dual licensed, licenses for NetBeans include the GNU Public License (GPL) version 2 with CLASSPATH exception, and the Common Development and Distribution License (CDDL) . Both of these licenses are approved by the Open Source Initiative (OSI).
To continue installing NetBeans, click on the checkbox labeled I accept the terms in the license agreement and click on the button labeled Next>.
We need to either accept the terms of the JUnit license at this point or choose not to install JUnit
At this point the installer will prompt us for a NetBeans installation directory, and for a JDK to use with NetBeans. We can either select new values for these or take the provided defaults.
Once we have selected the appropriate installation directory and JDK, we need to click on the button labeled Next> to continue the installation.
After NetBeans and all related components have been installed, the installer indicates a successful installation, giving us the option to contribute anonymous usage data. After making our selection we can simply click on the Finish button to exit the installer.
On most platforms, the installer places a NetBeans icon on the desktop, the icon should look like the following image:
We can start NetBeans by double-clicking on its icon, we should see the NetBeans splash screen while it is starting up.
Once NetBeans starts, we should see a page with links to demos, tutorials, sample projects, etc.
NetBeans defaults to showing this start page every time it is started, if we don't wish for this page to be displayed automatically every time NetBeans is started, we can disable this behavior by un-checking the checkbox labeled Show on Startup at the bottom of the page. We can always get the start page back by going to Help | Start Page.
NetBeans comes preconfigured with the GlassFish 3 application server, and with the JavaDB RDBMS. If we wish to use the included GlassFish 3 and JavaDB RDBMS, there is nothing we need to do to configure NetBeans.
We can, however, integrate NetBeans with other Java EE application servers such as JBoss, Weblogic, or WebSphere and with other Relational Database Systems such as MySQL, PostgreSQL, Oracle, or any RDBMS supported by JDBC, which pretty much means any RDBMS.
Integrating NetBeans with an application server is very simple, to do so, we need to follow the following steps:
In this section we will illustrate how to integrate NetBeans with JBoss, the procedure is very similar for other application servers or servlet containers.
First, we need to click on Win dow | Services.
Next, we need to right-click on the node labeled Servers in the tree inside the Services window, and select Add Server... from the resulting pop up menu.
Then we need to select the server to install from the list in the resulting window, and click on the button labeled Next>.
We then need to enter a location in the file system where the application server is installed and click Next>.
Finally, we need to select a domain, host, and port for our application server, and then click on the Finish button.
The Services window should now display our newly added application server.
That's it! We have successfully integrated NetBeans with a third party application server.
NetBeans comes with built-in integration with the JavaDB RDBMS system. Additionally, it comes with JDBC drivers for other RDBMS systems such as MySQL and PostgreSQL. It also comes with the JDBC-ODBC bridge driver to connect to RDBMS systems that don't natively support JDBC or for which a JDBC driver is not readily available.
Although using the JDBC-ODBC bridge allows us to connect to most RDBMS systems without having to obtain a JDBC driver, it is usually a better idea to obtain a JDBC driver for our RDBMS. The JDBC-ODBC bridge does not offer the best performance and there are JDBC drivers available for the vast majority of RDBMS systems.
In this section, we will create a connection to HSQLDB, an open source RDBMS written in Java. The idea is illustrate how to integrate NetBeans with a third party RDBMS, the procedure is very similar for other RDBMS systems such as Oracle, Sybase, SQL Server, and so on.
Before we can connect to a third party RDBMS, we need to add its JDBC driver to NetBeans. To add the JDBC driver, we need to right-click on the Drivers node under the Databases node in the Services tab.
We then need to select a JAR file containing the JDBC driver for our RDBMS, NetBeans guesses the name of the driver class containing the JDBC driver. If more than one driver class is found in the JAR file, the correct one can be selected from the drop down menu labeled Driver Class. We need to click on the OK button to add the driver to NetBeans.
Once we have followed the above procedure, our new JDBC driver is displayed in the list of registered drivers.
Once we have added the JDBC driver for our RDBMS to NetBeans, we are ready to connect to the third party RDBMS.
To connect to our third party RDBMS, we need to right click on its driver on the Services tab, then click on Connect Using... on the resulting pop up menu.
Then we need to enter the JDBC URL, username, and password for our database.
After selecting the schema and clicking on the OK button, our database is shown in the list of databases in the Services window. We can connect to it by right-clicking on it, selecting Connect from the resulting pop up, then entering our username and password for the database (we can choose not to allow NetBeans to "remember" the password when we add the database).
We have now successfully connected NetBeans to a third party RDBMS.
NetBeans comes pre-configured with a number of sample applications. To make sure everything is configured correctly, we will now deploy one of the sample applications to the integrated GlassFish application server that comes bundled with NetBeans.
To open the sample project, we need to go to File | New Project, then select Samples | Java Web from the categories list in the resulting pop up window. Once we have selected Java Web from the categories list, a list of projects is displayed in the Projects list, for this example we need to select the Servlet Stateless project. This sample is a simple project, it uses both a servlet and a stateless session bean, which gives us a chance to use both the GlassFish servlet container and its EJB container.
We can compile, package, and deploy our project all in one shot by right-clicking on it and selecting Run from the resulting pop up menu.
As soon as our application is deployed, a new browser window or a tab automatically starts, displaying the default page for our sample application.
The sample web application we just deployed is a simple application that demonstrates a nice feature that was introduced in Java EE 6, namely the ability to use dependency injection on a stateless session bean without the need to implement a business interface for said bean like it was required in Java EE 5, or without needing to use a home interface to obtain an instance of the session bean as we had to do back in the days of J2EE.
If our browser is displaying a page similar to the one above, then we can be certain that NetBeans and GlassFish are working properly and we are ready to start developing our own Java EE applications.
Although NetBeans offers a wide array of features that make Java EE development easier and faster, it also has a lot of features that ease Java development in general. In the following few sections we cover some of the most useful features.
The NetBeans code editor includes very good code completion, for example, if we wish to create a private variable, we don't need to type the whole "private" word. We can simply write the first three letters ("pri"), then hit Ctrl+space, and NetBeans will complete the word "private" for us.
Code completion also works for variable types and method return values, for example, if we want to declare a variable of type
java.util.List , we simply need to type the first few characters of the type, then hit Ctrl+space, NetBeans will try to complete with types in any packages we have imported in our class. To make NetBeans attempt to complete with any type in the CLASSPATH, we need to hit Ctrl+space again.
As we can see in the above screenshot, NetBeans displays JavaDoc for the class we selected from the code completion options. Another time-saving feature is that the class we select from the options is automatically imported into our code.
Once we have the type of our variable, we can hit Ctrl+Space again right after the variable and NetBeans will suggest variable names.
When we want to initialize our variable to a new value, we can simply hit Ctrl+space again and a list of valid types is shown as options for code completions.
In our example, our type (
java.util.List) is an interface, therefore all classes implementing this interface are shown as possible candidates for code completion. Had our type been a class, both our class and all of its subclasses would have been shown as code completion candidates.
When we are ready to use our variable, we can simply type the first few characters of the variable name, then hit Ctrl+Space.
When we wish to invoke a method in our object, we simply type the dot at the end of the variable name, and all available methods are displayed as code completion options.
Notice how the JavaDoc for the selected method is automatically displayed.
Code templates are abbreviations for frequently used code snippets. To use a code template, we simply type it into the editor and hit the Tab key to expand the abbreviations into the full code snippet it represents.
For example, typing
sout and pressing the Tab key will expand into
System.out.println("");, with the caret placed between the two double quotes.
Some of the most useful code templates are listed in the table below, please note that code templates are case sensitive.
Example expanded text
Useful when declaring public static final variables.
To see the complete list of code templates, click on Tools | Options, click on the Editor icon, then on the Code Templates tab.
We can add our own templates by clicking on the New button, we will be prompted for the template's abbreviation. Once we enter it our new template will be added to the template list and will automatically be selected. We can then enter the expanded text for our template in the Expanded Text tab.
It would be good to mention that code templates exist not only for Java but for HTML, CSS, and all other editors in NetBeans.
NetBeans offers several keyboard shortcuts that allow very fast navigation between source files. Memorizing these keyboard shortcuts allow us to develop code a lot more effectively than relying on the mouse. Some of the most useful NetBeans keyboard shortcuts are listed in this section, but this list is by no means exhaustive, the complete list of NetBeans keyboard shortcuts can be found online at http://netbeans.org/projects/www/downloads/download/shortcuts.pdf.
One useful keyboard shortcut that allows us to quickly navigate within a large Java file is Ctrl+F12. This keyboard shortcut will present an outline of the current Java file in the editor and show all of its methods and member variables.
Typing in the text field labeled Filter narrows the list of member variables and methods shown. This keyboard shortcut makes it very fast to navigate through large files.
Hitting Alt+F12 will result in a pop up window outlining the class hierarchy of the current Java class.
We can use the above shortcut to quickly navigate to a superclass or a subclass of the current class.
Another useful keyboard shortcut is Alt+Insert, this keyboard shortcut can be used to generate frequently used code such as constructors, getter, and setter methods, etc.
The code will be generated at the current location of the caret.
Additionally, when the caret is right next to an opening or closing brace, clicking Ctrl+[ results in the caret being placed in the matching brace. This shortcut works for curly braces, parenthesis, and square brackets. Hitting Ctrl+Shift+[ has a similar effect, but this key combination not only places the caret in the matching brace, it also selects the code between the two carets.
Sometimes, we would like to know all the places in our project where a specific method is invoked. Hitting Alt+F7 while the method is highlighted allows us to easily find out this information.
The above keyboard shortcut works with variables as well.
NetBeans will indicate compilation errors in our code by underlining the offending line with a squiggly red line. Placing the caret over the offending code and hitting Alt+Enter will allow us to select from a series of suggestions to fix our code.
Sometimes navigating through all the files in a project can be a bit cumbersome, especially if we know the name of the file we want to open but we are not sure of its location. Luckily, NetBeans provides the Shift+Alt+O keyboard shortcut that allows us to quickly open any file in our project.
Additional useful keyboard shortcuts include Shift+Alt+F, this shortcut quickly formats our code; Ctrl+E erases the current line, much faster than highlighting the line and hitting backspace. Sometimes we import a class into our code and later decide not to use it, some of us delete the lines where the class is used but forget to delete the import line at the top of the source file, NetBeans will generate a warning about the unused import, hitting Ctrl+Shift+I will delete all unused imports in one fell swoop, plus it will attempt to add any missing imports.
One last thing worth mentioning, even though it is not strictly a keyboard shortcut, a very useful feature of the NetBeans editor is that left-clicking on a method or variable while pressing Ctrl will turn the method or variable into a hyper link. Clicking on that hyper link will result in NetBeans taking us to the method or variable declaration.
In addition to offering keyboard shortcuts, code templates, and code completion, NetBeans offers a number of visual cues that allow us to better understand our code at a glance. Some of the most useful are illustrated in the following screenshot:
When there is a warning in our code NetBeans will alert us in two ways, it will underline the offending line with a squiggly yellow line, and it will place the icon shown below in the left margin of the offending line.
The light bulb in the icon indicates that NetBeans has a suggestion on how to fix the problem, moving the caret to the offending line and hitting Alt+Enter as discussed in the previous section will result in NetBeans offering one or more ways of fixing the problem.
Similarly, when there is a compilation error, NetBeans will underline the offending line with a red squiggly line, and place the icon shown below on the left margin of said line.
Again the light bulb indicates that NetBeans has suggestions on how to fix the problem, hitting Alt+Enter in the offending line will allow us to see the suggestions that NetBeans has.
NetBeans not only provides visual cues for errors in our code, it also provides other cues, for example, placing the caret next to an opening or closing brace will highlight both the opening and closing brace, as shown in the
doSomething() method in the above screenshot.
If one of our methods overrides a method from a parent class, the icon shown below will be placed in the left margin next to the method declaration.
The icon is an upper case "O" inside a circle, the O, of course, stands for override.
Similarly, when one of our methods is an implementation of one of the interfaces that our class implements, the icon shown below will be placed in the left margin of the method declaration.
The icon is an uppercase I inside a green circle, which stands for implements.
NetBeans also provides visual cues in the form of fonts and font colors. For example, static methods and variables are shown in italics, member variables are shown in green, and Java reserved keywords are shown in blue, all of the above cues can be seen in the screenshot at the beginning of this section.
Another nice feature of the NetBeans editor is that highlighting a method or variable highlights it everywhere it is used in the current open file.
In this chapter, we provided a brief history of how Java EE came into existence. We also explained how to obtain and install NetBeans for the different platforms it supports.
Additionally, we explained how to set up NetBeans with third party Java EE application servers and with third party Relational Database Systems, including how to register a JDBC driver for the RDBMS in question.
We also built and deployed our first Java EE application by using one of the sample projects included by NetBeans.
Finally we covered some of the NetBeans features such as code completion, code templates, keyboard shortcuts, and visual cues that allow us to do our job as software developers more effectively.