NetBeans IDE 7 Cookbook

netbeans-cookbook

Descripción

Es un excelente libro para iniciar a trabajar con Netbeans IDE, crear proyectos, importar desde otras plataformas, crear aplicaciones de escritorio (Desktop), JDBC trabajar con bases de datos MySQL, PostgreSQL, Oracle, construir aplicaciones Web, usar JavaFX, trabajar aplicaciones EJB, desarrollar aplicaciones para móviles y usar sistemas de control de versión.

Descarga / Download

Aqui

Vea también

Tutorial de Netbeans IDE 7.2

Tutorial de Netbeans 7.2 Parte 8

En este capítulo veremos una de las características o capacidades más de Netbeans IDE 7.2, relacionada al desarrollo de aplicaciones web.

Cómo crear Aplicaciones Web con Netbeans IDE 7.2

En este tema espeíificamente veremos cómo crear un proyecto de aplicación web con Java.

Una aplicación web Java podría tratarse de una estructura más compleja, puede involucrar el uso de uno o más frameworks para agilizar su desarrollo.  Sin embargo trataremos de verlo de la manera más simple por ahora.

En este capítulo veremos:

  1. El servidor de aplicaciones web Java
  2. Crear un proyecto web con Netbeans
  3. Integrar Firefox con Netbeans
  4. Ejecutar un proyecto web con Netbeans
  5. Realizar una aplicación basada en Servlets y JSPs

El servidor de aplicaciones web Java

El Netbeans IDE, viene integrado con dos de los más populares servidores de aplicaciones Java, que son: Apache Tomcat y GlassFish Server.

Estas aplicaciones son gratuitas y de código abierto (open source).

Para realizar nuestro ejemplo trabajaremos con el servidor Apache Tomcat.

Antes de comenzar debemos saber que Apache Tomcat es un servidor de aplicaciones web y por lo tanto hace uso del protocolo de red HTTP.  Sin embargo por defecto Tomcat en Netbeans está configurado con el puerto 8084, para evitar conflictos con GlassFish Server que está configurado para usar el puerto 8080.

Para ver esta configuración.  Seleccionamos el Servidor Apache Tomcat y luego: Properties.

Esta opción nos mostrará la siguiente pantalla.

No es necesario realizar ningún cambio sí se está seguro que ninguna otra aplicación está utilizando el puerto.

Para iniciar el servidor de aplicaciones seleccionamos: Start.

Si todo pasó correctamente esta acción desplegará una consola de salida (Log) para el servidor y la vista mostrará un icono que indica que el servidor está en ejecución.

Para verificar también podemos ingresar en el navegador web la direccion: http://localhost:8084

Crear un proyecto web con Netbeans

Cómo crear un proyecto web con NetBeans IDE 7.2

Ahora que tenemos un servidor de aplicaciones web listo y en marcha, iniciaremos creaando un proyecto para una aplicación web con Netbeans.

Como vimos en un capítulo anterior, iniciamos la creación de un nuevo proyecto.  Seleccionamos: Java Web > Web Application.

Luego presionamos en: Next >, e ingresamos un nombre para el proyecto “jcodeweb” y opcionalmente seleccionamos una ubicación.

Luego presionamos en: Next >, seleccionamos el servidor de aplicaciones, la versión de Java y terminamos presionando el botón: Finish.

Finalmente tendremos un proyecto para una aplicación web lista para probar, que incluye además una página de inicio.

Antes de ejecutar la aplicación veremos cómo integrar el navegador Firefox al Netbeans, para realizar las pruebas durante el desarrollo.

Integrar Firefox con Netbeans

Para iniciar esta configuración vamos a iniciar en el menú: Tools > Options.

Nota: obviamente es necesario que se tenga instalado Firefox.  Si prefieres trabajar con otro navegador no es necesario que realices ninguna configuración, por defecto Netbeans abrirá el navegador asociado al sistema operativo.

Luego en la ventana de opciones, en la pestaña General en: Web Browser, selecciona: Firefox.

Finalmente presiona: OK y listo.

Ejecutar un proyecto web con Netbeans

Para realizar la primera prueba seleccionamos el proyecto.  Luego: Run.

Luego Netbeans construirá la aplicación, lo implementará en el servidor Tomcat y abrirá el navegador para mostrar la aplicación.

¡Felicidades!, Con esto lograste iniciar la base fundamental de cómo construir una aplicación web con Netbeans.  Como cualquier proyecto ahora puedes subirlo a un repositorio Subversion como vimos en un capítulo anterior.

Realizar una aplicación basada en Servlets y JSPs

Para construir una aplicación web más grande podemos integrar a nuestro proyecto uno o más frameworks que no es otra cosa que agregar librerias a nuestro proyecto.  Obviamente esto requerirá de una configuración adecuada para ponerla en marcha.

Si ya tienes experiencia en la programación con lenguaje Java y puedes manejar una conexión a una base de datos, puede que necesites publicar una página con tus datos o una página para un formulario de registro.  Entonces la podemos realizar rapidamente con un Servlet y un par de JSPs.

El siguiente capítulo le dedicaremos completamente a ver esto.

Ir al Inicio

Tutorial de Netbeans 7.2 Parte 7

En este capítulo vamos a ver cómo integrar bibliotecas o librerías a la plataforma Netbeans IDE 7.2 y cómo agregar una librería a un proyecto.

Apache Commons http://commons.apache.org, es sin duda el sitio de bibliotecas o librerías más popular a la cual acuden los programadores Java.  Existen diversos componentes útiles para agilizar las tareas de programación, por lo tanto Apache Commons es una fuente de librerías para integrar a nuestros proyectos.

Asi de esa manera otras organizaciones o compañías de software distribuyen con diferentes licencias, paquetes de bibliotecas o librerías para el desarrollo de software final o incluso otras librerias.

Administrar las Librerías en Netbeans

Para realizar esta tarea vamos a agregar algunos componentes descargados de Apache Commons a las librerías de Netbeans IDE, como ejemplo.

Estos archivos fueron descargados, cada uno de su sitio respectivo en Apahce Commons.  Y ahora las vamos a agregar en una librería que la llamaremos: “Apache Commons“, a las librerías de Netbeans.

El Netbeasn IDE 7.2 tiene integrado una gran variedad de librerías listas para usar.  Como por ejemplo: Hibernate, Spring, Junit, y muchos más.

Para administrar las librerías iniciamos en el menú: Tools > Ant Libraries.  Luego presionamos en: New Library…

Luego ingresamos el nombre para la Librería: “Apache Commons”, luego seleccionando en: OK.

Esto nos mostrará la librería en la lista y tan solo nos quedara agregar los archivos jar desde: Add JAR/Folder…

Finalmente la librería esta lista para ser usada en algún proyecto que requiera de la misma.

Agregar una librería a un proyecto

Ahora veamos como agregar la nueva librería a nuestro proyecto.  Seleccionamos el proyecto: Libraries > Add Librery…

Luego ubicamos y seleccionamos nuestra librería.

Finalmente el proyecto se verá de la siguiente forma.

Agregar un JAR a un Proyecto

Se puede también agregar un archivo jar a un proyecto en Netbeans sin la necesidad de integrarla al IDE.

El procedimiento es muy sencillo.  Seleccionamos: Libraries > Add JAR/Folder…

Esto nos permitirá explorar los archivos y agregarlos directamente al proyecto.

Así terminamos de ver como se administran las bibliotecas o librerías en Netbeans IDE 7.2.

Ir al Inicio

Tutorial de Netbeans 7.2 Parte 6

En este capítulo veremos más de las prestaciones que tiene integrada el Netbeans IDE 7.2.  Y en este caso sus capacidades en el manejo de Bases de Datos.

Java Database Connectivity JDBC

Java Database Connectivity, más conocida por sus siglas JDBC, es una API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java, independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto SQL del modelo de base de datos que se utilice.

Netbeans IDE 7.2 utiliza esta API para realizar operaciones sobre bases de datos.  Además cuanta con algunos controladores (Drivers) por defecto listos para usar.

Conectando con una Base de Datos

¿Cómo se conecta Netbeans con bases de datos?.  Ahora veremos cómo realizar una conexión a una base de datos MySQL desde NetBeans IDE.

Seleccionamos el controlador (Driver) para la base de datos MySQL.  Luego: Connect Using…

Seguidamente ingresamos los datos para una conexión TCP con MySQL.  Luego verificamos presionando en: Test connection.

Luego de presionar en Finish, Netbeans nos mostrará un explorador para visualizar los objetos de la base de datos, como por ejemplo: Tablas.

Operaciones sobre las tablas

El Netbeasn IDE 7.2 ahora se convierte en una herramienta muy poderosa para realizar tareas sobre bases de datos.  Selecciona el objeto: Tables y Execute Command…

Se puede también seleccionar una tabla específica y ver sus datos seleccionando: View Data…

A continuación Netbeans habilita un área de trabajo con tres componentes que son: El editor de SQL, una Grilla de datos y una Consola de salida (Log Output).

Netbeans te permitirá realizar más de una conexión a la vez a diferentes bases de datos mediante controladores (Drivers) JDBC.  Cada fabricante de bases de datos actualmente proporciona estos controladores.

Con esto concluimos de ver el tema de cómo usar Netbeans para trabajar con bases de datos.

Ir al Inicio

Tutorial de Hibernate 4 con Netbeans 7.2

En esta nueva serie vamos a conocer un componente importante en el desarrollo de sistemas de información empresariales con Java.  El Hibernate 4 ORM.

Introducción

Hibernate 4, es una librería para el Mapeo objeto-relacional (ORM) que facilita el mapeo de atributos entre una base de datos relacional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los clases de las entidades que permiten establecer estas relaciones.  Por lo tanto Hibernate vincula la aplicación con la base de datos.

Contenido

  1. Creando una base de datos MySQL
  2. Crear un proyecto en Netbeans IDE 7.2
  3. Descargar e instalar Hibernate 4 ORM
  4. Crear una clase Entidad
  5. Ejecutar tareas de persistencia

1. Creando una base de datos MySQL

Asumiendo que el motor MySQL está instalada procedemos a la creación de una base de datos “heyma” con: create database heyma;

Confirmando la operación deberíamos ver la base de datos ejecutando: show databases;

2. Crear un proyecto en Netbeans IDE 7.2

En el tutorial de Netbeans vimos como crear un proyecto de Aplicación Java.  Por lo tanto vamos a crear y tener listo un proyecto con el nombre: jcode-hibernate”

3. Descargar e instalar Hibernate 4 ORM

El sitio oficial de Hibernate es: http://www.hibernate.org.  Donde encontraremos un enlace al sitio de descargas.

Una vez allí ingresamos al enlace de: release bundles.

Esto nos llevará al sitio de Source Forge donde obtendremos gratis, una copia de Hibernate 4 ORM.

Seleccionamos el paquete: hibernate-release-4.1.7.Final.zip, (48.7 MB ) y descomprimimos el mismo en una ubicación adecuada para nuestras librerías.

Luego como vimos en el tutorial de Netbeans de cómo crear y agregar librerías creamos una librería llamada: Hibernate 4.1.7, con todos los jars del directorio: lib/required de Hibernate 4 ORM.

Con esto está instalado hibernate 4 en nuestro proyecto y listo para ser usado.

4. Crear una clase Entidad

Primero vamos a crear un paquete: model y luego una clase de entidad: Employee.

La clase: Employee.java.

package jcode.hibernate.model;

import java.sql.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 *
 * @author John
 */
@Entity
@Table(name = "EMPLOYEE")
public class Employee {

    @Id
    @GeneratedValue
    private Long id;
    @Column(name = "firstname")
    private String firstname;
    @Column(name = "lastname")
    private String lastname;
    @Column(name = "birth_date")
    private Date birthDate;
    @Column(name = "cell_phone")
    private String cellphone;

    public Employee() {
    }

    public Employee(String firstname, String lastname, Date birthdate, String phone) {
        this.firstname = firstname;
        this.lastname = lastname;
        this.birthDate = birthdate;
        this.cellphone = phone;

    }

    public Long getId() {
        return id;
    }

    public String getFirstname() {
        return firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public String getCellphone() {
        return cellphone;
    }

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

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    public void setCellphone(String cellphone) {
        this.cellphone = cellphone;
    }
}

Luego Netbeans nos ayudará a crear un archivo de configuración para Hibernate.  Esta opción ejecutaremos sobre el paquete: jcode.hibernate.  Luiego:  New > Other…

Luego seleccionamos: (Categories) Hibernate > (File Types) Hibernate Configuration Wizard.

Luego de darle en: Next >.  Establecemos el nombre y el directorio de ubicación.

Luego en el siguiente paso debemos establecer una conexión a la base de datos.

Seguidamente presionamos: Next >.

Luego de finalizar el archivo xml debe quedar como sigue.  Sera necesario aumentar unas líneas extra.

El archivo: hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/heyma</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123</property>

        <property name="show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <mapping class="jcode.hibernate.model.Employee"/>
    </session-factory>
</hibernate-configuration>

5. Ejecutar tareas de persistencia

Ahora tan solo queda probar.  Para ello utilizaremos la clase: JcodeHibernate.java, que tiene un metodo main().

La clase:  JcodeHibernate.java

package jcode.hibernate;

import jcode.hibernate.model.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

/**
 *
 * @author John
 */
public class JcodeHibernate {

    private static SessionFactory sessionFactory = null;

    public static void main(String[] args) {
        Session session = null;
        try {
            try {
                sessionFactory = PersonFactory.getSessionFactory();
                session = sessionFactory.openSession();

                System.out.println("Insertando registro");
                Transaction tx = session.beginTransaction();
                //Creando un Objeto
                Employee employe = new Employee();
                employe.setFirstname("John");
                employe.setLastname("Castillo");
                //Guardando
                session.save(employe);
                tx.commit();
                System.out.println("Finalizado...");
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        } finally {
            session.close();
        }
    }
}

Luego de ejecutar la aplicación la consola (Output) debe mostrar lo siguiente:

Verificando la base de datos.

Con esto finalizamos el tutorial de Hibernate 4 ORM.  Un componente importante en la construcción de aplicaciones o sistemas de información con Java.

La clase: PersonFactory.java

package jcode.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

/**
 *
 * @author John
 */
public class PersonFactory {

    private static ServiceRegistry serviceRegistry;
    private static final SessionFactory sessionFactory;

    static {
        try {
            Configuration configuration = new Configuration();
            configuration.configure("jcode/hibernate/hibernate.cfg.xml");
            serviceRegistry = new ServiceRegistryBuilder().applySettings(
                    configuration.getProperties()).buildServiceRegistry();
            sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        } catch (Throwable ex) {
            System.err.println("Failed to create sessionFactory object." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Tutorial de Netbeans 7.2 Parte 5

Introducción a Subversion

Subversion es un sistema de control de versiones diseñado específicamente para reemplazar al popular CVS.  Es software libre bajo una licencia de tipo Apache/BSD y se le conoce también como svn por ser el nombre de la herramienta utilizada en la línea de comandos.

Ya que este tutorial trata de mostrar de una manera práctica las prestaciones de Netbeans IDE, en este capítulo veremos: cómo se trabaja con Subversion desde Netbeans IDE 7.2.

Si no entiendes bien este tema te recomiendo saltar este capítulo y realizar una investigación a cerca de esta práctica de almacenar el código fuente en sistemas de control de versiones y estudiar específicamente Subversion.

Donde conseguir un Repositorio Subversion Gratis

Una empresa que desarrolla software puede contar con servidores que tengan instalado Subversion para almacenar el código fuente de las aplicaciones que desarrollan.

Subversion soporta diferentes Protocolos de red, sin embargo la más utilizada es HTTP y se requiere que cada usuario tenga una credencial de acceso con usuario y una clave o password.

Para este ejemplo vamos a utilizar nuestra cuenta de Google para acceder al servicio de Alojamiento de Proyectos de Google.

Este servicio se llama Google Code.  Sitio Oficial:  https://code.google.com.  Página en la que se encuentra un enlace para crear un nuevo proyecto: Create a new project.

Luego de iniciar sesión con tu cuenta de Google.  Debes llenar un pequeño formulario.

Luego que finalices con Create project veras la página del proyecto de la siguiente manera.

En la pestaña source de la página del proyecto se encuentra la dirección HTTPS del Repositorio Subversion de nuestro proyecto.  En ella podemos subir varias aplicaciones directamente desde Netbeans.

Subir un proyecto de Netbeans a Subversion

Ya sea con el repositorio anteriormente creado o el repositorio de tu propia empresa el procedimiento será siempre el mismo.

Selecciona el Proyecto, luego en el menú: Team > Subversion > Import into Repository…

A continuación ingresa la dirección de tu repositorio y los datos de tu credencial de acceso.  Si estas usando googlecode entonces los datos de tu cuenta de Google.

Luego de darle en Next >, verás la siguiente pantalla.  Se debe especificar un mensaje para la versión 1 o línea base.

Luego de darle en Next >, aparecerá nuevamente el Prompt de conexión al repositorio con: Autthentication failed.  Solo si estas utilizando googlecode.

IMPORTANTE: Google ha permitido el acceso al repositorio con nuestros datos de la cuenta.  Pero para las operaciones de commit se debe usar la clave generada por googlecode para el repositorio.

Esta clave se encuentra accediendo al enlace: googlecode.com password, en la página del repositorio en la pestaña Source.

Y el enlace nos llevará a la siguiente pantalla.

Selecciona el password generado por googlecode y pégalo en la casilla del password del Promt de Netbeans.

Si todo salío correctamente deberias ver las siguiente pantalla.

Luego de darle en Finish, Netbeans subirá todos los archivos al repositorio Subversion.

Todo lo que suceda podrás observar en la consola del IDE.

Felicidades! ahora el proyecto está instalado en un sistema de control de versiones Subversion.  Como administrador del repositorio podrás agregar a tus colegas y todos podrán trabajar en el proyecto; compartirán las clases y las interfaces.  Podrán asignarse el desarrollo de clases específicas y subirlos al repositorio en cualquier momento con la opción: Commit…

Conectarse a un Proyecto en un repositorio Subversion

Para bajar un proyecto se necesitan los mismos parámetros que en el anterior caso.  La dirección del repositorio y la credencial de acceso con un usuario y una clave o password.  Tambíen puede estar disponible el acceso anónimo, es decir, que uno puede bajar un proyecto en modo read-only.  Esto obviamente no le permitirá al usuario hacer commit de sus cambios.

Para conectarnos iniciamos en el menú.  Luego en: Team > Subversion > checkout…

luego el usuario debe completar los parametos de la conexión.

Luego de darle en: Next >.  Solo faltará decidir el directorio local donde se descargará del proyecto.

Luego de darle en Finish Netbeans preguntará si deseas abrir el Proyecto.  Presiona en: Open Project para abrirlo.

Trabajando en un Proyecto que está en Subversion

Cuando se trabaja en un proyecto que está sobre un repositorio Subversion, el editor presenta nuevas caracteristicas.

La siguiente imagen muestra que las líneas 18, 19 y 20 son nuevas.

Y que los otros usuarios no las ven aún.  Para actualizar el repositorio debe realizarse el siguiente procedimiento.

Nota: Como en cualquier editor obviamente te corresponde salvar (Ctrl + S) los cambios del archivo que estás trabajando.

Para subir los cambios al repositorio.  Selecciona la clase o paquete que trabajaste.  Luego: Subversion > Commit…

Ahora vemos el procedimiento inverso.

Cómo bajamos los cambios que otros usuarios han subido.  Seleccionamos el proyecto.  Luego en: Subversion > Update.

Con esto concluimos de ver cómo Netbeans IDE 7.2 trabaja con el sistema de control de versiónes Subversión.  El sistema más popular del mundo.

En el siguiente capítulo veremos cómo Netbeans trabaja con bases de datos como MySQL, PostgreSQL o cualquiera que tenga disponible un Driver JDBC.

Ir al Inicio

Tutorial de Netbeans 7.2 Parte 4

En este capítulo veremos más de las prestaciones que tiene Netbeans IDE 7.2.

Transcribiendo interfaces

Otra parte importante que proporciona el diseño de una aplicación en la que participaron arquitectos o analistas son las interfaces, o servicios funcionales del sistema.  Estos servicios implementan la lógica de negocio del sistema, además estas clases requerirán pruebas unitarias de funcionalidad.

Los programadores ahora deben transcribir las 3200 interfaces del sistema que se está construyendo. :D

La mayor carga de trabajo está en la transcripción de los métodos de la interfaz y muchos métodos o funciones reciben o retornan objetos de las clases entidad <Entity> del sistema.  Es por eso que todas las clases entidad ya deben estar codificadas.

Crear una interfaz

En un capítulo anterior vimos cómo crear paquetes y clases en un proyecto de aplicación Java con Netbeans.  Ahora utilizando el mismo procedimiento crearemos las interfaces dentro los paquetes que corresponda.  Según el diseño de la arquitectura del sistema.

Para ello selecciona el paquete.  Luego: New > Java Interface...

Luego de crear las interfaces ahora hay que transcribir los métodos.  Será necesario agregar los imports (Ctrl + Shift + I) correspondientes para que queden como se muestra a continuación.

Interfaz ModuloClientes.java

package org.heyma.tutorial.services;

import java.util.List;
import org.heyma.tutorial.model.Cliente;

/**
 *
 * @author John
 */
public interface ModuloClientes {

    public void registrarCliente(Cliente cliente);

    public void actualizarDatos(Cliente cliente);

    public void eliminarCliente(Cliente cliente);

    public Cliente buscarCliente(int id);

    public List listarClientes();
}

Interfaz ModuloBanco.java

package org.heyma.tutorial.services;

import org.heyma.tutorial.model.Cliente;

/**
 *
 * @author John
 */
public interface ModuloBanco {

    public void abrirCuenta(Cliente cliente);

    public void cerrarCuenta(Cliente cliente);
}

Implementación de las Interfaces

Para implementar una interfaz se debe crear una clase y agregar a continuación del nombre la instrucción implements seguido del nombre de la interfaz a implementar.  Esto requerirá el import de la Interfaz.

Esto provocará un error en la Clase referida a que se deben implementar los métodos de la Interfaz.  Ahora utilizando las opciones del editor de Netbeans vamos a generar código.

Como en el anterior capítulo vamos a utilizar la opción de: Insert code… (Alt + Insert) o seleccionando en un lugar vacío del cuerpo de la clase, es decir, entre las  llaves {  …  }.  Luego seleccionamos la opción: Implement Method…

Luego debemos seleccionar todos los métodos a menos que la Clase esté definida como Abstracta.

Luego presionamos el botón Generate, y veremos la Clase como se muestra a continuación.

package org.heyma.tutorial.services.impl;

import java.util.List;
import org.heyma.tutorial.model.Cliente;
import org.heyma.tutorial.services.ModuloClientes;

/**
 *
 * @author John
 */
public class ModuloBancoImpl implements ModuloClientes {

    @Override
    public void registrarCliente(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void actualizarDatos(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void eliminarCliente(Cliente cliente) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public Cliente buscarCliente(int id) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public List listarClientes() {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

Finalmente quedará sustituir las líneas con:

throw new UnsupportedOperationException("Not supported yet.");

Por los algoritmos o la lógica funcional.  Tarea propia de los programadores.

Nota: El uso de la programación contra interfaces ayuda de gran manera al trabajo en equipo. Por ejemplo: Hay dos clases de servicios y asignadas a distintos programadores. Cuando una clase hace la llamada a métodos de la otra clase pero ninguna clase esta implementada, él programador no necesita esperar la implementación de la clase que necesita, puede utilizar su Interfaz que ya está disponible.

Ya que este tutorial trata de cómo utilizar Netbeans IDE,  no entraremos en el tema del uso de los paradigmas y las técnicas de programación.

Formatear el código (Alt + Shift + F)

No todos los programadores transcriben el código con el mismo estilo, pero una de las opciones que tiene el editor de Netbeans, es el formateo del código.

Esta opción está seleccionando en un lugar vacío del editor.  Luego: Format o Alt + Shift + F


En el siguiente capítulo veremos como importar nuestro proyecto a un Repositorio Subversion creando una cuenta de Google para el uso de Google Code.

Ir al Inicio

Glassfish version 3.1.2: Secure Admin must be enabled to access the DAS remotely.

Cuando se instala el servidor de aplicaciones Glassfish para entornos de desarrollo o pruebas uno no se percata de que las condiciones en producción son distintas.  Pueden estar implementadas rígidas políticas de seguridad en el dominio corporativo.

El Problema

Secure Admin must be enabled to access the DAS remotely.

Esto sucede cuando el host en el que está instalado Glassfish está gestionado bajo el Servidor de Administración de Dominio (DAS) y las peticiones remotas requieren de la habilitación de Secure Admin.

La solución

Para habilitar ejecutamos desde la linea de comandos en: ../glassfish/bin

asadmin --host [host] --port [port] enable-secure-admin

Importante

Después de la ejecución del comando se necesita reiniciar para que entre en vigor.

Rollback, Deshacer

Para deshabilitar nuevamente debemos ejecutar.

asadmin --host [host] --port [port] disable-secure-admin

Tutorial de Netbeans 7.2 Parte 3

El Editor de Netbeans IDE 7.2

En este capítulo veremos las prestaciones más importantes del Editor de Netbeans IDE.  Sobre todo para agilizar las tareas más rutinarias en la práctica real en el desarrollo de aplicaciones Java.

En este capítulo veremos:

  • Codificación de clases
  • Resolver Importaciones (imports)
  • Los Getters y Setters

Codificación de clases

El diseño del sistema genera el primer trabajo de los programadores:  Construir la arquitectura del sistema.  Todos los paquetes, clases e interfaces deben ser creados.

Antes de codificar el cuerpo de las clases es bueno iniciar por la estructura de paquetes y luego crear las 2027 clases del sistema :D.

En el capítulo anterior vimos cómo crear paquetes y clases dentro de un proyecto en Netbeans.  Ahora codificaremos el cuerpo la una clase <Entity> Persona, mientras vemos algunas de las prestaciones del Editor de Netbeans.

Luego de crear la clase Persona el Editor nos mostrara lo siguiente

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.heyma.tutorial.model;

/**
 *
 * @author John
 */
public class Persona {

}

La mayor carga de trabajo en el desarrollo de las clases tipo entidad está en la transcripción de las propiedades, sin embargo es bastante sencillo y no es necesario un test funcional.

Transcribiendo las propiedades de la clase Persona.

En este caso ha generado errores y el icono en la barra de numeración lo indica.  Si no eres un principiante de programación en Java sabes que son las importaciones de Date y List lo que hace falta.

Resolver Importaciones (imports) Ctrl + Shift + I

Para resolver el error de dependencias o imports la opción se encuentra en el menú: Source > Fix imports ó Ctrl + Shift + I.  Pero la manera más ágil antes que una combinación de teclas es de la siguiente forma: seleccionar dentro el editor señalando un lugar vacío y luego la opción: Fix imports.

Si se encuentran ambigüedades Netbeans mostrará el siguiente cuadro para seleccionar las Clases Correctas.

Otra Opción está en seleccionar el icono que además de mostrar el error tiene una sugerencia.

Luego las importaciones se agregarán al código y los errores en la barra de numeración desaparece.

Finalmente este tipo de clases <Entidad> debe encapsular sus propiedades, usar métodos para asignar u obtener valores.  Estos métodos se llaman: Getters y Setters.

Los Getters y Setters – Alt+Insert

Para ello seleccionamos dentro el editor señalando un lugar vacóo a continuación de la última propiedad y luego la opción: Insert Code… ó Alt + Insert.

Según los requerimientos selecciona las propiedades que tendrán Getter y Setter y luego presiona en el botón Generate.

Con esto gran parte de código se habrá generado sin mucho esfuerzo.

La mayor parte de las opciones que tiene Netbeans están basadas en estándares y paradigmas de Programación.

En el siguiente capítulo veremos cómo crear interfaces y clases de implementación y agilizar este trabajo con Netbeans IDE 7.2.

Ir al Inicio

Tutorial de Netbeans 7.2 Parte 2

El objetivo de este tutorial es de mostrar cómo trabajar con Netbeans IDE 7.2 orientado a las tareas de programación con lenguaje Java.

En este capítulo vamos a ver.

  1. Crear un proyecto de aplicación Java con Netbeans
  2. Ejecutar una aplicación Java con Netbeans
  3. Creación de Paquetes y Clases

Y aplicar el estándar de codificación Java.  Este estándar define como nombrar los paquetes, clases, propiedades o atributos, constantes,  métodos o funciones.

Ya que este tutorial trata de ilustrar el manejo y mostrar las prestaciones de Netbeans IDE 7.2, este tema del estándar de codificación no será tratado aquí, sin embargo todos los ejemplos seguirán disciplinadamente este estándar.

Crear un proyecto de aplicación Java con Netbeans

¡NetBeans IDE 7.2 iniciado y corriendo!

Para crear un proyecto iniciamos en el menú seleccionando en: File > New Project…

Luego veremos un cuadro con una amplia colección de tipos de proyectos organizados por categorias.  Seleccionamos: Java > Java Application.

Luego le damos en: Next >, y veremos el siguiente cuadro donde ingresaremos un nombre para el proyecto.

Nota: La creación de un proyecto Java en Netbeans trae seleccionado por defecto la opción: Create Main Class, esto creará un paquete y una clase que contiene la función especial de Java llamado main(), el cual hace que la clase sea ejecutable.

Luego de darle en: Finish el proyecto “tutorial” quedará listo parar trabajar.

Inicialmente podrás notar dos elementos importantes del IDE, que son:

  • El explorador de Proyectos
  • El Editor de Código

Ejecutar una aplicación Java con Netbeans

Agregando 1 línea en la Clase Turorial.java, generado por Netbeans quedaría así.

    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println("Hola mundo...");
    }

Ahora hay varias formas de ejecutar el proyecto con Netbeans.

Primera forma, seleccionamos el proyecto, y la opción Run.

Segunda forma, seleccionamos el proyecto y luego en el botón Run de la barra de herramientas.

Ahora veremos un tercer elemento importante de Netbeans IDE que es:

  • La consola de salida de Java (Output)

La consola de salida (Output) es donde veremos el resultado de la ejecución del Proyecto.

Creación de Paquetes y Clases

Los paquetes, el estándar de nombrado de paquetes dice que se utilicen únicamente minúsculas y además utilizar como raíz el nombre del proyecto, en nuestro caso “tutorial”.

Es posible que el proyecto sea parte de una compañía u organización, en este caso se puede anteponer el nombre del dominio, como por ejemplo:

  • org.heyma.tutorial
  • com.google.tutorial

Nota: La estructura de paquetes es simplemente una estructura de directorios de archivos, por lo tanto, la estructura “com/google/proyecto” en java se escribirá “com.google.proyecto”.

En nuestro proyecto tenemos el paquete “tutorial” y vamos a anteponer el nombre de dominio de nuestra organización.

Seleccionamos el paquete “tutorial”, luego: Refactor > Rename…

Cambiamos de “tutorial” a“org.heyma.tutorial” tal como se muestra en la siguiente imagen.

Para agregar paquetes tan solo seleccionamos el paquete raíz.  Seleccionar: New > Java Package… Colocar el nombre siguiendo la regla de ingresar en minúsculas únicamente y listo.

Las Clases, se nombran utilizando el patrón “PascalCase“, como por ejemplo: Persona, ServiciosCliente, ControladorDePagos, etc.  Inician siempre con la primera letra en mayúscula.

Para agregar clases se procede igual a los paquetes.  Seleccionar paquete: New > Java Class…  Nombrar como especifica la regla y listo.

Con esto finalizamos este capítulo.  En los siguientes veremos muchas más prestaciones que tiene el Netbeans IDE 7.2.

Ir al Inicio