Una forma sencilla y rápida de aprender JAVA, observando y deduciendo cómo se comporta el lenguaje a través de ejemplos prácticos.

martes, 27 de diciembre de 2011

Comunicación entre procesos en diferentes máquinas de una red (Sockets)

Para ello necesitamos 2 codigos, uno con funcion servidor y otro de cliente.
Primero entramos en la IDE de Netbeans, creamos dos nuevos proyectos de tipo "Java aplication". Uno lo llamaremos
"socket_servidor" y el otro "socket_cliente".


* Codigo servidor:

package socket_servidor;

import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Socket_servidor {
static final int PUERTO = 5000;
public Socket_servidor( ) {
try {
ServerSocket skServidor = new ServerSocket(PUERTO);
System.out.println("Esperando cliente..." );
Socket skCliente = skServidor.accept();
System.out.println("Recibido cliente y mandando saludo");
OutputStream aux = skCliente.getOutputStream();
DataOutputStream flujo = new DataOutputStream( aux );
flujo.writeUTF( "Saludos");
skCliente.close();
} catch( Exception e ) { System.out.println(e); }
}
public static void main(String[] args) {
new Socket_servidor();
}
}


* Codigo cliente:

package socket_cliente;

import java.io.DataInputStream;
import java.io.InputStream;
import java.net.Socket;

public class Socket_cliente {
static final String HOST = "localhost";
static final int PUERTO = 5000;
public Socket_cliente( ) {
try {
Socket skCliente = new Socket( HOST , PUERTO );
InputStream aux = skCliente.getInputStream();
DataInputStream flujo = new DataInputStream( aux );
System.out.println( "Servidor dice: " + flujo.readUTF() );
skCliente.close();
} catch( Exception e ) { System.out.println(e); }
}
public static void main(String[] args) {
new Socket_cliente();
}
}


- Resultado en pantalla del servidor:

run:
Esperando cliente...
Recibido cliente y mandando saludo
BUILD SUCCESSFUL (total time: 8 seconds)

Nota: Hasta que no se ejecute el codigo de cliente permanecerá en estado de "Esperando cliente..."


- Resultado en pantalla del cliente:

run:
Servidor dice: Saludos
BUILD SUCCESSFUL (total time: 0 seconds)

Nota 1: Debemos arrancar primero el codigo "socket_servidor" antes que el "socket cliente".
Nota 2: Asegurarse de usar puertos por encima de 1024. En nuestro caso utilizamos el puerto 5000.
Nota 3: Si tenemos puesto el proceso del servidor en otro PC dentro una misma red local, solo tenemos que modificar en el codigo del cliente la variable String HOST = "localhost" por la IP del servidor.
Ej:

String HOST = "192.168.0.100"; // IP donde este arrancado la aplicación "socket_servidor"



viernes, 23 de diciembre de 2011

Ejecución de comandos MySql en codigo java.

Se crea una tabla llamada contactos. Seguidamente se agregan datos (registros), luego se hace una consulta y muestra el resultado en consola. Finalmente elimina la tabla y cierra la base de datos.

Codigo:

package mysql1;
import java.sql.*;
public class MySQL1 {
static String bd = "mi_base";
static String login = "root";
static String password = "";
static String url = "jdbc:mysql://localhost:3306/"+bd;
public static void main(String[] args) throws Exception {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,password);
if (conn != null) {
System.out.println("-Abierta base de datos " + url + " - Ok");

// Crear tabla contacto
Statement st = conn.createStatement();//Permite comandos SQL
st.executeUpdate( "CREATE TABLE contacto ("
+ "id INT AUTO_INCREMENT, "
+ "PRIMARY KEY(id), "
+ "nombre VARCHAR(20), "
+ "apellidos VARCHAR(20), "
+ "telefono VARCHAR(20))" );
System.out.println("-Creada tabla (contacto) - Ok");

// Insertar datos a la tabla
String nombres[]={"Juan","Maria","Antonio"};
String apellidos[]={"Sanchez","Jimenez","Moreno"};
String telefonos[]={"918971234","918984621","935741254"};
for (int i=0;i < nombres.length;i++) {
st.executeUpdate("INSERT INTO contacto ("
+ "nombre, "
+ "apellidos, "
+ "telefono) "
+ "VALUES ("
+ "'"+nombres[i]+
"','"+apellidos[i]+
"','"+telefonos[i]+
"' )");
}
System.out.println("-Añadir registros a la tabla - Ok");

// Consulta de datos
System.out.println("-Consultar registros:");
ResultSet rs = st.executeQuery ("select * from contacto");
while (rs.next()) {
System.out.println (
rs.getString (1) + " " +
rs.getString (2) + " " +
rs.getString (3) + " " +
rs.getString (4)
);
}

// Borrar tabla
st.executeUpdate("DROP TABLE contacto");
System.out.println("-Borrar tabla contacto - Ok");

conn.close();// Cerrar base de datos
System.out.println("-Cerrar base de datos " + url + " - Ok");
}
} catch(SQLException ex) { System.out.println(ex); }
}
}
Resultado:

run:
-Abierta base de datos jdbc:mysql://localhost:3306/mi_base - Ok
-Creada tabla (contacto) - Ok
-Añadir registros a la tabla - Ok
-Consultar registros:
1 Juan Sanchez 918971234
2 Maria Jimenez 918984621
3 Antonio Moreno 935741254
-Borrar tabla contacto - Ok
-Cerrar base de datos jdbc:mysql://localhost:3306/mi_base - Ok
BUILD SUCCESSFUL (total time: 1 second)

Nota: Para ejecutar comandos MySql desde codigo java hemos utilizado la sentencia executeUpdate y para consultas se utiliza executeQuery.

martes, 29 de noviembre de 2011

Comandos básicos de MySQL desde consola.

Entramos en consola del sistema. Y nos dirigimos en el siguiente directorio:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin
Y arrancamos el usuario "root" con la siguiente instrucción:

mysql -u root -p

Una vez dentro del menú "MySQL monitor" ya podemos empezar a gestionar nuestras bases de datos con las siguientes instrucciones basicas:

SHOW databases; --> Muestra listado de todas las bases de datos

CREATE database agenda; --> Crea una nueva base de datos llamada "agenda"

USE agenda; --> Seleccionamos la base de datos "agenda"

CREATE table contacto (nombre varchar(20), edad int); --> Crea una tabla llamada "contacto" con los campos nombre y edad

DESCRIBE contacto; --> Describe la estructura de los campos de la tabla "contacto"

INSERT INTO contacto VALUES ('Fulano', 20); --> Añade un registro a la tabla

SELECT * FROM contacto; --> Muestra todos datos de la tabla contacto

DROP table contacto; --> Borra la tabla "contacto"

DROP database agenda; --> Borra la base de datos "agenda" junto con todas las tablas que contenga


- Ejemplo práctico de utilización de dichos comandos:

C:\Archivos de programa\MySQL\MySQL Server 5.5\bin> mysql -u root -p
Enter password: ******

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 40
Server version: 5.5.17 MySQL Community Server (GPL)

Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database...........|

+--------------------+

| information_schema |

| mysql..............|

| performance_schema |

+--------------------+

3 rows in set (0.00 sec)


mysql> create database agenda;

Query OK, 1 row affected (0.00 sec)

mysql> show databases;
+--------------------+

| Database...........|

+--------------------+

| information_schema |

| agenda.............|

| mysql..............|

| performance_schema |

+--------------------+

4 rows in set (0.00 sec)

mysql> use agenda;
Database changed

mysql> create table contacto (nombre varchar(20), edad int);
Query OK, 0 rows affected (0.06 sec)

mysql> describe contacto;
+--------+-------------+------+-----+---------+-------+

| Field .| Type........| Null | Key | Default | Extra |

+--------+-------------+------+-----+---------+-------+

| nombre | varchar(20) | YES .|.....| NULL....|.......|

| edad...| int(11).....| YES .|.....| NULL....|.......|

+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> insert into contacto values ('Fulano', 20);
Query OK, 1 row affected (0.01 sec)

mysql> select * from contacto;
+--------+------+

| nombre | edad |

+--------+------+

| Fulano |...20 |

+--------+------+
1 row in set (0.00 sec)

mysql> drop table contacto;
Query OK, 0 rows affected (0.05 sec)

mysql> show tables;
Empty set (0.00 sec)

mysql> drop database agenda;
Query OK, 0 rows affected (0.00 sec)

mysql> show databases;
+--------------------+
| Database...........|

+--------------------+

| information_schema |

| mysql .............|

| performance_schema |

+--------------------+
3 rows in set (0.00 sec)

mysql> exit;
Bye

C:\Archivos de programa\MySQL\MySQL Server 5.5\bin>

jueves, 24 de noviembre de 2011

Creación de una base de datos MySQL y comprobación de conexión

* Creación base de datos "mi_base":
Para empezar necesitaremos tener instalado el gestor de base de datos MySQL (la instalación por defecto
, nos lo deja ya todo preparado).

1- Entramos a consola de comandos Inicio - Ejecutar - cmd [enter]

2- Nos dirigimos en el directorio:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin

3- Ejecutamos la orden:

mysql -u root -p

e introducimos la contraseña que nos pide

4- Procedemos a crear la tabla "mi_base" con la instrucción:

CREATE DATABASE mi_base;

5- Mostramos un listado de las bases de datos disponibles y vemos que se nos ha creado la nuestra (mi_base)

SHOW DATABASES;

5- Finalmente activamos nuestra base de datos con la instrucción:

USE mi_base;



Ya tenemos creada nuestra base de datos, ahora nos hace falta hacer la conexión desde codigo java. Para ello entramos al Netbeans IDE le damos a New Project y a Java Application al que llamaremos "mysql1".

* Codigo MySQL.java:
package mysql1;
import java.sql.*;
public class MySQL1 {
static String bd = "mi_base"; //Nombre de nuestra base de datos
static String login = "root"; //Nombre usuario que nos sale por defecto
static String password = "pass"; //contraseña del servidor del MySQL
static String url = "jdbc:mysql://localhost:3306/"+bd;
public static void main(String[] args) throws Exception {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,password);

if (conn != null) {
System.out.println("Conexión a base de datos "+url+" ... Ok");
conn.close();
}
} catch(SQLException ex) {
System.out.println("Error al conectarse con la base de datos "+url);
}
}
}


* Resultado:

run:
Conexión a base de datos jdbc:mysql://localhost:3306/mi_base ... Ok

BUILD SUCCESSFUL (total time: 2 seconds)

lunes, 21 de noviembre de 2011

Conectar Java con MySQL.

Para empezar, debemos tener instalado el IDE NetBeans y el MySQL Connector Java que lo descargamos desde la URL:
http://dev.mysql.com/downloads/connector/j/


Se descomprime el archivo y se guarda en una carpeta que llamaremos C:\ConectorJ

Abrimos el Netbeans y procederemos de la siguiente manera:

1- Primero crearemos un proyecto normal (Java application).


2- Abrimos el manejador de bibliotecas. Menu Tools - Libraries - (Library Manager)




3- Nos aparece el cuadro Libray Manager y le damos al botón New Library. Nos aparece un cuadro que debemos rellenarlo tal y como se muestra en la figura de acontinuación y le damos Ok.



4- Ahora debemos agregar unos detalles a la biblioteca. Asegurando que la nueva biblioteca creada "MySQL" este seleccionada (izquierda).


5- Seleccionamos la pestaña Class Path y damos clic en el botón Add JAR/Folder...



6- Se abre un dialogo llamado Browse JAR/Folder que permite seleccionar archivos. Buscamos en la carpeta "C:\ConectorJ\mysql-connector-java-5.1.18\" el archivo "mysql-connector-java-5.1.18-bin.jar" descargado anteriormente, lo seleccionamos y damos click en el boton Add JAR/Folder


7- Aparecerá en la sección Class Path el archivo que acabamos de agregar, damos clic en Ok del cuadro de dialogo Library Manager. Y aqui termina la primera parte del proceso.


8- Ahora debemos agregar la librería al proyecto. Dentro del explorador del proyecto debemos seleccionar la carpeta Libraries. Dar click derecho para mostrar el menu contextual.




9- Seleccionar opción Add Library

10- Seleccionar de la lista, la biblioteca recién creada con el nombre "MySQL".


11- Debe aparecer como una nueva entrada dentro de la carpeta Libraries, tal y como muestra la siguiente imagen:



Y listo.

domingo, 20 de noviembre de 2011

Instalación de un gestor de base de datos (MySQL)

Para empezar a trabajar con la base de datos, vamos a necesitar un sistema de gestion de base de datos relacional. Utilizaremos el sistema MySQL por su potencia y por ser software libre.

Primero descargamos el MySQL Installer desde la URL:
http://www.mysql.com/downloads/installer/


Y ejecutamos el instalador mysql-installer-5.5.17.0.msi
.
Para evitar problemas y/o malos entendidos instalamos todas las opciones que nos vienen por defecto:

Developer Default - Next> - Next> - Execute - Next> - Developer Machine - Next> En esta pantalla en el apartado Security Settings introducimos nuestra contraseña que utilizaremos para entrar en nuestra futura base de datos.

Next> - Next> - Finish

Y ya tenemos la instalación de MySQL terminada.

viernes, 18 de noviembre de 2011

Instalación de Netbeans 7.0 para programar en Java SE.

NetBeans es el entorno de desarrollo que utilizaremos para la programación Java. Pasos a seguir para su puesta en marcha:


1º Descargamos e instalamos JAVA desde la URL http://java.com/es/


2º Descargamos e instalamos Java Platform (JDK) desde la URL http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u1-download-513651.html


3º Descargamos e instalamos NetBeans IDE de Java SE desde la URL http://netbeans.org/downloads/index.htmDurante la instalación dejamos todas las opciones por defecto.

jueves, 29 de septiembre de 2011

Operar con números muy grandes (BigInteger)

Codigo: (Archivo: NumerosGrandes.java)

package numerosgrandes;
import java.math.BigInteger;
public class NumerosGrandes {

public static void main(String[] args) {
BigInteger fact = factorial(30);
System.out.println ("Factorial de 30 es: " + fact);
}

public static BigInteger factorial(int n) {
BigInteger f = new BigInteger("1");
for(int i=1;i<=n;i++) f = f.multiply(new BigInteger(i + ""));
return f;
}

}

Resultado:

Factorial de 30 es: 265252859812191058636308480000000

martes, 28 de junio de 2011

Mostrar otra ventana (JDialog) al pulsar botón.

Usando Netbeans7.0 se agregan en el nuevo proyecto dos ventanas. La ventana principal tipo jFrame con un boton dentro y la ventana secundaria de tipo jDialog.

Ventana principal (JFrame):
package dosventanas;
public class ventanaPrincipal extends javax.swing.JFrame {
public ventanaPrincipal() {
initComponents();
}
@SuppressWarnings("unchecked")
+ Generated Code //Aqui va codigo generado por Netbeans (ventana y boton).

private void BotonMostrarJDialog1ActionPerformed(java.awt.event.ActionEvent evt) {
new ventana2(this, true).setVisible(true);
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {
new ventanaPrincipal().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton BotonMostrarJDialog1;
// End of variables declaration
}


Ventana secundaria (JDialog):
package dosventanas;
public class ventana2 extends javax.swing.JDialog {
public ventana2(java.awt.Frame parent, boolean modal) {
super(parent, modal);
initComponents();
}

@SuppressWarnings("unchecked")

+ Generated code //Aqui va codigo generado por Netbeans (ventana2)

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {
ventana2 dialog = new ventana2(new javax.swing.JFrame(), true);
dialog.addWindowListener(new java.awt.event.WindowAdapter() {

public void windowClosing(java.awt.event.WindowEvent e) {
System.exit(0);
}
});
dialog.setVisible(true);
}
});
}
// Variables declaration - do not modify
// End of variables declaration
}


Resultado:
Nota1: En este ejemplo la ventana principal queda inhabilitada hasta que no se cierre la ventana secundaria (jDialog). Las ventanas de tipo jDialog tienen la pecurialidad de que al abrirse bloquean el resto (por seguridad).

Nota2: En netbeans7.0 (por defecto) no aparece en la lista el paquete "jDialog Form". Para ello, clic con botón izquierdo sobre icono paquete del proyecto y en el menu que aparece seguir el siguiente camino:

- New - Other - Swing GUI FORMS - jDialog form. [Next] -

Con la tecnología de Blogger.