jueves, 22 de marzo de 2012

String a Date (Fecha) en Java





Buenas a tod@s!

Con esta entrada os quiero enseñar como se puede paar de String a date (fecha). ¿Para qué lo podemos necesitar? El ejemplo que más se me viene a la cabeza y por el cual tuve que investigar y por lo tanto puede que vosotros también es cuando cogía datos de tipo datetime o smalldatetime en sql server y lo recogía como string en java y luego quería tratar con él como si fuera de formato fecha.

Normalmente cualquier SGBD tendra un tipo de datos datetime, date o smalldatetime.

El tipo datetime suele ser así: "12/08/2012 12:51:12" si esta almacenado en formato local español.


Bueno en mi programa ejemplo voy a aplicarlo directamente sobre un String, pero como ya he dicho antes lo cogeríamos por ejemplo de una Base de Datos y lo almacenaríamos como string, con lo cual es lo mismo.

El código sería el siguiente:


import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

public class principal {

public static void main(String[] args) {
String fecha = "12/08/2012 12:51:12";
Date d = null;
/* FORMATOS EN EL CUAL QUEREMOS LA FECHA EN
EN ESTE CASO DIA / MES / AÑO */
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy", Locale.ENGLISH);
try {
//parseamos string a tipo date
d = sdf.parse(fecha);
} catch (ParseException e) {
e.printStackTrace();
}

//ALGUNOS TIPOS DE FORMATOS
DateFormat dfDateShort = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println(dfDateShort.format(d));
//FORMATO MEDIO
DateFormat dfDateMedium = DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println(dfDateMedium.format(d));
//FORMATO NORMAL
DateFormat dfDefault = DateFormat.getInstance();
System.out.println(dfDefault.format(d));
}

}


Ese es el pequeño código... Hay muchos más formatos, para verlos todos solamente necesitaremos por DateFormat.#Estilo_que_queramos, ya sea Long, milisegundos, decadas, short...

Espero que os haya servido de ayuda y cualquier duda o comentario nada más tenéis que postearlo e intentaré ayudaros.

¡Un saludo!

domingo, 18 de marzo de 2012

Un poco de JSplitPane y JScrollPane


La misma implementación que hice en la entra anterior, pero en vez de 3 JInternalFrame he usado 3 paneles (JPanel) con Scroll y Split.


public class VentanaPrincipal extends JFrame{ public VentanaPrincipal(){ { this.setTitle("Ventana Principal"); Container contenido = this.getContentPane(); crearJToolBar(); contenido.add(barraJTool, BorderLayout.NORTH); //CREAR PANELES PanelIzquierdo pi = new PanelIzquierdo(); pi.setBackground(Color.WHITE); PanelCentral pc= new PanelCentral(); pc.setBackground(Color.LIGHT_GRAY); PanelSuperior ps = new PanelSuperior(pc); ps.setBackground(Color.LIGHT_GRAY); scrollPI = new JScrollPane(); scrollPI.getViewport().add(pi, null); scrollPS = new JScrollPane(); scrollPS.getViewport().add(ps, null); Dimension d= new Dimension(800, 150); scrollPS.setMinimumSize(d); scrollPC = new JScrollPane(); scrollPC.getViewport().add(pc, null); jSP_1 = new JSplitPane(JSplitPane.VERTICAL_SPLIT,scrollPS,scrollPC); jSP_2 = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,scrollPI,jSP_1); jSP_1.setOneTouchExpandable(true); jSP_2.setOneTouchExpandable(true); } }


Espero que les haya servido de ayuda y para lo que sea dejen un comentario.

Un saludo.
 
     

viernes, 16 de marzo de 2012

Escritorio con 3 ventanas internas dinámicas


Bueno te cuento...

VentanaPrincipal es JFRAME es la ventana principal.

En la ventana principal se alojan 3 JInternalFrames, Izquierdo, Superior y central.

Ahí va el código:


VENTANA PRINCIPAL (JFRAME): [CODE]public class VentanaPrincipal extends JFrame { private VentanaPrincipal vp; private PanelCentral pc; private PanelSuperior ps; private PanelIzquierdo pi; public VentanaPrincipal(){ this.setLayout(null); this.setTitle("VENTANA PRINCIPAL"); this.setResizable(true); this.setBounds(0, 0, 1024, 768); this.setLocationRelativeTo(null); vp=this; /******** PANEL CENTRAL *******************/ pc = new PanelCentral(); /******** PANEL SUPERIOR *******************/ ps = new PanelSuperior(this, pc); /******** PANEL IZQUIERDO *******************/ pi = new PanelIzquierdo(this,ps,pc); ps.setPanelIzquierdo(pi); /******** AÑADIR A LA VENTANA *******************/ add(pi); add(pc); add(ps); /******** ESCUCHADOR CUANDO CAMBIAMOS TAMAÑO DE VENTANA PRINCIPAL *******************/ this.addComponentListener(new ComponentAdapter() { public void componentResized(ComponentEvent e) { pi.setBounds(0, 30, 200, vp.getHeight()-72); pc.setBounds(pi.getWidth(),ps.getHeight()+30,vp.getWidth()-pi.getWidth()-18,vp.getHeight()-ps.getHeight()-72); ps.setBounds(pi.getWidth(),30,vp.getWidth()-pi.getWidth()-18,vp.getHeight()-pc.getHeight()-70); } }); } public static String getFechaActual() { Date ahora = new Date(); SimpleDateFormat formateador = new SimpleDateFormat("dd-MM-yyyy"); return formateador.format(ahora); } public static String getHoraActual() { Date ahora = new Date(); SimpleDateFormat formateador = new SimpleDateFormat("hh:mm:ss"); return formateador.format(ahora); } }[/CODE] PANEL CENTRAL: [CODE]public class PanelCentral extends JInternalFrame { private int x, y; private PanelCentral pc; private JScrollPane scrollPane; public PanelCentral(){ pc=this; this.setLayout(null); this.setTitle(null); this.setVisible(true); this.setClosable(false); this.setMaximizable(false); this.setResizable(false); } }[/CODE] PANEL SUPERIOR [CODE] public class PanelSuperior extends JInternalFrame implements ComponentListener { private PanelIzquierdo vpi; private VentanaPrincipal vvp; private PanelSuperior vps; private PanelCentral vpc; public PanelSuperior(VentanaPrincipal vp, PanelCentral vc){ vps=this; vvp=vp; vpc=vc; this.setLayout(null); this.setTitle(null); this.setVisible(true); this.setClosable(false); this.setMaximizable(false); this.setResizable(true); this.addComponentListener(this); this.addComponentListener(new ComponentAdapter() { public void componentResized(ComponentEvent e) { vpc.setBounds(vpi.getWidth(),vps.getHeight()+30,vvp.getWidth()-vpi.getWidth()-18,vvp.getHeight()- vps.getHeight()-72); } }); } public void setPanelIzquierdo(PanelIzquierdo pi){ this.vpi=pi; } @Override public void componentHidden(ComponentEvent e) { // TODO Auto-generated method stub } @Override public void componentMoved(ComponentEvent e) { vps.reshape(vpi.getWidth(), 30,vvp.getWidth()-vpi.getWidth()-18,vvp.getHeight()-vpc.getHeight()-70); } @Override public void componentResized(ComponentEvent e) { // TODO Auto-generated method stub } @Override public void componentShown(ComponentEvent e) { // TODO Auto-generated method stub } } [/CODE] PANEL IZQUIERDO [CODE]public class PanelIzquierdo extends JInternalFrame implements ComponentListener , MouseListener{ private PanelIzquierdo pi; private VentanaPrincipal vvp; private PanelSuperior vps; private PanelCentral vpc; private JTree tree; public PanelIzquierdo(VentanaPrincipal vp, PanelSuperior vs, PanelCentral vc){ //this.setLayout(null); this.setBounds(0,30,200,768); this.setVisible(true); this.setClosable(false); this.setMaximizable(false); this.setResizable(true); this.setTitle("Navegador"); pi=this; vvp=vp; vps=vs; vpc=vc; this.addComponentListener(this); this.addMouseListener(this); crearJTREE(); this.addComponentListener(new ComponentAdapter() { public void componentResized(ComponentEvent e) { vpc.setBounds(pi.getWidth(),260,vvp.getWidth()-pi.getWidth()-18,vvp.getHeight()-302); vps.setBounds(pi.getWidth(),30,vvp.getWidth()-pi.getWidth()-18,vvp.getHeight()-vpc.getHeight()-70); tree.setBounds(0, 0, pi.getWidth(), pi.getHeight()); } }); } @Override public void componentHidden(ComponentEvent e) { // TODO Auto-generated method stub } @Override public void componentMoved(ComponentEvent e) { pi.reshape(0, 30, 200, vvp.getHeight()-72); } @Override public void componentResized(ComponentEvent e) { // TODO Auto-generated method stub } @Override public void componentShown(ComponentEvent e) { // TODO Auto-generated method stub } public void crearJTREE(){ DefaultMutableTreeNode Sistema = new DefaultMutableTreeNode("Sistema"); DefaultMutableTreeNode hijos = new DefaultMutableTreeNode("hijos"); DefaultTreeModel modelo = new DefaultTreeModel(Sistema); tree = new JTree(modelo); tree.setBounds(0, 0, pi.getWidth(), pi.getHeight()); DefaultMutableTreeNode Medicos = new DefaultMutableTreeNode("Medicos"); DefaultMutableTreeNode Otros = new DefaultMutableTreeNode("Otros"); DefaultMutableTreeNode Altas=new DefaultMutableTreeNode("Altas"); DefaultMutableTreeNode Bajas=new DefaultMutableTreeNode("Bajas"); DefaultMutableTreeNode Quirofano = new DefaultMutableTreeNode("Quirofano"); DefaultMutableTreeNode Otros2=new DefaultMutableTreeNode("Otros 2"); modelo.insertNodeInto(Medicos,Sistema,0); modelo.insertNodeInto(Otros, Sistema, 1); modelo.insertNodeInto(Otros2, Sistema, 2); modelo.insertNodeInto(Altas, Medicos, 0); modelo.insertNodeInto(Bajas, Medicos, 1); modelo.insertNodeInto(Quirofano, Medicos, 2); add(tree); } @Override public void mouseClicked(MouseEvent e) { } @Override public void mouseEntered(MouseEvent e) { // TODO Auto-generated method stub } @Override public void mouseExited(MouseEvent e) { // TODO Auto-generated method stub } @Override public void mousePressed(MouseEvent e) { } @Override public void mouseReleased(MouseEvent e) { // TODO Auto-generated method stub } }[/CODE]

Bueno llamariamos desde main a VentanaPrincipal.

La estructura queda así:




Un saludo.

jueves, 8 de marzo de 2012



INSTALAR ECLIPSE Y MI PRIMER PROGRAMA




Para empezar en el mundo de Java lo primero que debemos de instalar es eclipse, para poder escribir y probar el código que escribamos.


Para ello tenemos que ir a la página oficial de Eclipse, es totalmente gratuito y la verdad
es que no va nada mal.


Nos descargamos la versión que esté en .zip y una vez descargada lo único que tenemos quehacer es descomprimirla donde nosotros queramos y ya la tenemos totalmente funcional.


La primera vez que ejectuamos eclipse nos va a preguntar cual va a ser nuestro espacio de
trabajo por defecto (workspace), que, por defecto es C:/Users/Workspace.


Podemos decirle otra ruta, o dejar esa, y si queremos que no lo vuelva a preguntar más
tan solo tenemos que desactivar la casilla que viene más abajo.




Una vez dentro de eclipse, se puede ver que tenemos el Navegador de proyectos a la izquierdal os distintos menús arriba y a la derecha tenemos las clases que vamos usando (yo siempre lo quito) y arriba a la derecha nos saldrá en que lenguaje o plataforma estamos trabajando actualmente (Java, JavaEE, JSP, Android, etc...)






ABRIENDO UN NUEVO PROYECTO.


Para abrir un nuevo proyecto tenemos que ir a Archivo / Nuevo / Java proyect  --


File / New / Proyecto Java




Le ponemos el Nombre HolaMundo al proyecto y luego a terminar, Finish.






Creando nuestro primer proyecto.


Ahora a la izquierda en nuestro navegador tendremos HolaMundo, si lo desplegamos podremos
ver que tenemos dos carpetas


SRC- Source, donde tendremos todos los paquetes, clases y elementos o archivos indispensables
para poder funcionar nuestro proyect.


JRE SYSTEM LIBRARY - Librerias jar por defecto para usar en nuestro proyecto.




CREANDO NUESTRA PRIMERA CLASE.


Ahora vamos a escribir nuestro primer código, pero va a ser solamente mostrar por consola
el típico primer programa que usamos todos los informáticos o cuando probamos nuestro
primer programa. Es sencillo pero sirve para ver si funciona.


Nos vamos a SRC, le hacemos click derecho y nueva clase. Vamos a crear la clase Principal
como main y en el paquete principal.


Para ello lo indicamos como en la siguiente imagen


Primera configuración de nuestro proyecto.



Ahora hacemos doble click sobre nuestra recién creada clase Principal (Main). Doble click.


Podemos ver que nos crea el encabezado y el constructor como main con un Array de String
como argumento del mismo.


Los comentarios generados se pueden borrar.


Ahora para escribir Hola Mundo tan solo tendremos que escribir entre las llaves del constructor
(public static void main(String[] args)) un System.out.println("Hola Mundo");




Pulsamos sobre el botón Play y seleccionamos Aplicacion Java si nos lo preguntase.


Ya ejecutamos el programa y nos saldrá un mensaje en la Consola de Hola Mundo.



Si queremos mostrarlo como una ventana emergente escribiremos en vez de System.out.println lo siguiente JOptionPane.showMessageDialog(null, "Hola Mundo");




Hola Mundo en 



Recordad que cada vez que ejectemos el programa tendremos que darle al botón Parar
Rectangulo rojo y luego al doble aspa. Si no lo hacemos cuando ejecutemos el programa o
varios programas 40 veces por ejemplo, tendremos en ejecución 40 programas, lo que puede
hacer casi seguro ralentizarnos incluso dejarnos el pc colgado.


EXPORTAR NUESTRO PROYECTO A UN EJECUTABLE JAR


Por último si queremos que nuestro proyecto se pueda ejecutar en cualquier otra máquina
que disponga de la máquina virtual de java instalada tendremos que hacer lo siguiente:


File / Export / Java /Runnable JAR File


Le damos a siguiente y luego indicamos el nombre del proyecto (En nuestro caso HolaMundo).
Luego la ruta donde vamos a generar nuestro fichero .jar.


Exportar proyecto a un archivo JAR



Ya tendremos en la ruta dicha el archivo .jar, podremos ejecutarlo como si de un programa
normal se tratase (Doble click).


¡¡CUIDADO!!


Si estamos en eclipse bajo cualquier distro de Linux (Ubuntu, Fedora, OpenSuse...) nos
creará un archivo .jar igualmente como en Windows o Mac, pero luego tendremos que aplicarle
los permisos de ejecución desde consola o desde las propiedades del archivo.


DESDE LAS PROPIEDADES DEL ARCHIVO .JAR.


Simplemente hacemos click derecho sobre el fichero .jar y luego en propiedades. Le damos a
la pestaña permisos y activamos los permisos de ejecución.


EN CONSOLA


Nos vamos a la ruta donde está el fichero .jar y luego simplemente le añadimos los permisos de ejecución:


$ chmod +x fichero.jar


Si no estamos en la ruta como siempre


$ chmod +x Ruta_del_fichero/fichero.jar




Si queremos darle todos los permisos es simplemente poner chmod 777, ¡ojo con esto!


Espero que os haya servido de ayuda y si tenéis cualquier duda escribirme cualquier duda
o comentario.


Un saludo.

Ventana con imagen de Fondo


Buenas a todos.

Con esta entrada os quiero a enseñar a crear una simple ventana que contendrá un fondo que será una imagen, la que nosotros queramos.

Para este caso vamos a usar las siguientes clases:

Principal()
Ventana()
FondoVentana()

Las tres clases las vamos a poner en el mismo paquete, el paquete por defecto.

Empezamos por Principal:


Principal tendrá que llamar a Ventana, crearla, decirle que se haga visible y en este caso he puesto que cuando cerremos dicha ventana
se cierre todo el proceso del JFRAME.

El código sería el siguiente:


import javax.swing.JFrame;

public class Principal {

public static void main(String[] args) {

Ventana v = new Ventana();
v.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
v.setVisible(true);
}

}


Seguro que nos va a saltar varios errores, el primero de ellos puede ser que no hayáis importado swing.JFrame. El otro y más claro va a ser que no
podemos instanciar o crear Ventana, puesto que todavía no la hemos creado.

Ahora vamos con Ventana.

Para usar las propiedades de una Ventana, poder crearla, etc.., en Java necesitamos crear una clase que herede de JFrame. Tenemos que indicarle un
tamaño, un título (opcional), también podemos indicarle pero ya es también opcional si queremos bordes, si el usuario puede maximizar o minimizar, etc...
pero no voy a profundizar mucho más puesto que si estamos en una clase que hereda de JFRAME con poner this. saldrá todas las propiedades, funciones, procedimientos
y argumentos que puede admitir JFRAME.

El código sería algo así:


import javax.swing.JFrame;

public class Ventana extends JFrame {

private FondoVentana fondo;

public Ventana(){

this.setLayout(null);
this.setTitle("Mi ventana de entrada");
this.setBounds(40,40,600,400);
//quitar marcos (adornos)
//this.setUndecorated(true);


//pone la ventana en el centro
this.setLocationRelativeTo(null);

fondo = new FondoVentana();
this.add(fondo);

}
}


Simplemente heredamos de JFRAME, le indicamos que el layout se nulo, un título, un tamaño, lo centramos y luego le añadimos el fondo que todavía no hemos
creado.

Decir que con setBounds siempre los valores son para posicionar en X, Y y luego para Anchura, Altura. En nuestro caso da igual poner 40,40 como coordenadas
X.Y ya que luego aplicamos el setLocationRelativeTo(null) que nos crentrará la ventana sin preocuparnos de saber la resolución de nuestra pantalla.


Ahora vamos con el tercer paquete, pero antes vamos a nuestro Proyecto y creamos la carpeta Imagenes en nuestro proyecto. Buscamos una imagen para nuestro
fondo, lo suyo sería que tuviera las mismas proporciones que la ventana (600x400 pixeles) para que encaje bien, aunque si es mayor no pasa nada, cubrirá
solo la parte que pueda.

Ahora vamos con FondoVentana().

FondoVentana será un JDesktopPane. Es decir un panel de escritorio, o lo que es más conocido para nosotros un papel tapiz. Lo único que haremos en esta clase
es heredar de JDestopPane y cargar una imagen que estará en "/imagenes/nombrefondo.extension"


Vamos con su código:


import java.awt.Graphics;
import java.awt.Image;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JDesktopPane;

public class FondoVentana extends JDesktopPane {

private Image imagen;

public FondoVentana() {

this.setLayout(null);
this.setToolTipText("Ventana Principal");
this.setBounds(0, 0, 600, 400);

try {
imagen=ImageIO.read(getClass().getResource("/imagenes/fondoppal.png"));
}
 catch (IOException e) {
e.printStackTrace();
}

}

public void paintComponent(Graphics g){

super.paintComponent(g);
g.drawImage(imagen, 0, 0, getWidth(), getHeight(), this);
setOpaque(false);
}

}


Con esto ya tendremos nuestra Ventana lista con un fondo.

Espero que os haya servido de ayuda.

Un saludo.




miércoles, 7 de marzo de 2012

BlowFish en Java



Con esta entrada, os voy a enseñar cómo utilizar jBCrypt en Java. jBCrypt es una implementación de OpenBSD BlowFish (el cual también pondré cómo usar en otra entrada aparte), principalmente coge un String y lo encripta con un generador de claves.

Lo curioso es que solamente podremos encriptar un String, pero no al revés. Vosotros diréis pues es absurdo, pues no necesariamente, aquí un ejemplo:

1) Pedimos a un cliente un usuario y una contraseña. Nos da por ejemplo usuario10 y pass10. 

2) Nosotros lo encriptamos usando jBCrypt, nos dará una String o un array de Bytes según usemos una función u otra. 

3) La guardamos en un fichero, una tabla en una Base de Datos, donde sea, pero la guardamos.

4) La próxima vez que ese usuario vaya a entrar al Sistema o a donde tenga que entrar, nosotros le pediremos usuario y contraseña. Ahora viene la gracia, comparamos lo que nos da el usuario con lo que tenemos guardado en nuestro fichero o base de datos. Si coincide, pues que siga. Si no coincide, más memoria para la próxima :)


Lo primero que tendremos que hacer es bajarnos el fichero jBCrypt.java que lo podréis encontrar aquí.

Una vez lo descargamos, se descomprime y se importa el fichero mencionado anteriormente. Para importar ese Java en nuestro proyecto, por ejemplo, con Eclipse, basta con arrastrarlo hasta el paquete que queramos o al src si queremos e indicar que es una copia y no un linkeo. En la siguiente imagen os podéis hacer una idea de cómo se debería de quedar. En mi caso lo meto en un paquete llamado encrypts.










Ahora vamos a encriptar por ejemplo dos Strings cualquiera.

Creamos una clase por ejemplo Encriptar(){} y la vamos a hacer principal, total es para probar, pero ya sabéis que esto lo suyo sería ponerlo en un paquete distinto con una clase distinta.

Quedaría más o menos de la siguiente manera:

public class Encriptar { //lo ponemos manualmente para probar private String usuario="paco", password="estoesseguro";
public static void main(String[] args) { //vamos a crear un archivo, donde ira usuario y password encriptado try{ FileWriter fw = new FileWriter(new File("C:/Ejemplo"+".java"+".bin"),); PrintWriter pw = new PrintWriter(fw); String usuario= BCrypt.hashpw(usuario, BCrypt.gensalt()); String password = BCrypt.hashpw(password, BCrypt.gensalt()); pw.println(usuario); pw.println(password); pw.close(); } catch(IOException ex) System.out.println("Error al crear fichero"); System.out.println("Fichero creado correctamente"); }
}



Ahora solo faltaría ver como comprobarlo. Otra clase Comprobar() o en la misma de antes...



File archivo = "C:/Ejemplo/java.bin";
String checkusuario=null, checkpass=null;
int cont=0;


try{
 FileReader fr = new FileReader(archivo);
 BufferedReader br = new BufferedReader(fr);
 linea = br.readLine();
     
  while(linea!=null){      
                 
    try{

                  
     if (cont%2==0) if (BCrypt.checkpw(checkusuario, linea)) Acceso=true;       
     if (cont%2==1) if (BCrypt.checkpw(checkpass, linea))  Acceso2=true;
   

    }

    catch(NullPointerException e){}
      
    linea=br.readLine();
    cont++;    
      
    
    if (Acceso && Acceso2) break;
      
      
      
  } // FIN WHILE
     
   br.close();  //CERRAR FICHERO




//AQUI VAN LAS EXCEPCIONES