Datos simples, declaración y conversión

1 comentarios

Todo lenguaje de programación consta de elementos específicos que le permite realizar las operaciones básicas de la programación.
  • Tipos de datos
  • Operadores
  • Instrucciones o sentencias

Categorías de tipos de datos

Los tipos de datos en Java se pueden dividir en tres grupos.

De acuerdo con el tipo de información que representa. Dependiendo del tipo se podrán realizar unas acciones u otras.
  • Datos de tipo primitivo.
  • Variables referencia (variables array, clase/instacia, interface…)
Según se pueda modificar la variable en tiempo de ejecución.
  • Variables: El valor asociado puede ser modificado por el mismo programa durante el tiempo de ejecución
  • Constantes o variables finales: El valor permanecerá inmutable durante toda la ejecución del programa.
Según el lugar de declaración.
  • Variables miembro: Definida dentro de la clase y fuera de los métodos.
  • Variables locales: Se definen dentro de un método.

Tipos de dato  primitivos en Java

En Java prácticamente todo se realiza mediante objetos, de todas maneras, existen algunas excepciones en las que se tiene que trabajar con el mínimo de memoria posible. En estos casos se utilizan datos primitivos tales como int, char, byte, etc… los cuales tienen un tratamiento especial.
A diferencia de sus representaciones como objetos los tipos primitivos no aceptan el estado ‘null’ por lo que siempre se inicializan con un dato por defecto.

A partir de los datos primitivos se puede trabajar con estructuras de tipos de datos compuestos como podrían ser los Arrays, clases e interficies.

Literales

Los literales son la representación escrita en el código fuente de un valor fijo determinado.
Las constantes de tipo booleana son, tal y como hemos visto, ‘false’ por defecto o ‘true’.
Las constantes de tipo carácter (char) se declaran entre comilla simple, de esta manera le estamos indicando al compilador, que nos interesa, literalmente, lo que tenemos dentro de estas comillas, si bien esto nos sirve con la gran mayoría de caracteres alfanuméricos y símbolos de puntuación o especiales, hay un grupo de caracteres que necesitan de un tratamiento especial, para ello se utiliza la denominada secuencia de escape, la contra barra. Por ejemplo, no es lo mismo asignar ‘t’ que asignar \t con el primero mostraríamos una t por consola, con el segundo mostraríamos una tabulación, otra manera de cargar los caracteres seria a través de octales o de códigos Unicode. En la página Unicode-Table.com (Actualmente es (◕‿◕) SYMBL) tenéis todas las combinaciones posibles de códigos Unicode y en la pagina UTF8-CharTable.DE  si seleccionáis “display Octal” podréis ver la comparativa entre Unicode y Octal, esta segunda página es más ligera, pero más compleja de usar si no se sabe lo que se busca. A continuación pongo los caracteres normalmente más usados.

Esto nos lleva a una singularidad, que si bien este no es su momento, viene al caso explicarlo, el caso de los String. Los Strings pueden ser considerados como cadena de caracteres y tal y como se ha explicado hay ciertos caracteres especiales que no se pueden escribir de manera normal. En el caso de los String a la hora de asignar se realiza con las dobles comillas (“”) de tal manera que si queremos escribir una comilla doble tendremos que hacer uso de la secuencia de escape, de esta manera la frase (el “nunca” cogió el coche) quedaría como (“el \”nunca\” cogió el coche”). Basándonos en este principio podemos utilizar cualquier secuencia de escape.
Las constantes enteras se pueden declarar como binarios,  octales, decimales o hexadecimales, si el primer digito del numero que se asigna es un ‘0 ‘ se entiende que se trata de un Octal, en la siguiente tabla vienen explicadas todas las opciones.

Las constantes reales o de coma flotante se expresan con coma decimal y opcionalmente seguidos de un exponente. Por defecto cuando se declaran son doublé, pero lo podemos modificar finalizando la declaración con una ‘f’ o ‘F’.

Desde Java 7 en los numéricos pueden aparecer caracteres de subrayado para facilitar la lectura del número, digamos que queremos declarar de manera constante una tarjeta de crédito , si ponemos todos los dígitos seguidos puede resultar difícil de leer, además las tarjetas de crédito ya tienen una separación lógica, de manera que si queremos podemos declarar un entero long tarjeta = 1234_5678_9012_3456L; y se lee mejor.

Declaración de variables

Una variable es un espacio de memoria correspondiente a un dato cuyo valor se puede modificar en tiempo de ejecución. Toda variable tiene que tener un tipo de dato y un identificador con el que poder referenciarlo. El tipo de dato indicara a Java el espacio de memoria que se tiene que reservar en memoria, los diferentes valores que puede tomar la variable y las operaciones que con ella se puede realizar.
El identificador elegido no puede coincidir con ninguna de las palabras reservadas, además debería seguir las convenciones que todos los programadores intentamos seguir.
·         La variable comienza por minúsculas: mes, clave, nombre…
·         Si el identificador es una palabra compuesta el resto de palabras van juntas y la primera letra en mayúsculas: esDivisible, numeroTarjeta, telefonoMovil
·         El carácter de subrayado puede ser usado en cualquier lugar del identificador, no obstante es aconsejable usarlo únicamente como separador de palabras en las constantes: CARGA_MAXIMA, CARGA_MINIMA,..
En el momento de declaración de las variables podemos declarar primero todas las variables y luego inicializarlas o inicializarlas según las vamos declarando.
Además podemos declarar más de una variable en la misma línea.
int n;
double x = 12.5, y = 2.0;
Pero en el caso de las constantes es aconsejable inicializarlos siempre. Al ser un ‘final’ lo que le estamos indicando es que una vez inicializado no se va a variar nunca, pero no podemos esperar a un método para poner el valor, en el mismo momento en el que se carga la clase contenedora se tiene que cargar el valor de esa variable o nos encontraremos un error en tiempo de ejecución, de esta manera si queremos que este valor se base en una decisión tenemos que ponerlo en el constructor de la clase y recordar que su valor no se va a modificar en toda la ejecución del programa.
La asignación de valor se puede posponer en el código, aunque en ningún caso su valor puede modificarse una vez ha sido inicializada ya que se generaría un error. Ejemplo de inicialización posterior a la declaración de la constante:
final int MAXIMO;
...
MAXIMO = 15;
Puede parecer que solo se inicializa una vez, pero recordemos que un tipo primitivo siempre se inicializa con un valor por defecto.
Además de estas reglas de inicialización también hay que seguir un convenio a la hora de elegir el nombre que le vamos a poner a nuestra constantes
·         Los identificadores siempre se escriben en mayúsculas. MAXIMO.
·         El carácter de subrayado es aceptable en cualquier lugar del identificador, pero es recomendable solo usarlo para separar las palabras: MAXIMO_VALOR.

Conversión entre tipos de datos

Excepto para los booleanos que no pueden ser transformados a otro tipo de dato, para el resto de tipos de datos existen dos categorías de conversión.
·         Ensanchamiento o promoción.
·         Estrechamiento o contracción.
Las promociones transforman un dato de un tipo a otro con un espacio de memoria mayor para almacenar información. En estos casos podríamos tener una pérdida de precisión al convertir un valor entero a otro real al desechar algunos dígitos significativos si el número de cifras del valor entero original es muy grande. En la siguiente imagen se puede ver cuáles son las posibles conversiones de promoción.

Las conversiones de contracción son un poco más peliagudas ya que cada vez que hacemos una conversión tenemos una pérdida de datos a menos que el origen cumpla con el máximo del destino.

Todas las conversiones se realizan básicamente de tres modos:
·         Asignación: por conversión implícita cuando se asigna una variable de un tipo a otra de otro tipo.
·         Promoción aritmética: conversión implícita como resultado de una operación aritmética.
·         Por casting o “moldes”: conversión explícita con operadores que producen la conversión entre tipos.
En la siguiente imagen se hace un resumen de las diferentes conversiones que se pueden realizar, podremos observar las conversiones implícitas o automáticas (A) en las que no tenemos que hacer nada para convertir el dato, las conversiones en las que es posible que tengamos perdidas de datos (P) y las conversiones en las que hay que hacer una conversión explícita o “casting” (C).


Estructura de un programa en Java

0 comentarios

La clase principal y el método main.

Un programa puede construirse empleando varias clases. En su estructura más simple tendríamos una clase principal que contendría el programa, rutina o método principal: main() en el cual se incluirían las sentencias del programa principal. De esta manera la estructura de un programa simple en Java seria el siguiente:
public class ClasePrincipal {
        public static void main(String[] args) {
                sentencia_1;
                sentencia_2;
                //...
                sentencia_N;
        }
}

Comentarios

Una parte importante de los programas son sus comentarios ya que estos nos permiten saber cuál se supone que tienen que ser el funcionamiento de una sentencia en concreto. Los comentarios no son almacenados a la hora de compilar de manera que el compilador los detecta y los ignora, haciendo que el código sea más ligero.
En Java disponemos de tres tipos de comentarios, entre los cuales podemos encontrar los comentarios clásicos de C y C++ tales como // y /* … */. De esta manera el compilador de Java ignorara todo lo que escribamos desde // hasta el final de la línea:
System.gc(); // Esta parte será ignorada, pero realizara el Garbage collection.
Con el tipo de comentario /* … */ tendremos un comentario multilinea, en este caso solo tendremos que marcar el inicio”/*” y el final “*/”  para que todo lo que se encuentre en su interior sea ignorado por el compilador.
public class suma {
        public static void main(String[] args) {
                int numero = 1;
                numero++;
                int multiplicador = 2;
                numero *= multiplicador;
                System.out.println("salida 1: " + numero);
                numero++;
                numero *= multiplicador;
                System.out.println("salida 2: " + numero);
        }
}
c:\>javac suma.java

c:\>java suma
salida 1: 4
salida 2: 10
public class suma {
        public static void main(String[] args) {
                int numero = 1;
                numero++;
                int multiplicador = 2;
                numero *= multiplicador;
                System.out.println("salida 1: " + numero);/*
                numero++;
                numero *= multiplicador;
                */System.out.println("salida 2: " + numero);
        }
}
c:\>javac suma.java

c:\>java suma
salida 1: 4
salida 2: 4

Por ultimo tenemos el tipo de comentario que se usa para el documentador de Java, este se caracteriza por que comienza con “/**”  y termina con “*/” si nos fijamos en la diferencia con el comentario anterior este contiene dos * al inicio, en lugar de uno solo.
Este tipo de comentarios suele encontrarse al inicio de los métodos y nos indica varios parámetros del mismo así como una breve descripción.
/**
* Método que permite convertir una lista en un array
* @param list
* @return Array
*/

Hay muchos y muy variados tags para este API de JavaDocs, de manera que ya lo miraremos más adelante.

Tokens

                Un token es el elemento más pequeño que se interpretara en nuestro código por el compilador. En Java los tokens se pueden dividir en 4 grupos.

  • Identificadores o nombres que se asignarían a las variables, constantes, clases, paquetes y métodos. Dentro de los identificadores se encuentran las palabras claves que son identificadores reservados por Java para cumplir con un objetivo específico en el código.
  • Constantes literales: representan valores predefinidos que puede tomar una.
  • Operadores: representan una operación que se aplica a un objeto o un dato, sobre una variable o constante (operando).
  •  Separadores: Son empleados para indicarle al compilador de Java donde se ubican los elementos de código. Por ejemplo: { } , : ;
Los identificadores tienen que seguir una serie de normas a la hora de declararse.
  • Los identificadores han de comenzar por una letra, o por un carácter de subrayado “_” o con el carácter de dólar “$”. Aunque se desaconseja utilizar el carácter dólar ya que el compilador lo utiliza de manera interna.
  • A partir del segundo carácter se podrán usar además números u otros digitos. Estarian prohibidos los espacios en blanco, el signo de interrogación “?” y el signo del tanto por ciento “%”.
  •  No hay límite de caracteres.
  • El identificador es case sensitive, lo que viene a significar, que los identificadores “casa”, “CASA” y “Casa” serian diferentes
  • Se pueden incluir caracteres Unicode, con lo que se pueden emplear secuencias de escape \uxxxx para representar estos caracteres
  • No puede emplearse el identificador de una variable o cualquier otro elemento del código fuente del programa para otro ya existente en el mismo bloque. Excepción: variable miembro y local con el mismo identificador.
  • Las palabras reservadas no pueden emplearse como identificadores.

Aunque la elección de cómo escribir los identificadores en Java no se encuentra normalizado, sí que tenemos una serie de convenciones en la que nos podemos basar a la hora de construir nuestros nombres.
  • Los identificadores tienen que ser auto explicativos, de tal manera que cualquier persona que venga, sepa a la perfección que es lo que va a hacer el método. Por ejemplo, si ponemos un método denominado “Integer getmes(Usuario usuario)” lo que cualquiera esperara es que el método me devuelva el numero del mes usuario, pero aquí comienza el problema, el mes de alta, de baja, de nacimiento… como se puede ver un déficit de información en el identificador nos puede llevar a errores en el futuro. Si se hubiera puesto “Integer getmesaltasistema(Usuario usuario)” no habría dudas, devuelve el mes en el que se dio de alta.
  •  Si el identificador contiene más de una palabra se utilizaría la convención ‘Lower Camel Case’ o lo que es lo mismo, la primera letra de la primera palabra en minúscula y el resto de palabras con la primera letra en mayúsculas. Por ejemplo, si nos fijamos en el apartado A) se hace realmente difícil de leer, cuando solamente era “getmes” era sencillo, pero si lo pasamos por el convenio quedaría de la siguiente manera “getMes”, la cosa se complica cuando se incluyen más palabras “getmesaltasistema”, amén de que juntar algunas palabras puede tener un sentido que no queremos dar, de manera que separaremos la palabra según el convenio “getMesAltaSistema”, ahora es mucho más intuitivo de separar.
  • El uso del subrayado ‘_’ está permitido en todo tipo de identificador, pero es aconsejable usarlo únicamente como separador de palabras en las constantes, por ejemplo

public static final int NUMERO_MAXIMO_CARACTERES = 255;

Existen muchas más convenciones, si estás interesado en ellas, no dudes en leerte las convenciones publicadas por Oracle, serán del 1999 pero ya que son convenciones que no varían casi nunca siguen siendo igual de validas; tenéis toda la información aquí 

¿Qué es Derby?

0 comentarios


Derby es una base de datos relacional escrito íntegramente en JAVA. Actualmente se encuentra bajo una licencia Apache 2.0.

Pero esta base de datos no siempre se llamó Derby, en el 1997 una empresa de Oakland, California denominada Cloudscape dio a luz, la que fue reconocida como primera versión de Derby, un motor de base de datos denominado JBMS. Posteriormente el producto adopto el nombre de la empresa Cloudscape y comenzaron a aparecer versiones cada seis meses, esto hizo que otra gran empresa se fijara en ellos y en 1999 Informix Software, Inc. adquirió Cloudscape, Inc. por diez millones de acciones, del paquete de acciones ordinarias para emisión; lo cual la verdad no se a cuánto ascendía, ahora mismo no soy capaz de encontrar el valor. Esta transacción no pasó desapercibida para la gigante IBM que en seguida se fijó en el paquete, o quizás orquesto él la compra, esto último nunca lo sabremos, la cuestión es que apenas dos años después, en Julio del 2001, IBM se hace con la BBDD de Cloudscape tras la compra de parte de Informix.
El motor de la base de datos fue renombrado a IBM Cloudscape y comenzaron a aparecer versiones enfocadas principalmente a los productos de IBM y su Middleware.

En el 2004 IBM cedió el código del "IBM Cloudscape" a la Apache Software Foundation para Derby, un proyecto patrocinado por el proyecto Apache DB. En Julio de 2005 el proyecto Derby continuó como un subproyecto de base de datos de alto nivel de Apache. Sun Microsystem se unió al proyecto para poder lanzar Derby como base de datos empotrada de Java, lo cual consiguió con el lanzamiento de Java 6 en diciembre de 2006, Sun comenzó empaquetando Derby en el JDK bajo el nombre Java DB.


En su modo embebido Derby sólo soporta un hilo, lo cual puede ser un problema para grandes proyectos, pero hay que tener en cuenta que esta base de datos no está pensada para ser utilizada en proyectos de larga duración ya que su consumo de memoria lo haría inviable. Derby más bien lo podríamos utilizar para demos, presentaciones, bases de datos auxiliares durante la instalación o cuando se sabe de antemano que la carga va a ser nula y los registros que se van a cargar van a ser pocos.

Desactivar las X en nuestro Ubuntu Server 12.04

0 comentarios

Buenos días.

Por solicitud de Cristian Tapia he retomado el hilo de lo que estaba haciendo en mi entrada Como instalar Xfce en Ubuntu Server 12.04 lts y mostrar la manera de que nuestro servidor no malgaste recursos con la carga de las X, Xfce 4 en nuestro caso.

Para conseguir que Ubuntu inicie en modo consola estuve buscando la solución a través del Grub, lo cual fue un error, al final la solución es más sencilla. El sistema de arranque de Ubuntu, que no del sistema, siempre ira a comprobar las X ya que se las hemos instalado, por lo tanto es a las X a la que le tenemos que decir que no queremos que se cargue, para ello lo mejor es que pasemos a modo consola ( Ctrl + Alt + F1 ), se puede hacer desde el simulador de consola, pero prefiero hacerlo con la consola real.

Una vez estamos en moda consola ejecutamos el comando:
 
sudo nano /etc/X11/default-display-manager

Si tu no has instalado el Ubuntu server igual que nosotros, has instalado un gestor de ventanas diferentes o simplemente ves muchas más líneas que nosotros tendrás que buscar algo muy parecido a lo que voy a decir ahora.
 
Dentro de este fichero nos encontraremos con una solo entrada, esta entrada se debería denominar "/usr/bin/wdm" esta es la que llama al cargador de las X, por lo que he podido observar por diferentes pruebas este fichero es muy similar en diferente entornos, por ejemplo para un sistema basado en Gnome la línea se denomina "/usr/bin/gdm" y para un sistema basado en KDE la línea se denomina "/usr/bin/kdm", de manera que no creo que sea muy difícil de detectar esta línea vengas del sistema que vengas.
 
Una vez tengamos la línea tenemos que pensar en solo hay tres estados:
  1. La ausencia de parámetros, que es el estándar con el que lo encontramos, hace que se cargue la pantalla grafica, justamente lo que queremos evitar.
  2. play, nos cargara el apartado grafico en modo consola, todavía no he pillado muy bien para que sirve, la cuestión es que yo no he visto que descienda el consumo de RAM.
  3. stop, este parámetro evita que se cargue todo el apartado grafico, en este si que he podido ver una reducción en el consumo de memoria RAM.
Yo estoy utilizando la opción de stop y me esta funcionando bastante bien.
 
Espero que os sea de ayuda a todos este pequeño tutorial de como manteneros en la consola de Linux.

Ejecutar las macros de un XLSM desde Java

3 comentarios

Vamos con algo muy sencillo pero que hasta que he encontrado la formula más sencilla he tenido que dar unas cuantas de vueltas. Se trata de la ejecución de macros desde Java, para eso tenemos dos maneras, hoy nos vamos a ocupar solamente de una, vamos a ejecutar una macro almacenada dentro de un Excel.

Lo primero que necesitamos es una API externa denominada JACOB que es un JAVA-COM bridge estas se utilizan normalmente para realizar llamadas a JNI (Java Native Interface) en este caso para poder realizar llamadas a las DLL que nos permite la ejecución de una macro, para ello nos tenemos que bajar el jar y el dll de la pagina de sourceforge donde se aloja el proyecto.

Ahora dentro del Eclipse, o el IDE que utilicéis para programar, tenemos que importar un nuevo JAR y a este asignarle el directorio en el que se encuentra el dll.


No os engañéis por el nombre, "LFR/lib/jacob.dll" es un directorio, no un fichero, solo que soy así de poco original.

Hay una cosa importante en este programa y es que tenéis que conocer como se llama la macro y en que pagina esta escrita ya que le tenéis que dar toda la ruta entera, de ahí que esto sea solamente un ejemplo, para tenerlo todo perfectamente programado todo esto tendría que estar parametrizado, preferiblemente desde base de datos, lo cual nos evita un pase a producción, y la función tendría que aceptar como parámetros de entrada diferenciados la ruta, el libro, la pagina y el nombre de la macro para poder montarlo nosotros de manera dinámica.

Veamos el código, os lo dejo para que podáis familiarizaros con el, es relativamente fácil, de todas maneras vamos a comentar los puntos claves para que se vea más claro.

package LFR.Liem.Dazkun.Test.Java.POIExecutor;

import java.io.File;

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.ComThread;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;

public class POIExecutor {
 /**
  * 
  * 
  * @author Liem Dazkun
  * @param file
  *            Fichero del que se ejecuta la macro
  * @return boolean TRUE si se ejecuto correctamente la macro
  * 
  */
 public boolean openFile(String file) {
  try {
   final String macroName = "!Hoja1.multiplica";
   executeMacro(new File(file), macroName);
   return true;
  } catch (Exception e) {
   e.printStackTrace();
  }
  return true;
 }

 public boolean executeMacro(File file, String macroName) {
  ComThread.InitSTA();

  final ActiveXComponent excel = new ActiveXComponent("Excel.Application");

  try {

   final Dispatch workbooks = excel.getProperty("Workbooks")
     .toDispatch();
   final Dispatch workBook = Dispatch.call(workbooks, "Open",
     file.getAbsolutePath()).toDispatch();

   final Variant result = Dispatch.call(excel, "Run",
     new Variant(file.getName() + macroName));

   Dispatch.call(workBook, "Save");

   com.jacob.com.Variant f = new com.jacob.com.Variant(true);
   Dispatch.call(workBook, "Close", f);

  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   excel.invoke("Quit", new Variant[0]);
   ComThread.Release();
   return true;
  }

 }
}

Bueno por lo que podemos ver openFile es la que hace la llamada a la macro en este caso es una macro que tengo almacenada en la 'Hoja1' y que se llama 'multiplica', por eso os decía que era muy importante saber como se llamaban las macros, después llamamos a una función denominada executeMacro con dos parámetros, el primero será el Excel al que le ejecutaremos la macro y el segundo será el nombre de la misma.
Cargaremos el Excel que es un 'ActiveXComponent', un objeto propiedad de la librería Jacob, y lo inicializaremos como un 'Excel.Application'. Después se cargara el libro sobre el que trabajaremos y en la siguiente línea se ejecutara la macro, salvamos el libro para asegurar que las modificaciones quedan almacenadas y cerramos el flujo de datos del JNI.
Con eso ya tendríamos toda la llamada a la macro de un Excel.

Para hacer tanto tiempo que no escribo nada no esta del todo mal, ha sido una investigación interesante de hacer.

Tabla de multiplicar para SAP ABAP IV

0 comentarios

De todo hay que aprender y nada puede detenernos, ahora estoy estudiando algo de ABAP IV, como muestra os voy a dejar una tabla de multiplicar realizada bajo SAP ABAP IV.

SAP nos solicita de que numero solicitamos la tabla de multiplicar, tras ello hacemos un bucle para imprimir las diez multiplicaciones necesarias.

*&---------------------------------------------------------------------*
*& Report  Z_LIEM_TEST
*&
*&---------------------------------------------------------------------*
*&
*& El programa solicita un numero y muestra su tabla de multiplicar
*&---------------------------------------------------------------------*

REPORT  z_liem_test.

DATA resultado TYPE string.
DATA multi(17) TYPE c.

SELECTION-SCREEN BEGIN OF BLOCK b1 WITH FRAME.
PARAMETERS p_params TYPE i.
SELECTION-SCREEN END OF BLOCK b1.

IF p_params IS INITIAL.
  WRITE 'No se ha indicado de que tabla quiere'.
ELSE.
  WRITE p_params TO multi.
  DO 10 TIMES.
    DATA index(17) TYPE c.
    DATA res(17) TYPE c.
    DATA resu TYPE i.
    resu = sy-index.
    WRITE sy-index TO index.
    MULTIPLY resu BY multi.
    WRITE resu TO res.
    CONCATENATE index ' * ' multi ' = ' res INTO resultado.
    CONDENSE resultado.
    WRITE resultado.
    SKIP.
  ENDDO.
ENDIF.


Como podemos ver es mucho código para este solo proceso, pero es un primer acercamiento al código  seguiremos haciendo cosas para SAP ABAP IV :)

Crear un "Splash Screen" sencillo en Android

0 comentarios

Ahora vamos a intentar de crear un "splash screen" sencillo para Android. Un "splash screen" o pantalla de acogida no es más que un texto, imagen o programa liviano que cargamos a la espera de cargar todo el contenido completo de nuestro programa.

Este tipo de programas son creados con la clara idea de publicitar la empresa y/o amenizar la espera durante los tiempos de carga, de ahí que haya dicho programa liviano.

Bien, vamos al grano, yo este lo he realizado con un proyecto completamente limpio denominado "SplashScreen", para el que no lo recuerde puede encontrar como crear un proyecto en mi publicación programando Android en Ubuntu 11.10 (II) en la parte final.

Ahora tenemos que comenzar a configurar la actividad referente a nuestro "splash screen", para ello comenzaremos por el XML que contendrá los datos que usaremos en esta actividad, este fichero que yo he denominado "splash_activity.xml" tiene que estar situado en "/SplashScreen/res/layout".

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >

<TextView 
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="center"
    android:textSize ="18sp"
    android:text="@string/hello_world_2"
    />
</LinearLayout>

Ya que estamos en la carpeta nos aseguramos de que tengamos un XML para la actividad principal, este no hará falta tocarlo, pero por si acaso, su contenido tendría que tener esta forma si hace o no hace.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

<TextView 
    android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/hello_world"
        tools:context=".MainActivity"
    />
</RelativeLayout>

Ahora tenemos que editar el "AndroiManifest.xml" para que contemple la nueva actividad que tiene que hacer, podéis encontrar una descripción más detallada del "AndroidManifest.xml" en mi entrada AndroidManifest.xml, que es y para que sirve en este mismo blog. Tal y como explique en este fichero pondremos cualquier actividad, servicio, etc. que necesitemos ejecutar, de esta manera podremos ver como nos quedaran dos actividades prácticamente iguales la una a la otra.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="lfr.liem.dazkun.test.android.splashscreen"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".SplashScreen"
            android:label="@string/title_activity_main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".MainActivity"
            android:label="@string/title_activity_main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Ahora vamos a los ficheros Java que tenemos en la carpeta "src", tenemos que tener dos ficheros, el "MainActivity.java" y el "SplashScreen.java", fijaros que los nombres coinciden con los que asignamos en el "AndroiManifest.xml" en la parte de " android:name=".MainActivity""  y "android:name=".SplashScreen"". 
El fichero Java principal en un principio no hay que tocarlo, es más, si lo tocáis corre por vuestra propia cuenta y riesgo. De manera que veamos que es lo que sucede con el "SplashScreen.java" que es el que se iniciara en primera instancia.

package lfr.liem.dazkun.test.android.splashscreen;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class SplashScreen extends Activity {

 /** Se le llama cuando la actividad es creada por primera vez*/
    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        
        //Creamos un objeto de tipo SplashHandler
        SplashHandler mHandler = new SplashHandler();
        //Le seteamos cual es el XML va a usar como configurador de la actividad
        setContentView(R.layout.splash_activity);
        //Creamos un objeto de tipo Message
        Message msg = new Message();
        //Asignamos un codigo unico al mensaje
        //Despues este codigo sera utilizado para identificar el mensaje.
        msg.what = 0;
        //Enviamos el mensaje que durara 3 segundos (3000 = 3 seg)
        mHandler.sendMessageDelayed(msg, 3000);
    }     
    
    //La clase Handler implementa 'handle' el manejador de los mensajes
    private class SplashHandler extends Handler {
        
     //Este metodo se usa para manejar los mensajes recibidos. 
        public void handleMessage(Message msg)
          {

            final Intent intent = new Intent();
            //switch del identificador del mensaje segun su codigo
            switch (msg.what) {
            case 0:
             super.handleMessage(msg);
             //Creamos un intent para arrancar la actividad
             //Nuestra intención es comenzar MainActivity
             intent.setClass(SplashScreen.this,MainActivity.class);
             startActivity(intent);
             // finalizamos la actual actividad
             SplashScreen.this.finish();
             break;
            default:
             //Duplicamos el codigo por que solo tenemos un splash screen
             //si tuvieramos alguno que tuviera que salir en caso de fallo lo pondriamos aquí
                super.handleMessage(msg);
                intent.setClass(SplashScreen.this,MainActivity.class);
                startActivity(intent);
                SplashScreen.this.finish();
                break;
            }
          }
    }    
   

}

El onCreate es como el que tendremos en cualquiera de nuestras actividades, sencillamente inicializa y llama a su XML el cual contendrá el texto que visualizaremos y la asignación del mensaje que visualizaremos.

El objeto Handler es un controlador de mensajes que nos enviara el mensaje durante tres segundos.

La clase SplashHandler lo que hace es crear un nuevo hilo que mostrara el nuestra pantalla de inicio, el objeto Intent se ocupara de realizar la transición desde nuestro "SplashScreen" a nuestra clase principal, startActivity(intent); arrancaria esa actividad mientras que SplashScreen.this.finish(); haría que nuestra actividad finalizara. El codigo se ha repetido dos veces aunque no sea necesario, pero en toda clausula "switch" tiene que haber una opción "default:" y no quería dejarla en blanco.

Instalar SubVersion en Ubuntu server 12.04

0 comentarios

Una de las herramientas más básicas para todo programador es un controlador de versiones, uno de los más conocidos o como mínimo el único que me he encontrado en mi trabajo diario es el SVN.

Se trata de una herramienta opensource con un gran potencial y muy estable, podéis encontrar muchas más información sobre el en su pagina principal: http://subversion.tigris.org/.

Para instalar el servidor de subversion o SVN como prefiráis,  solo tenemos que hacer un par de cosas. Partamos de que estoy utilizando una maquina virtual con el Ubuntu Server 12.04 instalada, prácticamente sin nada más, solo el Xfce que ya le instale en la entrada "Como instalar Xfce en Ubuntu Server 12.04 lts" por si queréis dejar el entorno tal y como yo lo tengo.


Ahora solo tenemos que instalar lo que serian los paquetes básicos del subversion, para ello introduciremos la siguiente linea:



sudo aptitude install subversion subversion-tools



Bien, lo siguiente que tenemos que comprobar es que tenemos instalado los módulos dav y dav_svn y para ello tenemos que introducir los comandos:


a2enmod dav
a2enmod dav_svn

Si los tenemos instalados tendríamos que ver una pantalla como esta:



Si alguno de los dos modulos no esta instalado solo tendremos que instalar una cosilla más en nuestro servidor.


sudo aptitude install libapache2-svn


Ahora que ya lo hemos instalado volveremos a comprobar si ya funcionan los comandos, personalmente no he detectado ningún error más hasta este punto pero si alguien lo tiene que me lo haga saber e intentare reproducir el error en mi maquina para daros una solución.


Bien, el sistema de control de versiones SVN ya esta instalado en vuestras maquinas, si queréis mirar si la instalación ha sido satisfactoria solo tenéis que escribir:



svnadmin help

Como instalar Xfce en Ubuntu Server 12.04 lts

4 comentarios

Cuando tienes que virtualizar servicios por la comodidad del transporte te encuentras con la necesidad de no ocupar mucha memoria, lo cual acostumbra a ser un inconveniente en un mundo tan acostumbrado al entorno gráfico ya que este ocupa mucho en memoria, asimismo las versiones "desktop" acostumbran a incorporar mucho software que no hace falta y/o nos distrae de nuestro objetivo.

A la hora de virtualizar sistemas operativos suelo decantarme por Oracle VirtualBox el cual es compatible con Windows, OS X, Solaris y Linux, su gran versatilidad es lo que hace que me decante por el, amén de que es el mejor a mi parecer por su facilidad y robustez.

El sistema operativo que he elegido es el Ubuntu Server 12.04 lts, se que no es el más liviano de todos los que existen, los hay como Tiny core Linux que ocupan solo 11Mb y que serian una perfecta elección para cualquier equipo con pocos recursos o incluso una maquina virtual, pero mi elección se basa en que necesitaba una maquina para usarla como servidor y ya de paso ponerle el SVN, la idea es clara, tener un control de todo el código creado y no perderlo en uno de mis muchos formateo amén de la utilización de varios ordenadores y SO.

Pero Ubuntu Server, como todo buen servidor, no dispone de parte gráfica de manera con la que trabajar, lo que si que dispone es del basto universo de software del que hay en su repositorio, de manera que para instalar el Xfce solo tenemos que seguir estos simples pasos.


  1. Activar el repositorio "universe" en caso de que no lo este, para ello tenemos que comprobar que las siguientes dos lineas existen en el fichero "/etc/apt/sources.list"

deb http://es.archive.ubuntu.com/ubuntu/ precise universe
deb-src http://es.archive.ubuntu.com/ubuntu/ preciseuniverse
  1. Actualizar los repositorios

sudo apt-get update
  1. Instalar los packages necesarios para poner el sistema grafico

sudo apt-get install wdm x-window-system-core xfce4
  1. Durante la instalación es posible que nos solicite el tamaño de la pantalla, esto ya va a gustos.
  2. Y ahora para comenzar a utilizarlo solo tenemos que escribir es “startx”
Solo le he encontrado una pega a este método y es que sobrecarga el arranque al añadir el GRUB y que siempre se me va al sistema gráfico en lugar de quedarse en consola a la espera de que yo decida de activar el sistema gráfico. Pero no pasa nada, otra cosa con la que picarme sanamente, el próximo paso lógico tras terminar de montar todo el servidor sera desactivar el auto arranque del modo gráfico.

Ampliar memoria en el WebLogic

0 comentarios

Esto es algo que siempre olvido y termino recurriendo a Google para averiguarlo.

Para ampliar la memoria lo primero que tenemos que hacer es localizar desde que directorio se ejecuta. Pensad que el WebLogic no tiene que estar instalado necesariamente en la misma ruta que la ejecución de nuestro proyecto, por ejemplo, mi servidor se encuentra en "c:\ORACLE\Middleware\wls1211\wlserver\server\" mientras que la ejecución de mi proyecto se encuentra en "c:\ORACLE\Middleware\user_projects\domains\Cartera\startWebLogic.cmd" a partir de este fichero nos encontraremos la manera de llegar al fichero "real" de ejecución.

Normalmente este fichero suele tener la siguiente estructura.

@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:\ORACLE\Middleware\user_projects\domains\Cartera

call "%DOMAIN_HOME%\bin\startWebLogic.cmd" %*



ENDLOCAL



En caso de que usemos Linux tendremos algo parecido a lo siguiente
#!/bin/sh

# WARNING: This file is created by the Configuration Wizard.
# Any changes to this script may be lost when adding extensions to this configuration.

DOMAIN_HOME="C:/ORACLE/Middleware/user_projects/domains/Cartera"

${DOMAIN_HOME}/bin/startWebLogic.sh $*





Si nos fijamos en ambos casos nos redirecciona a la carpeta de instalación. Esto hace que este fichero sea una mera plataforma para arrancar el sistema ya que setea en ambos ficheros la misma dirección.

En el siguiente fichero tenemos el grueso del asunto, el como se va a cargar todo lo que tenemos relacionado con WebLogic. Y lo que no pone es lo que más nos interesa en este momento, hay una variable  muy importante que es "MEM_ARGS", esta variable que no esta bien definida en el fichero es la responsable de que podamos ampliar la memoria con la que arrancamos.

Para inicializarla solamente le tenemos que poner la siguiente linea dentro del fichero, indistintamente de que tratemos con el "bat" o el "sh".

set MEM_ARGS=-Xms512m -Xmx1024m -XX:CompileThreshold=8000 -XX:PermSize=64m -XX:MaxPermSize=256m


Y de esta manera nos cargara con la memoria que le indicamos.