Bitsmi Blog
Weblogic – Doble despliegue de una aplicación J2EE
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.
OCP7 06 – Genéricos y colecciones – Introducción
OCP7 09 – Pricipios básicos de E/S
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)
- Clase InputStream (Bytes)
- 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)
- Clase OutputStream (Bytes)
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);
// ...
}
OCP7 12 – Conexión JDBC en Java 7
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).
OCP7 08 – Excepciones (I)
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");
}
}
}
OCP7 02 – Diseño de una clase Java
OCP7 03 – Diseño de una clase Java
En este apartado se introducen conceptos relacionados con el diseño de una clase.
OCP7 05 – Herencia en las interfaces Java
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.
OCP7 13 – Localización
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.
OCP7 11 – Hilos (01) – Introducción
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.