Creating a CRUD with JSF and Ajax using NetBeans 6.5 Beta

Pre-requisite: NetBeans 6.5 Beta, or most recent version with the “Java Web and EE” or “All” pack. The glassfish version 2 or 3 must be installed.

On this tutorial we will see how to create a CRUD application (Create, Read, Update and Delete) using the NetBeans IDE 6.5 Beta. The main features demonstred in this tutorial are: work with a web project using glassfish and Java Server Faces; create a Persistence Unit; create an Entity Class; automaticaly generate jsf pages from an Entity Class.

Let’s start, first of all go to the Services Tab (Ctrl+5), open Databases node and follow the steps bellow:

  1. Click with right button in Java DB on Start Server (Picture 1)
  2. Click again with right button in Java DB and now click on Create Database…
  3. In the next window fill all fields according to Picture 2

Picture 1 - Starting Java DB server

Picture 2 - Creating a new database in Java DB

After the database creation, so let’s go to our NetBeans project:

  1. Create a new web project (File->New project) in Java Web category, then choose the option Web Application (Picture 3)
  2. in the next window fill all the fields according with Picture 4
  3. Define the web server (recommended glassfish v2 or v3) and the context path (Picture 5)
  4. Click next and select the framework: JavaServer Faces (Picture 6)

Picture 3 - Creating a new web project

Picture 4 - Defining project name and project local

Picture 5 - Suggestions to choose the web server and your configurations

Picture 6 - Adding the framework Java Server Faces to your project

Now your project is created, to test if your project is working correctly with the web server, click with rigth button in project tab (Ctrl+1) and click Run.
Well, the next step is create a new Persistence Unit, an Entity Class, the JPA (Java Persistence API) controllers:

  1. Click in File->New File, select the Persistence category, so choose the option Persistence Unit and click next
  2. Click at the combobox arrow and select New Data Source …
  3. Type a name to jndi (eg: dsExemploJsf or dsSampleJsf), at Database Connection select the connection with the database that you created in the begin of this tutorial, click ok
  4. In Provider and Database window fill all fields according with Picture 8 and then click finish
  5. Again click File->New File, in Persistence category, select Entity Class and click next
  6. In the next window fill all fields according with Picture 9 and click finish

Picture 7 - New Persistence Unit

Picture 8 - Provider and Database

Picture 9 - Creating a new Entity class

After generating the Livro.java (or Book.java) NetBeans shold automatically open it, let’s edit this file that way:

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
 
private String isbn;
private String title;
private String author;
private Integer numberOfPages;
private Double weight;
 
public Long getId() {
return id;
}

Then put the cursor position at line imediatlly after:

public void setId(Long id) {
this.id = id;
}

then press simultaneously: alt+insert, select Getter and Setter… then select all fields and click ok.

After creation of the Entity Class, let’s go to more one netbeans wizard wich will generate all necessary code to work with JPA and JSF files, so click in File->New File, in Persistence category, choose the option: JSF Pages From Entity Classes, and follow steps:

  1. Choose Livro’s (or Book’s) Entity Classe (Picture 10)
  2. Choose the packages where will be generated the files for JPA and JSF manipulation (Picture 11), here note that the option “Ajax-enable generated pages” is displayed, this option allows generated code to use Ajax technology, remember that this is only available from version 6.5 beta or the most recent version.

Picture 10 - Select Entity Classes

Picture 11 - Select packages to JPA and JSF

Now we have all necessary code, to test our project result, build the project (type Shift+11, clean and build project) click with right button in project name by Projects tab (Ctrl+1), after click “Undeploy and Deploy” to remove the web project of server (if there is) and deploy version that you already finished building (Picture 12).

If there are no errors message at Output tab (Ctrl+4), you can run the project using F6 key and see your CRUD working wonderful. (Pictures 13 and 14)

Picture 12 - Project Undeploy and Deploy

Picture 13 - CRUD finished, inserting a new registry

Picture 14 - CRUD finished, registries overview after insert confirmation

Conclusion: It’s not recommendable the use of this wizard to generate CRUD by NetBeans for people who don’t have experience with Java Server Faces to do their production work day by day. The importance of this NetBeans feature for this public is that they have access to development step by step about the creation of a CRUD using these wonderful Java frameworks. The learning on this activity is quite satisfactory. For those who already have experience just a look at the creation process and results will teach what to do. For those who want something practical, without much detail, and that is quite fast to do, this guide is quite helpful.

Revised by Ana Lyvia Liveira.

Criando um CRUD em JSF e Ajax com o NetBeans 6.5 Beta

Pré-requisito: NetBeans 6.5 Beta, ou versão mais recente com o pacote Java Web and EE ou completo. O glassfish versão 2 ou 3 deve estar instalado.

Neste tutorial podemos ver como criar uma aplicação CRUD (Create=Criar, Read=Ler, Update=Atualizar, Delete=Excluir) utilizando o NetBeans IDE 6.5 Beta. As principais características demonstrada neste tutorial são: trabalhar com um projeto web utilizando glassfish e java server faces; criar um Persistence Unit (Unidade de Persistência); criar um Entity class (Entidade de classe); gerar automaticamente páginas jsf a partir do entity class.

Vamos começar, primeiramente vá até a aba Services (Ctrl+5), abra o nó Databases e siga os seguintes passos:

  1. clique com o botão direito em Java DB em seguida Start Server (Figura 1)
  2. clique novamente com o botão direito em Java DB agora clique em Create Database…
  3. na próxima janela preenche os campos de acordo com a Figura 2

Figura 1 - Iniciando o servidor Java DB

Figura 2 - Criando um novo banco de dados no Java DB

Agora com o banco de dados criado, vamos então para o nosso projeto no NetBeans, então:

  1. Crie um novo projeto web (File->New project) na categoria Java Web, escolha a opção Web Application (Figura 3)
  2. na janela seguinte preencha os campos de acordo com a Figura 4
  3. Defina o servidor web (recomendado o glassfish v2 ou v3) e o caminho do contexto (Figura 5)
  4. clique em next e selecione o framework: JavaServer Faces (Figura 6)

Figura 3 - Criando um novo projeto web

Figura 4 - Definindo o nome e local do projeto

Figura 5 - Sugestões para escolha do servidor web e configurações

Figura 6 - Adicionando o framework JavaServer Faces ao seu projeto

Agora seu projeto está criado, para testar se o seu projeto está funcionando corretamente com o servidor web, clique com o botão direito no projeto (janela projects – Ctrl+1) e clique em Run.
Bom, o próximo passo é criarmos um Persistence Unit, um Entity class, os controllers do JPA (Java Persistence API):

  1. clique em File->new File, selecione a categoria Persistence, então escolha a opção Persistence Unit e clique em next
  2. Vá até a setinha do combobox e selecione New Data Source…
  3. digite um nome para o jndi name (ex.: dsExemploJsf), em Database Connection selecione a conexão com o banco de dados que você criou no início deste tutorial, clique em ok
  4. na janela Provider and Database preencha os campos de acordo com a Figura 8 em seguida clique em finish
  5. Novamente clique em File->new File, na categoria Persistence, selecione Entity Class e clique em next
  6. na janela seguinte preencha os campos de acordo com a Figura 9 e clique em Finish

Figura 7 - Novo Persistence Unit

Figura 8 - Provider and Database

Figura 9 - Criando um novo Entity class

Depois de gerado o arquivo Livro.java o NetBeans abre automaticamente ele, vamos editar este arquivo para que fique da seguinte forma:

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
 
private String isbn;
private String titulo;
private String autor;
private Integer numeroPaginas;
private Double peso;
 
public Long getId() {
return id;
}

Então posicione o cursor na linha imediatamente depois de:

public void setId(Long id) {
this.id = id;
}

e pressione simultaneamente: Alt+insert, selecione Getter and Setter… selecione todos os campos e clique em ok.

Após criarmos o Entity Class, vamos para mais um wizard do netbeans o qual irá nos gerar os códigos necessários para trabalhar com JPA e os arquivos JSF, para isso vamos em File->New File, na categoria Persistence, escolha a opção: JSF Pages From Entity Classes, e siga novamente os passos:

  1. Escolha a Entity class do Livro (Figura 10)
  2. Escolha os pacotes para onde vão ficar os arquivos gerados para manipulação do JPA e JSF (Figura 11), nesta opção perceba que aparece a opção “Ajax-enable generated pages”, que fará com que o código gerado utilize tecnologia Ajax, lembrando que esta opção só está disponível a partir da versão 6.5 beta do NetBeans

Figura 10 - Selecionar Entity classes

Figura 11 - Selecionar pacotes para JPA e JSF

Pronto, agora estamos com todo o código necessário pronto, para que possamos testar o resultado do nosso projeto, construa o projeto (tecle Shift+F11, limpa e constrói o projeto) clique com o botão direito no nome do projeto pela janela Projects (Ctrl+1) em seguida clique em “Undeploy and Deploy” para remover o projeto do servidor web (se houver) e implantar a versão que você acabou de construir (Figura 12).

Se não houver nenhuma mensagem de erro na janela Output (Ctrl+4), você pode executar o projeto através da tecla F6 e ver seu CRUD funcionando bonitinho. (Figuras 13 e 14)

Figura 12 - Undeploy and Deploy (Desimplantação e implantação) do projeto

Figura 13 - CRUD pronto, criando um novo registro

Figura 14 - CRUD pronto, visão geral dos registro após confirmação de inserção do registro

Conclusão: Não é recomendável que uma pessoa que não tenha experiência com Java Server Faces utilize o assistente de geração de CRUD do NetBeans para fazer seu trabalho do dia a dia de produção, a importância dessa característica do IDE NetBeans para esse público é que tenham acesso ao desenvolvimento passo a passo da criação de um CRUD utilizando esses fantásticos frameworks para Java, o aprendizado nessa atividade é bastante satisfatório. Para quem já tem experiência basta olhar o processo de criação e os resultados e já saberá o que fazer. Para quem quer uma coisa prática, sem muito detalhe, e que seja bem rápido de fazer isso aqui é uma mão na roda.