Bitsmi Blog

Weblogic – Doble despliegue de una aplicación J2EE

09-07-2014 - Xavier Salvador

Al trabajar con Weblogic y Eclipse, muchas veces da la impresión de que las aplicaciones se despliegan dos veces.

  • Una junto al arranque del servidor y, una vez éste está arrancada, vuelve a hacer el deploy correspondiente.
  • Parece ser que el problema está en la carpeta tmp del server que no se borra durante los reinicios del servidor.

NOTA: Todos los cambios que se detallan a continuación han sido realizado en Windows 8.

Para solucionarlo se puede modificar el script de arranque de startWebLogic.cmd añadiendo la instrucción rd de MS-DOS para borrar la carpeta tmp antes de iniciar el servidor.

La modificación quedaria de este modo:

@ECHO OFF 
@REM WARNING: This file is created by the Configuration Wizard. 
@REM Any changes to this script may be lost when adding extensions to this configuration. 
SETLOCAL 
set DOMAIN_HOME=C:OracleMiddlewareuser_projectsdomainscomercio_domain 
@REM Borrar tmp 
rd /S /Q %DOMAIN_HOME%serversAdminServertmp 
call "%DOMAIN_HOME%binstartWebLogic.cmd" %* 
ENDLOCAL

La modificación del fichero de arranque se ha producido mediante el servidor Bea Weblogic en su versión 9.2 MP4.

NOTA: Se pueden aplicar dichos cambios también en los ficheros de arranque de Linux (extensión .sh) o de otros sistemas operativos. El principio de eliminación de la carpeta temporal sirve independientemente de cuál sea el sistema operativo.

more…

OCP7 06 – Genéricos y colecciones – Introducción

04-07-2014 - Xavier Salvador

more…

OCP7 09 – Pricipios básicos de E/S

03-07-2014 - Xavier Salvador

Streams

El término define una corriente de datos de una fuente a un destino.

Todos los datos fluyen a través de un ordenador desde una entrada (fuente) hacia una salida (destino).

Los fuentes y destinos de datos son nodos de los flujos en la comunicación del ordenador. Todos los flujos presentan el mismo modelo a todos los programas Java que los utilizan:

  • flujo de entrada: para leer secuencialmente datos desde una fuente (un archivo, un teclado por ejemplo). Llamado también como input stream.
  • flujo de salida: para escribir secuencialmente datos a un destino (una pantalla, archivo, etc). Llamado también como outputstream. Estos nodos pueden ser representados por una fuente de datos, un programa, un flujo, etc..

Flujos de Datos (Bytes y carácteres)

La tecnología Java admite dos tipos de datos en los flujos: bytes y carácteres.

En el lenguaje Java los flujos de datos se detallan mediante clases que forman jerarquías según sea el tipo de dato char Unicode de 16 bits o byte de 8 bits.

A su vez, las clases se agrupan en jerarquías según sea su función de lectura (Read) o de escritura (Write).

La mayoría de las clases que se utilizan con Streams se encuentran ubicadas en el paquete java.io. En la cabecera del código fuente debe escribirse el importe del paquete import java.io.*;

  • Métodos básicos de lectura de Streams
    • Clase InputStream (Bytes)
      • int read()
      • int read(byte[] buffer)
      • int read(byte[] buffer, int offset, int length)
    • Clase Reader (Caracteres)
      • int read()
      • int read(char[] buffer)
      • int read(char[] buffer, int offset, int length)
  • Métodos básicos de escritura de Streams
    • Clase OutputStream (Bytes)
      • void write(int c)
      • void write(byte[] buffer)
      • void write(byte[] buffer, int offset, int length)
    • Clase Writer (Caracteres)
      • void write(int c)
      • void write(char[] buffer)
      • void write(char[] buffer, int offset, int length)
      • void write(String string)
      • void write(String string, int offset, int length)

Lectura/escritura en ficheros

Los tipos fundamentales de nodos o elementos a los que puede entrar y salir un flujo de datos que se pueden encontrar en el JDK 1.7 de Java son los siguientes:

Todos los flujos deben cerrarse una vez haya finalizado su uso, forzando un close dentro de la cláusula finally.

Flujos en Memoria Intermedia

Para la lectura de archivos cortos de texto es mejor utilizar FileInputStream en conjunción con FileReader. A continuación se añaden algunos ejemplos con código fuente para la memoria intermedia.

Ejemplo TestBufferedStreams

package bufferedstreams;
 
import java.io.*;
 
public class TestBufferedStreams {
 
    public static void main(String[] args) {
        try (
           BufferedReader bufInput = 
       new BufferedReader(new FileReader("src\bufferedstreams\file1.txt"));
           BufferedWriter bufOutput = 
       new BufferedWriter(new FileWriter("src\bufferedstreams\file2.txt"))
        ){
            String line = bufInput.readLine();
            while (line != null) {
                
                bufOutput.write(line, 0, line.length());
                bufOutput.newLine();               
                line = bufInput.readLine();                
            }
        } catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }
}

Ejemplo TestCharactersStreams

package bufferedstreams;
 
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class TestCharactersStreams {
 
    public static void main(String[] args) {
        try (FileReader input = new FileReader("src\bufferedstreams\file1.txt");
             FileWriter output = new FileWriter("src\bufferedstreams\file2.txt")) {
 
            int charsRead;
            while ((charsRead = input.read()) != -1) {
                output.write(charsRead);
            }
        } catch (IOException e) {
            System.out.println("IOException: " + e);
        }
    }
}

Entrada y salida estándar

Existen en Java 7 tres flujos estándar principales:

  • System.in. Campo estático de entrada de tipo InputStream lo que permite leer desde la entrada estándar.
  • System.out. Campo estático de salida de tipo PrintStream lo que permite escribir en la salida estándar.
  • System.err. Campo estático de salida de tipo PrintStream lo que permite escribir en el error estándar.

A continuación se indican los métodos principales print y println de la clase PrintStream

  • Métodos print con parámetros distintos
    • void print(boolean b) void print(char c) void print(char[] s) void print(double d) void print(float f) void print(int i) void print(long l) void print(Object obj) void print(String s)
  • Métodos println con parámetros distintos void println() void println(boolean x) void println(char x) void println(char[] x) void println(double x) void println(float x) void println(int x) void println(long x) void println(Object x) void println(String x)

Ambos métodos son métodos sobrecargados de la clase PrintStream. A continuación se añade un ejemplo con código fuente para la entrada y salida estándar.

Ejemplo KeyboardInput

import java.io.*;
 
public class KeyboardInput {
 
    public static void main(String[] args) {
 
        try (BufferedReader in = new BufferedReader(new InputStreamReader(System.in))) {
            String s = "";
            while (s != null) {
                System.out.print("Type xyz to exit: ");
                s = in.readLine().trim();                
                System.out.println("Read: " + s);
                System.out.println("");
 
                if (s.equals("xyz")) {
                    System.exit(0);
                }
            }
        } catch (IOException e) {
            System.out.println("Exception: " + e);
        }
    }
}

Persistencia

La persistencia consiste en el proceso de serialización (secuencia de bytes) y la deserialización (reconstrucción del objeto obteniendo una copia a partir de los bytes) de un objeto en Java.

Un objeto tiene capacidad de persistencia cuándo puede almacenarse en disco o mediante cualquier otro dispositivo de almacenamiento o enviado a otra máquina y mantener su estado actual correctamente.

Dentro de una aplicación Java, cualquier clase que quiera ser serializada debe implementar la interfaz java.io.Serializable, marcador utilizado para indicar que la clase puede ser serializada.

Puede producirse la excepción NotSerializableException cuándo un objeto no se puede serializar.

Los campos marcados con los modificadores static o transient no pueden ser serializados por lo que al deserializar un objeto dichos campos apuntaran a un valor nulo o cero al finalizar la reconstrucción del objeto. A continuación se añade un ejemplo con código fuente para obtener la persistencia de los datos de un estudiante. Se incluyen la definición del objeto Student, y las clases para la persistencia junto a la clase de ejecución.

Ejemplo DeserializeMyClass

package persistence;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
 
public class DeserializeMyClass {
 
    public static void main(String[] args) {
         
        MyClass myclass = null;
         
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("file1.ser"))) {
            myclass = (MyClass) in.readObject();
             
        } catch (ClassNotFoundException | IOException e) {
            System.out.println("Exception deserializing file1.ser: " + e);
        }
        System.out.println("a = " + myclass.a);
        System.out.println("b = " + myclass.b);
        System.out.println("cad1 = " + myclass.getCad1());
        System.out.println("cad2 = " + myclass.getCad2());
    }
}

Ejemplo MyClass

package persistence;
 
import java.io.Serializable;
 
public class MyClass implements Serializable {
 
    public int a = 0;
    private String cad1 = "";
    static int b = 0;    
    private transient String cad2 = "";
    Student student = new Student();
 
    public String getCad1() {
        return cad1;
    }
 
    public void setCad1(String cad1) {
        this.cad1 = cad1;
    }
 
    public String getCad2() {
        return cad2;
    }
 
    public void setCad2(String cad2) {
        this.cad2 = cad2;
    }
}

Ejemplo SerializeMyClass

package persistence;
 
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
 
public class SerializeMyClass {
 
    public static void main(String[] args) {
         
        MyClass myclass = new MyClass();
        myclass.a = 100;
        myclass.b = 200;
        myclass.setCad1("Hello World");
        myclass.setCad2("Hello student");
 
        try (ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("file1.ser"))) {
            o.writeObject(myclass);
             
        } catch (IOException e) {
            System.out.println("Exception serializing file1.ser: " + e);
        }
    }
}

Ejemplo Student

package persistence;
 
public class Student {
 
    String name = "Darío";
    int age = 3;
}

Recordatorio

Las clases BufferedReader y BufferedWriter aumentan la eficacia de las operaciones de entrada y salida. Estas clases permiten gestionar el búfer y escribir o leer línea por línea. A continuación se añade un ejemplo sencillo utilizando un BufferedReader para leer la cadena xyz y finalizar la ejecución.1.-Ejemplo utilizando BufferedReader

try (BufferedReader in = new BufferedReader(
  new InputStreamReader(system.in)))) {
   String s = "";
   System.out.print("Type xyz to exit");
   s = in.readline().trim();
   System.out.print("Read "+s);
 
   // ...
}

more…

OCP7 12 – Conexión JDBC en Java 7

03-07-2014 - Xavier Salvador

Introducción

JDBC (Java Database Connectivity) es un acrónimo que identifica la API mediante la cuál las aplicaciones Java pueden conectarse a sistemas gestores de bases de datos (BBDD). Esta conexión se obtiene por la utilización de interfícies de conexión llamadas controladores JDBC (o conocidos también como drivers). Estas bases de datos acostumbran a ser en general relacionales, aunque también existen otros drivers para otros tipos de BBDD (nosql, ficheros planos, hojas de cálculo, etc).

more…

OCP7 08 – Excepciones (I)

03-07-2014 - Antonio Archilla

Tipos de Excepciones

Excepciones comprobadas (checked).

Representan errores producidos durante la ejecución de un programa por condiciones inválidas en el flujo esperado. Estos errores pueden ser previsibles o esperables y por eso se puede definir un flujo alternativo para tratarlos. Es el caso, por ejemplo, de errores de conexión de red, errores en la localización de ficheros, conexión a base de datos, etc. En estos casos, se puede aplicar una política de re-intentos o bien informar al usuario del error de forma controlada si se trata de un entorno interactivo.

Los métodos están obligados a tratar de alguna manera las excepciones de este tipo producidas en su implementación, ya sea relanzándolas, apilándolas o tratándolas mediante un bloque try/catch.

Exception y subclases, excepto RuntimeException y subclases.

Excepciones no comprobadas (unchecked).

Representan errores producidos durante la ejecución de un programa de los que no se espera una posible recuperación o no se pueden tratar. Se incluyen entre estos casos errores aritméticos, cómo divisiones entre cero, excepciones en el tratamiento de punteros, cómo el acceso a referencias nulas (NullPointerException) u errores en el tratamiento de índices, cómo por ejemplo el acceso a un índice incorrecto de un array.

Este tipo de errores pueden ocurrir en cualquier lugar de la aplicación y no se requiere su especificación en la firma de los métodos correspondientes o su tratamiento a través de bloques try/catch (aunque es posible hacerlo) lo que facilita a la legibilidad del código.

RuntimeException, Error y subclases de éstas.

En concreto la excepción no comprobada Error representa errores producidos por condiciones anormales en la ejecución de una aplicación que nunca deberían darse. En su mayoría se trata de errores no recuperables y por esta razón, este tipo de excepciones no extienden de Exception y si de Throwable con el propósito que no sean capturadas accidentalmente por ningún bloque try/catch que pueda impedir la finalización de la ejecución. A nivel de compilación, estos se tratan de igual forma que las excepciones no comprobadas, por lo que no hay la obligación de declarar su lanzamiento en las firmas de los métodos.

Ejemplos:

  • VirtualMachineError: Indica que se ha producido un error que impide a la máquina virtual seguir con la ejecución, sea porque se ha roto o porque no puede conseguir los recursos necesarios para hacerlo, cómo por ejemplo, por falta de memoria (OutOfMemoryError), porque se haya producido un desborde de la pila (StackOverflowError) o porque se haya producido un error interno (InternalError).
  • LinkageError: Indica incompatibilidades con una dependencia (clase) que ha sido modificada después de la compilación.
  • AssertionError: Indica un error en una aserción.

Jerarquía de Excepciones

La jerarquía de las excepciones en Java 7 puede visualizarse en el siguiente esquema:

La superclase de todas las excepciones es Throwable.

La clase Exception sirve como superclase para crear excepciones de propósito específico, es decir, adaptado a nuestras necesidades.

La clase Error está relacionada con errores de compilación, del sistema o de la JVM. Normalmente estos errores son irrecuperables.

RuntimeException (Excepciones Implícitas): Excepciones muy frecuentes relacionadas con errores de programación. Existen pocas posibilidades también de recuperar situaciones anómalas de este tipo.

Lanzamiento de Excepciones

Para el lanzamiento de una excepción debe ejecutarse el siguiente código:

//  Crear una excepcion
MyException me = new MyException("Myexception message");
 
//  Lanzamiento de la excepción
throw me;

Bloque try-catch

El bloque que puede lanzar una excepción se coloca dentro de un bloque try. Se escribe un bloque catch para cada excepción que se quiera capturar. Ambos bloques se encuentran ligados en ejecución por lo que no debe existir una separación entre ellos formando una estructura try-catch conjunta e indivisible. Pueden asociarse varios bloques catch a un mismo bloque try.

import java.util.*;
 
public class ExTryCatch {
 public static void main(String[] args){
   
  int i=-3;
   
  try{
   String[] array = new String[i];
   System.out.println("Message1");
  }
   
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
   
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
   
  System.out.println("Message2");
   
 }
}

Bloque Finally

Cuándo se agrupan excepciones al acceder a uno de los catch el resto de catch no se ejecutarán y puede provocar un error en la liberación de recursos utilizados en un programa. Java cuenta con un mecanismo para evitar esto de forma consistente en el bloque de código finally el cuál siempre se ejecuta.

import java.util.*;
 
public class ExFinally {
 public static void main(String[] args){
   
  int i=5;
   
  try{
   String[] array = new String[i];
  }
   
  catch(NegativeArraySizeException e){
   System.out.println("Exception1");
  }
   
  catch(IllegalArgumentException  e){
   System.out.println("Exception2");
  }
   
  finally{
   System.out.println("This always executes");
  } 
 }
}

more…

OCP7 02 – Diseño de una clase Java

01-07-2014 - Xavier Salvador

more…

OCP7 03 – Diseño de una clase Java

01-07-2014 - Antonio Archilla

En este apartado se introducen conceptos relacionados con el diseño de una clase.

more…

OCP7 05 – Herencia en las interfaces Java

01-07-2014 - Xavier Salvador

Uso de las interfaces Java

Una interfaz representa una alternativa a la herencia multiple de objetos. Son similares a las clases abstractas ya que contienen únicamente métodos públicos y abstractos. Ninguno de sus métodos pueden ser implementados (ni siquiera con un conjunto vacío de llaves). La declaración de una interfaz es similar a la declaración de una clase. Se usa la palabra reservada interface. Para la implementación de una interface se añade implements a la clase que implementa la interfaz. Una interfaz puede utilizarse como un tipo de referencia. Puede utilizarse el operador instanceof con las interfaces para detectar si un objeto es del tipo de referencia indicado por la interfície implementada. Interfaces de Marcador: definen un tipo concreto pero no describen los métodos que deben ser implementados por una clase, sólo sirven para la comprobación de tipos.

Existen dos tipos:

  • java.io.Serializable és una interfaz de marcador utilizado por la biblioteca de E/S de Java para determinar si un objeto puede tener su estado serializado.

Como convertir de un tipo de dato al tipo de la interfaz

Antes de generar una excepción en la conversión de tipos de unos objetos a otros objetos se comprueba que dicha conversión sea posible mediante la utilización del operador instanceof (ya comentado anteriormente).

En general, cuándo se utilicen referencias, éstas deben utilizar el tipo más genérico posible, es decir, que sirvan para cualquier tipo de interfaz o clase padre. Así la referencia no se vincula a una clase particular.

Una clase puede heredar de una clase padre e implementar una o varias interfaces pero siempre en este orden: primero hereda – extends – y después implementa – implements – separando las interfaces mediante comas.

Una interfaz puede heredar de otra interfaz. Java no permite la herencia múltiple de clases pero sí la herencia múltiple de interfaces:

Si escribimos una clase que hereda de una clase que implementa una interfaz, entonces la clase que estamos escribiendo hereda también de dicha interfaz. La refactorización consiste en realizar modificaciones en el código para mejorar su estructura interna sin alterar su comportamiento externo.

Composición

Este patrón de diseño permite la creación de objetos más complejos a partir de objetos más simples. Se crea una nueva clase con referencias a otras clases. A esta nueva clase le agregaremos los mismos métodos que tienen las demás clases.

public class ComplexClass {
    private Single1 c1 = new Single1();
    private Single2 c2 = new Single2();
    private Single3 c3 = new Single3();
}

Referencia al polimorfismo

Vamos a describir un ejemplo de polimorfismo. Si existe una clase nueva llamada Hombre que dispone de un método addCoche con la configuración de clases establecida en la siguiente imagen:

No se le puede pasar como argumento al método addCoche de Hombre cualquier tipo de coche. Solución: Para soportar el polimorfismo en las composiciones cada clase usada en la composición debe disponer de una interfaz definida y así se le podrá pasar cualquier tipo de coche al método en cuestión.

more…

OCP7 13 – Localización

01-07-2014 - Xavier Salvador

Localización

La localización o regionalización es el proceso mediante el cual un producto internacionalizado se configura para una determinada región, aprovechando las opciones que la internacionalización previa de este producto ha permitido (i18n). Por ejemplo, la internacionalización puede permitir utilizar distintos formatos de fecha, y la localización consiste en escoger el adecuado para una región específica.

more…

OCP7 11 – Hilos (01) – Introducción

20-06-2014 - Antonio Archilla

En este apartado se exponen los conceptos básicos referentes del diseño de programas concurrentes y paralelos y los mecanismos que la especificación estándar de Java pone a disposición del programador para conseguirlo.

Se tratarán los siguientes conceptos:

  • Cómo el sistema operativo gestiona los procesos e hilos.
  • Ciclo de vida de un hilo de ejecución.
  • Sincronización y comunicación de datos entre hilos de ejecución.

more…

results matching ""

    No results matching ""