Archive for the ‘NetBeans’ Category.

Change font size of NetBeans IDE controls

It's a little bit confusing changing the font size of IDE controls and menus. The options dialog has only font size changes for the editor, not for the whole IDE. This is specially helpful on windows with scaled screen resolution on HiDPI displays.

The trick is to add an additional parameter to the VM options in the netbeans.conf configuration file. On Windows this is e.g. C:\Program Files\NetBeans 8.2\etc\netbeans.conf, on OS X /Applications/NetBeans/Netbeans

Add the parameter --font-size to the line starting with netbeans_default_options.


  1.  netbeans_default_options="--font-size=14 -J-client -J-Xss2m -J-Xms32m"

Now the IDE has a font size of 14pt for the IDE.

ObjectListDataProvider Tutorial

This is a tutorial for using the ObjectListDataProvider in a Visual Web Project. A ObjectListDataProvider is useful if the underlaying data is from a datasource not supported by NetBeans. Some samples for such datasources are a JPA or hibernate connection, other legacy systems such SAP or Lotus Notes and files in various formats.

In this tutorial we use a text file with customer records as datasource for our application.

Creating the project

In the first step you create a normal VWP project named OldpSample:

Project settings OLDP

Address POJO

For data storage we use a simple POJO object. Right click the oldpsample package under «Source Packages» and select «New -> Java Class». Name the class Address.

Create Address class

  1. package oldpsample;
  3. public class Address {
  5. private String id;
  6. private String title;
  7. private String lastname;
  8. private String firstname;
  9. private String street;
  10. private String city;
  11. private String state;
  12. private String country;
  14. /** Creates a new instance of Address */
  15. public Address() {
  16. }
  18. public String getId() {
  19. return id;
  20. }
  22. public void setId(String id) {
  23. = id;
  24. }
  26. public String getTitle() {
  27. return title;
  28. }
  30. public void setTitle(String title) {
  31. this.title = title;
  32. }
  34. public String getLastname() {
  35. return lastname;
  36. }
  38. public void setLastname(String lastname) {
  39. this.lastname = lastname;
  40. }
  42. public String getFirstname() {
  43. return firstname;
  44. }
  46. public void setFirstname(String firstname) {
  47. this.firstname = firstname;
  48. }
  50. public String getStreet() {
  51. return street;
  52. }
  54. public void setStreet(String street) {
  55. this.street = street;
  56. }
  58. public String getCity() {
  59. return city;
  60. }
  62. public void setCity(String city) {
  63. = city;
  64. }
  66. public String getState() {
  67. return state;
  68. }
  70. public void setState(String state) {
  71. this.state = state;
  72. }
  74. public String getCountry() {
  75. return country;
  76. }
  78. public void setCountry(String country) {
  79. = country;
  80. }
  82. }

Create AddressDataProvider

Now we create the class AddressDataProvider. We create a new class and derive it from ObjectListDataProvider. Right click the oldpsample package under «Source Packages» and select «New -> Java Class».

Create AdressDataProvider class

Our class stores all data in a ArrayList, so we need a member variable of type ArrayList. In the constructor we must tell the underlying ObjectListDataProvider where the data comes from (method setList) and of which type the data is (method setObjectType). We also need methods to load the data from file or stream.

  1. package oldpsample;
  3. import;
  4. import;
  5. import;
  6. import;
  7. import;
  8. import java.util.ArrayList;
  10. public class AddressDataProvider extends ObjectListDataProvider {
  12. private ArrayList addressList = new ArrayList();
  14. /** Creates a new instance of AddressDataProvider */
  15. public AddressDataProvider() {
  16. setList( addressList );
  17. setObjectType( Address.class );
  18. }
  20. public void load(InputStream istream ) {
  21. try {
  22. InputStreamReader sr = new InputStreamReader( istream );
  24. while ( br.ready() ) {
  25. String line = br.readLine();
  26. String[] cols = line.split( ";" );
  28. if ( cols.length == 8 ) {
  29. Address address = new Address();
  30. address.setId( cols[0] );
  31. address.setTitle( cols[1] );
  32. address.setLastname( cols[2] );
  33. address.setFirstname( cols[3] );
  34. address.setStreet( cols[4] );
  35. address.setCity( cols[5] );
  36. address.setState( cols[6] );
  37. address.setCountry( cols[7] );
  38. getList().add( address );
  39. }
  40. }
  42. } catch ( Exception e ) {
  43. e.printStackTrace();
  44. }
  45. }
  47. public void load(String filename) {
  48. try {
  49. FileInputStream fs = new FileInputStream( filename );
  50. load( fs );
  51. } catch ( Exception e ) {
  52. e.printStackTrace();
  53. }
  54. }
  56. }

Add AddressDataProvider to SessionBean1

In the outline view right click on SessionBean1 and select «Add->Property» from the context menu. Name the property «addressDataProvider» and enter «AddressDataProvider» as Type. Leave all other options on the default values.

New Property addressDataProvider

Double click SessionBean1 in the outline view. Find the line

  1. private AddressDataProvider addressDataProvider;

and change it to

  1. private AddressDataProvider addressDataProvider = new AddressDataProvider();

You must build, close and reopen your VWP project now (as of NetBeans 5.5.1). If not, NetBeans doesn't detect our ObjectListDataProvider. This should hopefully not been necessary in future NetBeans releases.

Design Web Page

The project wizard has generated a default web page Page1.jsp. Open this page and the visual designer starts.

Select a table component from the palette and drop it onto your page. Right click the table component and select «Bind to Data...». Select «addressDataProvider (SessionBean1)» from the dropdown list. Reorder the fields with the «Up» and «Down» buttons, so it look like this:

Select Data Provider

Press «OK» and our page has a table component bound to the AddressDataProvider.

To show some data in the table component we let the user upload a CSV file. Drop a File Upload and a Button component from the palette onto the page. Set the text property of the button to «Upload file». Your page should look like this:

Page Design

Double click on the «Upload file» button and enter the following code into the event handler:

  1. public String button1_action() {
  2. if ( fileUpload1.getUploadedFile().getSize() > 0 ) {
  3. try {
  4. getSessionBean1().getAddressDataProvider().load(
  5. getFileUpload1().getUploadedFile().getInputStream() );
  6. } catch ( Exception e ) {
  7. e.printStackTrace();
  8. }
  9. }
  10. return null;
  11. }

Run your project. Use this sample CSV data file to test the application:

1;Mr.;Able;Tony;216 King St;San Francisco;CA;USA
2;Mr.;Black;Tom;655 Divisadero St;San Francisco;CA;USA
3;Mr.;Kent;Richard;509 Valencia St;San Francisco;CA;USA
4;Mr.;Chen;Larry;407 Ellis St;San Francisco;CA;USA
5;Mrs.;Donaldson;Sue;314 Columbus Ave;San Francisco;CA;USA
6;Mr.;Murrell;Tony;4124 Geary Blvd;San Francisco;CA;USA

This sample project can also be downloaded.

NetBeans JPA and Hibernate Tutorial

This tutorial illustrates the usage of JPA with Hibernate as the persistence layer for a Java SE application. For this tutorial we use a PostgreSQL database. The installation of PostgreSQL and creation of the test database is not handled in this tutorial.

Start NetBeans and create a new Java project.

JPA Tutorial: Screenshot new project wizard

Name your project «JPATutorial» and deselect the «Create Main Class» checkbox. Click on «Finish» and the setup wizard creates your project. Right click the «Source Packages» note in the project explorer and select «New -> Java Package». Name the package «jpatutorial» and click «Finish».


We need some additional libraries for our project. First we need the Hibernate Core and Hibernate Entity Manager libraries. You can download this libraries from the Hibernate website. Second, we need the jdbc drivers for our PostgreSQL database system. And last, we need the JPA libraries from the Java EE 5 SDK. You can download this from the Sun website or if you have a installed Sun Java System Application Server, you can simply use the javaee.jar from this installation.

Use the NetBeans Library Manager under «Tools -> Library Manager» to create a new class library. Name the library «Hibernate-JPA» and choose «Class Libraries» as Library type.

Add the following files to the library class path:

from Hibernate Core:

from Hibernate Entity Manager:

from Java EE 5 SDK:

from PostgreSQL JDBC driver:

JPA Tutorial: Screenshot library manager

Persistence Unit

Now we create the persistence.xml file, the main configuration file for a JPA application. Right click your project in the project explorer and choose «New -> File/Folder». Select the «Persistence» category and the file type «Persistence Unit». Click next, the wizard asks about the persistence unit name, the persistence library and the database connection. So we want to use Hibernate as our persistence provider and PostgreSQL as database backend, our choices should look like this:

JPA Tutorial: Screenshot persistence unit wizard

If your database connection is not already defined you can use the «New database connection...» wizard to create it.

Leave the setting «Create» for the table generation scheme. This automatically create needed tables in the database. Use «Drop and Create» if your tables should be deleted and newly created on every program start (good for unit tests). «None» is the preffered setting for production environment and does nothing on program start.

We want to make this a swing application. So right click the package and choose «New -> JFrame Form». Type «MainUI» as class name and click finish. The wizard generates our new swing class and starts the matisse gui builder.

Entity class

JPA uses entity classes to persist information. An entity class is a simple pojo with annotations. You should always implement the Serializable interface, although it's not needed. Background: In an Java EE environment, entity objects are often transfered between an enterprise java bean and a web application. The enterprise bean lives in the ejb container and the web application in the web container. When objects are transfered between containers, they must be serializable.

Right click your «jpatutorial» package and choose «New -> File/Folder». Select «Entity Class» from the «Persistence» category and click next. Enter Address as class name and click finish.

Place the cursor above the constructor and add the following code:

  1. private String customerNo;
  2. private String lastname;
  3. private String firstname;
  4. private String street;
  5. private String postcode;
  6. private String city;

Right click in the editor window and choose «Refactor -> Encapsulate fields...» to create the getter and setter methods for our properties.

User interface

Now we need some gui components for the application. Drag and drop six JLabel and six JTextField components onto the frame.

Name the label components «customerNoLabel», «nameLabel», «firstnameLabel», «streetLabel», «postcodeLabel» and «cityLabel». Set the component text property to a corresponding value.

For the textfield components choose «customerNoText», «nameText», «firstnameText», «streetText», «postcodeText» and «cityText» as component name. Clear the text property of this components.

Drag two JButton components to the page, one named «Load» and the other named «Save». Set the name properties to «loadButton» and «saveButton».

Your frame should look like this:

JPA Tutorial: Screenshot MainUI frame

Store object

Select the Save button, right click and choose «Events -> Action -> actionPerformed». Enter the following code into the event handler:

  1. private void saveButtonActionPerformed(ActionEvent evt) {
  2. Address address = new Address();
  3. address.setCustomerNo( customerNoText.getText() );
  4. address.setLastname( lastnameText.getText() );
  5. address.setFirstname( firstnameText.getText() );
  6. address.setStreet( streetText.getText() );
  7. address.setPostcode( postcodeText.getText() );
  8. address.setCity( cityText.getText() );
  10. EntityManagerFactory emf = Persistence.createEntityManagerFactory(
  11. "JPATutorialPU" );
  12. EntityManager em = emf.createEntityManager();
  13. em.getTransaction().begin();
  15. try {
  16. em.persist( address );
  17. em.getTransaction().commit();
  18. } catch (Exception e) {
  19. System.out.println( e.getMessage() );
  20. em.getTransaction().rollback();
  21. } finally {
  22. em.close();
  23. }
  24. }

Right click in your source and select «Fix Imports» (or press ALT-SHIFT-F) to add the needed import statements to your source.

This code creates a Address object and fill it's properties from our frame. Now we create an EntityManagerFactory for our persistence unit. With this factory we can create the needed EntityManager.

To persist our Address object we use the persist method of the EntityManager.

Retrieve object

Now we want to retrieve an object from the database. Right click the load button and select «Events -> Action -> actionPerformed». Enter the following code into the event handler:

  1. private void loadButtonActionPerformed(java.awt.event.ActionEvent evt) {
  3. EntityManagerFactory emf = Persistence.createEntityManagerFactory(
  4. "JPATutorialPU" );
  5. EntityManager em = emf.createEntityManager();
  6. em.getTransaction().begin();
  8. String customerNo = JOptionPane.showInputDialog(
  9. null,
  10. "Enter customer number",
  11. "Input",
  12. JOptionPane.QUESTION_MESSAGE);
  14. try {
  15. Query query = em.createQuery(
  16. "SELECT a FROM Address a WHERE a.customerNo = :customerNo");
  17. query.setParameter(
  18. "customerNo",
  19. customerNo);
  21. Address address = (Address) query.getSingleResult();
  23. customerNoText.setText( address.getCustomerNo() );
  24. lastnameText.setText( address.getLastname() );
  25. firstnameText.setText( address.getFirstname() );
  26. streetText.setText( address.getStreet() );
  27. postcodeText.setText( address.getPostcode() );
  28. cityText.setText( address.getCity() );
  30. } catch (Exception e) {
  31. System.out.println( e.getMessage() );
  32. em.getTransaction().rollback();
  33. } finally {
  34. em.close();
  35. }
  36. }

Right click in your source and select «Fix Imports» (or press ALT-SHIFT-F) to add the needed import statements to your source. Select «javax.persistence.Query» as fully qualified Name for the Query class.

This code does the following: It asks the user about the customer number, creates a query object and sets the parameter «customerNo» to the entered value. The method «getSingleResult» of the query object returns the result object or an exception if no result was found.

The source code for this tutorial can be downloaded here.

Fill a treeview programmatically

You must build a collection of TreeNode objects and add this collection to the TreeView control. Each TreeNode object has several properties to set up the visual appearance and functionality.

Important TreeNode properties

expanded - Shows this node expaned with children
ext - Title text of the node
target - Target browser window
toolTip - Tooltip text to display
url - Hyperlink to navigate to
action - Name of method to call if user selects this node
actionListenerExpression - Expression for action listener method.

Adding icon to TreeNode

To add a icon to the TreeNode you must first create a ImageComponent. Now you can set the theme specific icon with the setIcon method. Use a constant of class ThemeImages for the icon name. Add the created ImageComponent as facet to the TreeNode.


  1. ImageComponent image = new ImageComponent();
  2. image.setIcon( TreeImages.TREE_FOLDER );
  3. treeNode.getFacets().put( treeNode.IMAGE_FACET_KEY, image );

Setting Action Expression for TreeNode

To set the Action Expression of a TreeNode you must use the method setActionExpression of the TreeNode object. This method needs a MethodExpression object as parameter.

Sample code:

  1. ExpressionFactory ef = FacesContext.
  2. getCurrentInstance().
  3. getApplication().
  4. getExpressionFactory();
  5. ELContext elContext = FacesContext.
  6. getCurrentInstance().
  7. getELContext();
  8. MethodExpression me = ef.createMethodExpression(
  9. elContext,
  10. "#{Page1.treeNode_action}",
  11. String.class, new Class[]{} );
  12. treeNode.setActionExpression( me );

JAAS with active directory authentication in a web application

This is a sample to use JAAS authentication with a windows active directory server. I use a Sun Java System Application Server, so the steps with other servers could be different.

Step 1: Defining LDAP realm

In this example you must define a LDAP realm named «ads-realm» with the following parameters:

Realm class:


directory            = ldap://
base-dn              = DC=ads,DC=domain,DC=com
search-bind-dn       = user
search-bind-password = password
search-filter        = (&(objectClass=user)(sAMAccountName=%s))
group-search-filter  = (&(objectClass=group)(member=%d))
jaas-context         = ldapRealm

You must change directory, base-dn, search-bind-dn and search-bind-password to your active directory configuration. The «search-bind-dn» and «search-bind-password» parameters are needed, because with default settings active directory doesn't allow anonymous users to browse the directory.

Step 2: Setting the following JVM Switch for refferals

The following JVM switch is needed with active directory LDAP servers:


Add this switch to your server startup script or with the admin console.

Step 3a: Basic authentication

Add the following section to your web.xml or go to Step 3b for form
based authentication.


Step 3b: Form based authentication

Add the following section to your web.xml:


Create the page /login.html with a least the following code:

    <form action="j_security_check" method="post">
      Username: <input type="text" name="j_username"><br/>
      Password: <input type="password" name="j_password"><br/>
      <input type="submit" value="Login"/>

Step 4: Adding security role to web.xml

Add at least one security role to your web.xml, in this example «userRole».


Step 5: Adding security constraint to web.xml

Now we must create a security constraint and the path to the pages we want to allow only authenticated access. In this sample the access to the folder /pages/ is resticted to authenticated users in role «userRole».


Step 6: Create role mapping between active directory group and role

Role mappings are defined in sun-web.xml for the Sun Java System Application Server, so add the following section:


This maps the active directory group «users» to our role «userRole»,
so only users in the group «users» can access our secured folder.