Patrones de diseño en Java

A continuacion les dejo un ebook que me había encontrado en internet hace un tiempo, el cual contiene distintos patrones de diseño programados en Java.

Por acá les dejo el link para que lo descarguen: AQUI.

Eclipse SDK…programa para la astronomía. WTF?

Así es, según la web de descargas de Orange, el Eclipse SDK es un programa muy útil para la astronomía jajajajajajja. Acontinuación les muestro la descrición ahí dada para el Eclipse SDK:

Programa muy útil para los aficionados a la astronomía. Se trata de contemplar un eclipse y aprender de que manera se produce.
Consta de trece fotografías de la trayectoria, las cuales nos irá enseñando poco a poco, con una breve expliación de cada una de las fases.

Es increíble que pongan este tipo de descripciones jajjaaja siendo que en el link que pusieron hacia la web del autor se muestra claramente que NO es un programa de astronomía.

Vía: Microsiervos

WTF? encontré una descripción parecida en bajame.net. Al parecer esto es serio jajaja

Vía: esta la encontre yo mismo

Saludos desde

Ejemplo de Java + SQL + Netbeans

Después de un poco de retraso de este post y de tener un poco de tiempo sin postear algo, traigo este ejemplo (el tercero) de Java y MySQL bajo la plataforma Netbeans. El propósito de este post es crear una clase que realmente realiza las acciones básicas (agregar, modificar, eliminar, consultar) pero implementadas de una «mejor manera» comparada con los otros post que hay en este blog sobre este tema (tampoco quiero decir que sea la mejor ni mucho menos).

La base de datos que usaremos para este ejemplo es la siguiente:

• BD: prueba.
• tabla: usuarios.
• campos: id(autoinc), nombre, contraseña.

Diagrama de clases:

Bueno, primero que nada empezaremos con nuestra clase que contendrá los métodos de las acciones que vamos a realizar.

import java.sql.*;
import java.util.Hashtable;

public class SQLconnection {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;

public SQLconnection()
{
this.url = «jdbc:mysql://» + this.host + «/» + this.db;
}

public SQLconnection (String server, String usuario, String contraseña, String bd)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = server;
this.url = «jdbc:mysql://» + this.host + «/» + this.db;
}

public void connectar()
{
try {
Class.forName(«org.gjt.mm.mysql.Driver»);
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println(«Conexión a base de datos «+url+» … Ok»);
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println(«Hubo un problema al intentar conectarse con la base de datos «+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}

public String getDb() {
return db;
}

public void setDb(String db) {
this.db = db;
}

public String getHost() {
return host;
}

public void setHost(String host) {
this.host = host;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getUser() {
return user;
}

public void setUser(String user) {
this.user = user;
}

public ResultSet consultar(String tabla) throws SQLException
{
rs = stm.executeQuery(«SELECT * FROM » + tabla);
return rs;
}

public String buscarNombre(String tabla, String nombre) throws SQLException
{
String name = null;
try{
rs = stm.executeQuery(«SELECT * FROM » + tabla + » WHERE nombre = ‘»+ nombre +»‘ LIMIT 1″);
rs.next();
name = rs.getString(2);
}catch(SQLException ex){System.out.println(ex);}
return name;
}

public void insertar(Hashtable usuario)
{
try {
stm.execute(«INSERT INTO usuarios (nombre, contraseña) VALUES (‘» + usuario.get(«nombre») + «‘,'» + usuario.get(«contraseña») + «‘)»);
} catch (SQLException ex) {
System.out.println(ex);
}
}

public void actualizar(String tabla, Hashtable usuario, String nombre)
{
try {
stm.execute(«UPDATE » + tabla + » SET nombre='» + usuario.get(«nombre») + «‘ WHERE nombre='» + nombre + «‘»);
} catch (SQLException ex) {
System.out.println(ex);
}
}

public void eliminar(String tabla, String nombre)
{
try {
stm.execute(«DELETE FROM » + tabla + » WHERE nombre='» + nombre + «‘»);
} catch (SQLException ex) {
System.out.println(ex);
}
}
}

Como podemos observar, esta clase cuenta con sobrecarga de constructores lo cual nos permite conectarnos de 2 maneras distintas a la base de datos. La primera es utilizar el constructor que no recibe ningún parámetro y definirlos mediante los métodos set y get para después llamar al método conectar. La segunda es enviarle directamente los valores al constructor  y, al igual que en la forma anterior, ejecutar el método conectar, y esta será la forma que usaremos para nuestro ejemplo.

Primero que nada vamos a conectarnos a nuestra base de datos y realizaremos una consulta de todos los registros:

SQLconnection con = new SQLconnection(«localhost», «usuario», «contraseña», «prueba»);
con.connectar();
ResultSet rs;
rs = con.consultar(«usuarios»);
while(rs.next()){
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(rs.getString(3));
}

En esta clase también implementamos una opción que nos permite realizar búsquedas por medio de nombres(es el campo de la base de datos que elegí para este ejemplo); ha este método le mandamos 2 parámetros, que son la base de datos y el nombre:

System.out.println(con.buscarNombre(«usuarios», «frago»));

Para insertar un nuevo registro vamos a hacer uso del Hastable para enviarle los valores que queremos agregar:

Hashtable usuario = new Hashtable();
usuario.put(«nombre», «frago»);
usuario.put(«contraseña», «xxx»);
con.insertar(usuario);

Para eliminar un registro simplemente le ejecutamos el método correspondiente y le pasamos como parametros la tabla y el nomrbe del usuario a eliminar:

con.eliminar(tabla, «frago»);

Para actualizar un registro le tenemos que pasar 3 parámetros al método. EL primero es el nombre de la tabla; el segundo es un Hastable en el que se incluya la modificación que se quiere realizar y el tercer es, en este caso, el nombre de la persona a la que se le va realizar la modificación:

Hashtable usuario = new Hashtable();
usuario.put(«nombre», «frago1»);
con.actualizar(tabla, usuario, «frago»);

El proyecto en netbeans pueden descargarselo AQUI

Ejecutar SQL en Java

En esta ocasión veremos como ejecutar sentencias SQL en Java, tomando en cuenta la conexión que realizamos a la base de datos anteriormente.

Para este ejemplo uso una tabla llamada «usuarios», la cual tiene únicamente 3 campos: id(autoinc), nombre y contraseña

El código de la clase es el siguiente:

import java.sql.*;
public class Conexion {
private String user;
private String password;
private String db;
private String host;
private String url;
private Connection conn = null;
private Statement stm;
private ResultSet rs;
public Conexion(String usuario, String contraseña, String bd, String servidor)
{
this.user = usuario;
this.password = contraseña;
this.db = bd;
this.host = servidor;
this.url = "jdbc:mysql://" + this.host + "/" + this.db;
}
public void conectar()
{
try {
Class.forName("org.gjt.mm.mysql.Driver");
conn = DriverManager.getConnection(url, user, password);
if (conn != null)
{
System.out.println("Conexión a base de datos "+url+" ... Ok");
stm = conn.createStatement();
}
}
catch(SQLException ex) {
System.out.println("Hubo un problema al intentar conectarse con la base de datos "+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
public void consultar() throws SQLException
{
rs = stm.executeQuery("SELECT * FROM usuarios");
while(rs.next())
{
System.out.println(rs.getString("nombre"));
System.out.println(rs.getString("contraseña"));
}
}
public void actualizar() throws SQLException
{
stm.execute("UPDATE usuarios SET nombre='nombre usuario' WHERE id="+1);
}
public void insertar() throws SQLException
{
stm.execute("INSERT INTO usuarios (nombre, contraseña) VALUES ('new_name', 'new_Pass')");
}
public void eliminar() throws SQLException
{
stm.execute("DELETE FROM usuarios WHERE id="+1);
}
}

Únicamente resta crear una instancia de la clase y empezar a utilizar sus métodos.

Conectar Java con MySQL en NetBeans

Dentro de unas semanas tendré que desarrollar, junto con un equipo de trabajo, un sistema de un almacen en Java bajo la plataforma de NetBeans. Es por eso que comenzaré a pubicar una serie de post sobre cómo manejar bases de datos de MySQL con Java, y en los cuales poco a poco iré agregando nuevas funcionalidades.

Por ahora solo mostraré cómo realizar la conexión a la base de datos de MySQL.

Para comenzar debemos de tener instalado NetBeans, en lo particular yo tengo instalada la versión 6.0. Posteriormente debemos descargar un Driver o Conector para poder conectarnos a la base de datos. Se puede decir que ese Driver sabe «cómo hablar con la base de datos», yo descargué la versión 5.0.

Una vez descargado el archivo, extraemos los componentes, de estos el archivo que nos interesa es mysql-connector-java-5.0.5-bin.jar , este jar es la clase o Driver que nos permitirá conectarnos a la base de datos.

Ahora tenemos que hacer que esa clase esté accesible para nuestros proyectos, así que la vamos a guardar en la carpeta <DIRECTORIO_DE_JAVA>/jre/lib/ext. Si has realizado una instalación por defecto del NetBeans en Windows, entonces estará en: C:\Archivos de programa\Java\jdk1.6.0_04\jre\lib\ext. En esta carpeta es donde se agregan los jar adicionales, y así ya los tendremos disponibles para cuando necesitemos usarlos de nuevo.

Ahora que ya tenemos el conector a la base de datos pasaremos a la parte del NetBeans:

1. Creamos un nuevo proyecto: New Project -> Java -> Desktop Application (Basic application).
2. Agregamos un botón al formulario y le cambiamos su label a «Cargar datos».
3. Agregamos una nueva clase llamada TestConnection
   import java.sql.*;
public class TestConnection {
public String bd = "nombre_bd";
public String login = "usuario";
public String password = "contraseña";
public String url = "jdbc:mysql://localhost/"+bd;
public void conectar() {
Connection conn = null;
try {
Class.forName("org.gjt.mm.mysql.Driver");
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("Hubo un problema al intentar conectarse con la base de datos "+url);
}
catch(ClassNotFoundException ex) {
System.out.println(ex);
}
}
}

4. Hacemos doble clic en el boton «Cargar datos» y colocamos el siguiente código:
   sourcecode language=’java’ [
   TestConnection conexion = new TestConnection();
conexion.conectar();

]

Y listo!!!. Con esto ya tenemos realizada la conexión a la base de datos de MySQL

Espero que les sirva!!!

Relacionados:

• Ejecutar SQL en Java
• Ejemplo Java + SQL en Netbeans