sábado, 30 de abril de 2011

Tipos de Tablas en MySQL


Cuando se trabaja con MySQL, existe la opción de variar el tipo de tabla después de creada (salvo con las tablas del sistema llamadas MySQL y test , que por defecto son MyISAM y no se recomienda modificarlas).

Para indicar el tipo de tabla al crearla usamos la siguiente sintaxis:

CREATE TABLE tabla1 (
campo1 INT(4) UNSIGNED,
campo2 VARCHAR(25) NOT NULL
) ENGINE=MYISAM;




Si se omite la opción ENGINE=... por defecto se crea una tabla MyISAM.

Importante: según MySQL, la opción TYPE (similar a ENGINE) es soportada hasta la versión 4.x de MySQL (dejará de usarse a partir de la 5). La opción ENGINE fue añadida en la versión 4.0.18 del lenguaje (para las series 4.x) y en la versión 4.1.2 (correspondiente a las versiones 4.1).

Si se intenta crear un tipo de tabla no disponible en nuestra versión, MySQL optará por crear una tabla tipo MyISAM.

A continuación, haremos una reseña de los tipos de tablas soportados.

ISAM

En un principio, el gestor de bases de datos MySQL empezó utilizando este tipo de tablas y, actualmente, se las considera en desuso. Entre sus desventajas figura el hecho de no poder transportar archivos entre máquinas con distinta arquitectura (tiene un formato diferente para cada arquitectura / sistema operativo, lo cual resulta más rápido, pero presenta el problema de la incompatibilidad) y el de no manejar archivos de tablas superiores a 4 GB.

Los índices se guardan en archivos .ISM y los datos, en archivos .ISD. MySQL recomienda actualizar este tipo de tablas hacia las de tipo MyISAM. Esto puede hacerse con la siguiente instrucción SQL:


ALTER TABLE nombre_de_la_tabla ENGINE = MYISAM;



MyISAM

Es el tipo de tabla por defecto en MySQL desde la versión 3.23 y está basada sobre las tablas ISAM, por supuesto que ofreciendo más opciones que éstas. Cuando se usan estas tablas, los datos se almacenan físicamente en dos archivos: uno que tiene la extensión .MYI (MYISAM INDEX), en donde se almacenan los índices, y otro .MYD (MYISAM DATA), donde se almacenan los datos.

Se encargan de proveer un almacenamiento independiente: esto significa que se pueden copiar tablas de una máquina a otra de distinta plataforma.

Si estamos trabajando con MySQL en forma local, normalmente, se podrá ver en el propio equipo que estos archivos se almacenan en una carpeta que tiene por nombre una base de datos (estas carpetas están en el directorio data dentro del directorio en donde se instaló MySQL, y allí hay una carpeta por cada base de datos). Esto vale también para otros tipos de tablas.

Además:
• Soportan archivos de gran tamaño (63 bits, archivos de tablas superiores a 4 GB)
en comparación con los que soportaban las ISAM.
• Están optimizadas para sistemas operativos de 64 bits.
• Posibilidad de indexar campos BLOB y TEXT.
• Se permiten valores NULL en columnas indexadas.
• Cada tabla guarda un registro que indica si fue cerrada correctamente o no, y al iniciar MySQL existe la opción de indicarle que se verifique ese registro, y se repare la tabla de ser necesario, de forma automática. Esto se logra iniciando MySQL con la opción:

--myisam-recover

Si se encontró un error, trata de repararlo de forma rápida ordenando los registros de la tabla. Si éste persiste, se vuelve a crear el archivo que contiene la tabla. Y si continúa existiendo, se intenta repararlo escribiendo los registros sin un ordenamiento.
• Inserts concurrentes (se pueden insertar varios registros al mismo tiempo).

MERGE

Este tipo de tabla es muy utilizada en los casos en que se precise tratar un número N de tablas MyISAM (de idéntica estructura y pertenecientes a la misma base de datos, de la que también deberá formar parte la tabla MERGE) como si fuera una sola.

Esto podría aplicarse si la tabla MyISAM original es de gran tamaño, y acceder a su contenido llevará una cantidad considerable de tiempo y recursos. Obviamente, estamos hablando de una tabla realmente muy grande.

Otras características:
• Sólo se pueden aplicar instrucciones SELECT, DELETE y UPDATE.
• La definición de la tabla se almacena en un archivo .FRM, y el listado de las tablas MyISAM, en un archivo .MRG (aquí hay en realidad un índice de los archivos .MYI usados. Ver tablas MYISAM).
• Permiten de alguna forma burlar el tamaño máximo de una tabla y el tamaño máximo de un archivo en un sistema operativo específico.
• Debemos saber que si queremos borrar una de las tablas MyISAM que forma parte de la tabla MERGE, no podremos hacerlo bajo el sistema operativo Windows, ya que éste no permite borrar archivos que estén abiertos, y la tabla, al formar parte de la tabla MERGE, se considera abierta. Por la misma razón se producen inconvenientes al aplicar instrucciones tales como DROP TABLE, ALTER TABLE, DELETE FROM sin WHERE, REPAIR TABLE, TRUNCATE TABLE, OPTIMIZE TABLE y ANALYZE TABLE. Una forma de solucionar esto es borrar el contenido de la tabla MERGE (aplicando la instrucción DELETE sin WHERE a una tabla MERGE, no se borra el contenido de las tablas MyISAM sino que se las quita del listado de componentes de la tabla MERGE). Así estas tablas se considerarán no abiertas.

Cuando se crea una tabla de este tipo hay que especificar (con la instrucción UNION) la lista de tablas asociadas. Veamos un ejemplo.

CREATE TABLE t1 (a INT AUTO_INCREMENT PRIMARY KEY, mensaje CHAR(20));
CREATE TABLE t2 (a INT AUTO_INCREMENT PRIMARY KEY, mensaje CHAR(20));

INSERT INTO t1 (mensaje) VALUES ("uno");
INSERT INTO t1 (mensaje) VALUES ("dos");
INSERT INTO t1 (mensaje) VALUES ("tres");
INSERT INTO t2 (mensaje) VALUES ("cuatro");
INSERT INTO t2 (mensaje) VALUES ("cinco");
INSERT INTO t2 (mensaje) VALUES ("seis");

CREATE TABLE total (
a INT AUTO_INCREMENT PRIMARY KEY,
mensaje CHAR(20)
)
ENGINE=MERGE UNION=(t1,t2) INSERT_METHOD=LAST;

SELECT * FROM total;




Devolvería algo como:

1 uno
2 dos
3 tres
1 cuatro
2 cinco
3 seis

El parámetro INSERT_METHOD especifica en qué tabla se realizarán los INSERTS; si en la primera de la lista (poniendo INSERT_METHOD=FIRST) o en la última (poniendo INSERT_METHOD=LAST). En nuestro caso la tabla t1 es la primera y t2 es la última.

HEAP

Este tipo de tablas tienen una particularidad que las hace diferentes del resto: son tablas en memoria, son temporales y desaparecen cuando el servidor se cierra.

Es importante saber que esto las hace realmente rápidas y que, a diferencia de una tabla TEMPORARY, que sólo puede ser accedida por el usuario que la crea, una tabla HEAP puede ser utilizada por diversas personas.

Algunas otras particularidades:
• No soportan columnas de tipo BLOB o TEXT.
• No soportan columnas de tipo AUTO_INCREMENT.
• No se permiten valores NULL en las columnas que han sido indexadas (antes de MySQL en la versión correspondiente a la 4.0.2).
• Siempre conviene especificar el número máximo de filas (MAX_ROWS) cuando se crea la tabla, para no usar toda la memoria disponible.

InnoDB

Debemos saber que estas tablas, al igual que las BerkeleyDB, son TST: este término significa Transactions Safe Tables, o tablas para transacciones seguras. Las tablas tipo TST son menos rápidas y ocupan más memoria, pero a cambio ofrecen mayor seguridad frente a fallos durante la consulta.

Además, las tablas InnoDB tienen las siguientes características:
• Proveen la posibilidad de transacciones seguras. ACID (Atomicidad; Consistencia; Separación, en inglés Isolation y Durabilidad).
• Recuperación ante fallos.
• Soporta FOREIGN KEY (Claves foráneas). Primera vez que se da esto en MySQL.
• Bloqueo a nivel de fila.
• Permite realizar copias de seguridad mientras la base está funcionando.
• Gran eficacia en el procesamiento de grandes volúmenes de información.
• No permite crear claves sobre columnas de tipo BLOB o TEXT.
• Una tabla no puede tener más de 1000 columnas.
• Al borrar todas las filas de una tabla las borra una por una –lo que produce problemas relacionados a la velocidad. Hasta ahora puede truncar tablas.

Fueron agregadas en la versión 4.0 de MySQL.

BerkeleyDB

Estas tablas pueden ser usadas independientemente de MySQL: están desarrolladas por otra empresa (Sleepycat) y el gestor de bases de datos MySQL ofrece una interfaz para trabajar con ellas como una posibilidad más.
• Soportan operaciones COMMIT y ROLLBACK.
• Es de tipo denominado TST (Transactions Safe Tables). Podemos ver tablas INNODB para obtener más información acerca de este tema.
• Normalmente, para instalarlas hay que buscar una versión de MySQL que incluya soporte para este tipo de tablas, y habilitar la opción al momento de la instalación (––with*berkeley–dboption).
• En el archivo en donde se guardan los datos también se guarda la ruta a ese mismo archivo, de modo que no es posible cambiar la base de directorio.

¿En qué casos usar cada una?

Como siempre, la respuesta depende de lo que tengamos que hacer. Las tablas que normalmente se usan hoy en día son las MyISAM, pero pronto (quizás muy pronto) se comenzarán a usar las INNODB, especialmente por la posibilidad de crear relaciones entre tablas (fundamental en el modelo relacional) y ofrecer mayores prestaciones respecto de la seguridad, además de las transacciones.

Las ISAM están prácticamente en desuso (incluso la empresa que desarrolla MySQL admite la posibilidad de que en su versión 5 ya no estén disponibles), y las demás tienen usos muy específicos e incluso compatibles con otros tipos: la clave está en estudiar los problemas que se necesita solucionar, y ver en cada caso qué conviene.

Envío de datos con PHP


En PHP es posible generar script para imitar el envío de datos a través de formularios que utilizan el método POST usando las cabeceras necesarias para que el navegador reconozca la petición. Veamos un ejemplo:




//Lleno los datos a enviar.
$contenido[] = “x=$x”;
$contenido[] = “y=$y”;
$contenido[] = “z=$z”;

$contenido = implode(“&”,$contenido);

$logitud = strlen($contenido);

$peticion .= “POST /pagina.php HTTP/1.1\r\n”;
$peticion .= “Host: xservidor.com\r\n”;
$peticion .= “Content-Type: application/x-www-form-urlencoded\r\n”;
$peticion .= “Content-Length: $logitud\r\n”;
$peticion .= “Connection close\r\n”;
$peticion .= “\r\n”;
$peticion .= $contenido;

if ($manejador = fsockopen(“servidor.com”, 80)) {

fputs($manejador, $peticion);

while (!feof($manejador)) {
$respuesta .= fgets($manejador, 1024);
}

fclose($manejador);
}



Con este script podremos testear nuestros formularios o se podría usar para ingreso de datos masivos. Pero también para ataque a nuestro sitios por lo que deberíamos usar un captcha para prevenir estos ataques.

jueves, 28 de abril de 2011

Autenticación en JSF

Como todos sabemos la seguridad se puede dividir en 3 aspectos:

  • Autenticación: que el usuario sea realmente quien dice ser.
  • Autorización: que el usuario pueda hacer solo lo que el tenga permiso de hacer.
  • Seguridad de Datos: que el usuario vea los datos que el realmente puede ver.

No todas las aplicaciones necesitan todas estos aspectos, por ejemplo una aplicación menor de una intranet no necesariamente necesita la seguridad de datos.

Vamos a atacar la autenticación. Con JSF podemos autenticar a nuestros usuarios de diferentes maneras.

Una forma es por medio del contenedor, todos los contenedores web manejan el concepto de seguridad y la posibilidad de autenticar a un usuario. Muchas aplicaciones solo necesitan la autenticación; por lo tanto lo podemos hacer a nivel contenedor. Este provee tres formas: basic, form-based, y client certificate. Veamos un ejemplo de autenticación basic, agregando las siguientes lineas al web.xml :








BASIC
UserDatabase





La autenticación básica trajo con sigo el concepto de realm. Un realm es un objeto que representa al usuario y su autenticación. Realm no es un concepto estándar y se implementa de forma diferente en los contenedores. Por ejemplo en Apache Tomcat es un simple archivo xml:














Otra posible autenticación es basado en formularios, esta solución fue creada antes de JSF y no es recomendada si la autenticación debe estar integrada a la aplicación:



FORM
UserDatabase

/faces/login.jsp
/faces/loginError.jsp




Otra posibilidad es integrar el login a nuestra aplicación. Vamos a profundizar esta opción que es la más utilizada.

Lo que deberíamos hacer es una aplicación la cual no se pueda acceder a ninguna pagina sin antes logearse, y si alguien intenta acceder a la pagina esta lo redireccionara a la pagina de login. En el login el usuario podrá logearse y así poder realizar sus tareas.

El concepto de servler filter, implementado en la versión 2.3 de servlet y redefinido en 2.4 permite operar sobre una request antes que esta sea procesada. Esto nos permite chequear si el usuario esta logueado cuando quiere acceder a alguna pagina. Entonces declaremos nuestro filtro en el web.xml:



Require that the user log in before accessing any page
other than the entry pages

ForcedLoginFilter
org.assembly.util.ForcedLoginFilter



ForcedLoginFilter
*.jsp
REQUEST
FORWARD



Y la clase ForcedLoginFilter es la siguiente:


package org.assembly.util;

import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

public class ForcedLoginFilter implements Filter {
private static final String LOGIN_JSP = "login.jsp";

public ForcedLoginFilter() {
}

private static boolean checkLoginState(ServletRequest request,
ServletResponse response) throws IOException, ServletException {
boolean isLoggedIn = false;
HttpSession session = ((HttpServletRequest) request).getSession(false);
UserBean managedUserBean = null;
// If there is a UserBean in the session, and it has
// the isLoggedIn property set to true.
if (null != session
&& (null != (managedUserBean = (UserBean) session
.getAttribute("UserBean")))) {
if (managedUserBean.isIsLoggedIn()) {
isLoggedIn = true;
}
}
return isLoggedIn;
}

public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

boolean isLoggedIn = checkLoginState(request, response);

if (isRedirect((HttpServletRequest) request) && !isLoggedIn) {
String loginURI = LOGIN_JSP;

RequestDispatcher requestDispatcher = request
.getRequestDispatcher(loginURI);

// Force the login
requestDispatcher.forward(request, response);
return;
} else {
try {
chain.doFilter(request, response);
} catch (Throwable t) {
// A production quality implementation will
// deal with this exception.
}
}
}

private boolean isRedirect(HttpServletRequest request) {
String requestURI = request.getRequestURI();

return (!requestURI.contains(LOGIN_JSP));
}

@Override
public void destroy() {
// TODO Auto-generated method stub

}

@Override
public void init(FilterConfig arg0) throws ServletException {
// TODO Auto-generated method stub

}
}




Las clases que son filtros deben implementar la interfaz Filter. En este caso lo que hace el filtro es verificar que existe el usuario en la session y si la url es redirecciónable, dado que si al ir a login redireccionamos se formara un bucle infinito.

El objeto UserBean es el encargado de representar un usuario.


package org.assembly.util;

public class UserBean {

private String userName;

private String userPassword;

public UserBean(String userName, String userPassword) {
this.userName = userName;
this.userPassword = userPassword;
}

public boolean isIsLoggedIn() {
return true;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public String getUserPassword() {
return userPassword;
}

public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}

}





Entonces ahora debemos crear la pagina login.jsp que sera como la siguientes



<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

< html>
< head>
< meta http-equiv="Content-Type" content="text/html; charset=UTF-8">


Base de Contribuyentes


< /head>
< body background="black">











action="#{loginBean.validate}" />







< /body>

< /html>




Y luego debemos crear el managed bean que sera como este:


package org.assembly.util.login;

import javax.faces.context.FacesContext;
import org.assembly.util.UserBean;

public class LoginBean {

private String userName;

private String userPassword;

public String validate() {

// Validar si la contraseña y pass son correctas.
// si hay un error return null;

UserBean user = new UserBean(userName, userPassword);

FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
.put("UserBean", user);

return "index";
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public String getUserPassword() {
return userPassword;
}

public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}

}



Luego debemos declarar en el face-config.xml nuestro bean y la url login.



loginBean
org.assembly.util.login.LoginBean
request

...


login
/login.jsp




Este fue un pequeño ejemplo de login en jsf.

miércoles, 27 de abril de 2011

Pese al avance de los sistemas libres, el 78% de las computadoras usa Windows



Publico esta noticia de clarin, que la verdad no me gusta nada:

A pesar del avance del software libre, el Windows de Microsoft continuó dominando en 2010 el mundo de las computadoras con una cuota del 78,6% en el sector de los sistemas operativos, según el analista de mercado Gartner.

El porcentaje supera al de 2009, cuando Microsoft tenía un 77,9%. En total, el sistema operativo Windows permitió facturar a la compañía US$ 30.400 millones, lo que supone un incremento interanual del 7,8%.

Por su parte, Apple pudo elevar los aportes de sus sistemas operativos a la facturación total de 1,6 a 1,7 por ciento. Actualmente las computadoras Mac están experimentando un "boom", según Gartner, mientras que Microsoft se benefició del cambio del impopular Vista al nuevo Windows 7.

De acuerdo con Gartner, además de PCs y Mac, para su estudio tuvo también en cuenta las grandes computadoras corporativas, los llamados "servidores", donde IBM, HP o Oracle tienen mayor presencia. Entre los operadores de servidores el más popular resultó ser Linux.

Por que no cambiar a Linux?

Dejo link:

http://www.ieco.clarin.com/economia/Pese-sistemas-libres-computadoras-Windows_0_235200025.html

domingo, 24 de abril de 2011

Encriptar password con MySQL


Quien no tuvo que encriptar una password antes de guardarla en la base de datos? Como sabrán es una muy buena práctica guardar las password encriptadas dado que esto permite minimizar los daños a nuestros usuarios en caso que que un intruso consiga la forma de consultar la base y a la vez permite que los administradores del sistema no tengan conocimiento de las mismas, ni forma de saberlas.

Cuando trabajamos con MySQL, podemos usar las funciones md5 o sha1. Para probarlas podemos hacerlo de la siguiente forma:

> select md5('Holass');

> select sha1('Holass');

Recordemos que los algoritmos de encriptación md5 y sha1 son los más usados.

Para insertas un usuario con su password encriptado usando md5 podremos hacer lo siguiente:

> insert into usuario (nombre, clave) values ('nombre', md5('password'));

y si queremos verificar el usuario:

> select * from usuario where nombre = 'nombre' and clave = md5('password');

Además MySQL trae su propia función para encriptar llamade password:

> select password('Holass');

Dejo links:



jueves, 21 de abril de 2011

Soy Yeta


Soy Yeta o debo ser lo, por que en este blog comente que el browser flock era el futuro de los browsers, o por lo menos era lo que pensaba. Hoy me llego un mail que flock se discontinuo, que el soporte para este browser cesara el 26 de Abril y me invita a migrar a otros browsers como firefox o chrome.

Voy a intentar no predecir el futuro de otros productos; simplemente para que no cierren.


martes, 19 de abril de 2011

NoSQL vs NewSQL


Antes de empezar vamos a definir que es NoSQL y NewSQL.

Nos dice la wikipedia: NoSQL es un término usado en informática para agrupar una serie de almacenes de datos no relacionales que no proporcionan garantías ACID. Normalmente no tienen esquemas fijos de tablas ni sentencias "join".

"NewSQL" es la forma abreviada que nos referimos a los diversos nuevos vendedores de base de datos de alto rendimiento. Anteriormente se referian a estos productos como “ScalableSQL” para diferenciarlos de los productos de bases de datos relacionales tradicionales. Dado que esto implica escalabilidad horizontal, que no es necesariamente una característica de todos los productos.

Y para aclarar, como NoSQL, NewSQL no debe ser tomado demasiado literalmente: lo nuevo acerca de los vendedores NewSQL es el vendedor, no el SQL.

Entonces, ¿quiénes serían considerados vendedores NewSQL? Al igual que NoSQL, NewSQL se utiliza para describir un grupo de empresas o productos, lo que tienen en común es el desarrollo de nuevos productos y servicios de base de datos relacionales, diseñados para llevar los beneficios del modelo relacional a arquitecturas distribuidas, o para mejorar el rendimiento de bases de datos relacionales en la medida en que la escalabilidad es una necesidad.

Para nombrar algunas productos/empresas NewSQL: Clustrix, GenieDB, ScalArc, Goleta, VoltDB, RethinkDB, ScaleDB, Akiban, CodeFutures, ScaleBase, Translattice y NimbusDB...

Estos nuevos productos NewSQL solapan su funcionalidad con el NoSQL, permitiendo gran escalabilidad sin perder el modelo relacional y algunos productos se confunden con los productos NoSQL, haciendo la linea muy delgada.

Cual es el futuro de las bases de dato? NewSQL le ganara el puesto que gano NoSQL?

EL tiempo lo dirá...

Dejo links:



Publican Libro Gratuito de Scala


Es la primera edición de Programming in Scala, es buenisimo este aporte.

Dejo el link:

http://www.artima.com/pins1ed/

domingo, 17 de abril de 2011

Seguridad con JEE


JEE y EJB proveen un conjunto de servicios que los desarrolladores pueden integrar de forma declarativa o programática. Estos servicios incluyen autorización y autenticación.

Autenticación e identificación

La autenticación es comprobar que el usuario sea quien dice ser. En un sistema EJB un usuario es asociado con una identidad segurizada, esta esta lista para ser usada por los EJB. Cuando un cliente invoca un método de un EJB, el servidor pasa la identidad del cliente con la invocación del método. Cuando el contenedor de EJB recibe la invocación valida la identidad del usuario y si este puede invocar el método invocado.

La especificación EJB no indica como se autentica. Aunque esta definido como la seguridad se propaga del cliente al servidor, no esta definido como el cliente obtiene la identidad y la credencial con una invocación EJB, tampoco define como el servidor guarda y obtiene las autenticaciones.

Cuando accedemos a un EJB muchas aplicaciones utilizan la JNDI API, por ejemplo podemos autenticar el acceso a un EJB de este modo:

properties.put(Context.SECURITY_PRINCIPAL, "username");
properties.put(Context.SECURITY_CREDENTIALS, "password");
Context ctx = new InitialContext(properties);
Object ref = jndiContext.lookup("SecureBean/remote");
SecureRemoteBusiness remote = (SecureRemoteBusiness)ref;

En el ejemplo, el usuario es autenticado con la conexión a el “JNDI InitialContext”

Autorización.

Como sabemos en las aplicaciones no todos somos iguales, cada usuario tiene un rol ante una aplicación por ejemplo “administrador”, “empleado”, etc. y cada rol puede hacer o no determinadas acciones, es decir tiene o no tiene permiso para.

En EJB existen diferentes tipos de granularidad de permisos, puede ser por usuario o por rol. Esto permite que la autenticación sea un proceso separado de la autorización.

Los roles son definidos de forma logica y pueden representar roles, grupos de usuarios, o cualquier otro sistema de identificación. Los roles del los EJB son mapeados a los usuarios y grupos reales cuando el bean es deployado.

La autorización esta bien definida en la especificación EJB. Se declaran los roles de forma programática y luego se indican los permisos a los beans por medio de anotaciones o declararlos en ejb-jar.xml

Vimos de forma teoría la seguridad en EJB, en un próximo post vamos a hace algo más práctico.

Por que no EJB 3?


Soy un promovedor del uso de Spring pero por X motivo estoy estudiando un poco JEE 5 y la verdad estoy sorprendido por su simpleza, cambio mucho. Lo único que critico es que el tiempo de levantar jboss o glassfish o otro servidor JEE es mayor que usar solo tomcat o jetty (obviamente).

La especificación EJB 3 deja atrás el mal sabor que tenían las anteriores versiones de EJB a la hora de desarrollar. El paso más importante ahora los EJB son pojos, que por medio de anotaciones se infiere el comportamiento. No es necesario heredar de ningún objeto, ni hacer interfaces (gracias a Dios).

Veamos los tipos de beans que existen:

Session EJB: Son los beans que tienen las acciones; son los que tienen la lógica del negocio. Este tipo de bean viene en 2 sabores Stateless (no mantiene el estado en el servidor) o Statefull (mantiene el estado en el servidor). Además se agrego un Sigleton Beans, para cuando necesitamos solo una instancia de nuestro objeto de negocio.

Message-Driven Beans: La mensajería asíncrona es un paradigma en el cual dos o más aplicaciones se se comunican mediante un mensaje que describe un evento de negocio. Estos beans pueden generar mensajes asíncronos y consumirlos.

Entity Beans: Son objetos que modelan nuestros datos (Pojos) y son persistidos por medio del javax.persistence.EntityManager. Usando JPA (descripto en JSR-317) podemos persistir nuestros entity beans como si usáramos un ORM común.

Este es un pequeño resumen de la que nos brinda EJB 3. En próximos post ampliaremos!!


miércoles, 13 de abril de 2011

Java Magazine is Coming!


La idea es que en fines de julio va salir la revista oficial de Java gratuita. Es una interesante propuesta de oracle.

Todavía no se encuentra un nro publicado pero ya nos podemos registrar.

Dejo el link:

martes, 12 de abril de 2011

java.util.Objects la nueva librería de java 7!


La verdad es que mucho no me gusta (sera resistencia al cambio), yo pienso que le roba trabajo a los objetos, para mi debería estar esta funcionalidad en Object o de otra forma, no lo se.

Más allá de mi humilde opinión era necesaria, siempre teníamos que escribir un util que haga cosas que hora hace esta librería.

Veamos unos ejemplos:


public void showFoo(Foo foo) { Foo foo2 = new Foo();

//lot of code

if(foo.equals(foo2)) {
System.out.println("Two Men");
} else {
System.out.println("And a Half");
}
}



Esto puede dar NullPointer veamos como lo resolvemos con Objects:

public void showFoo(Foo foo) {

Foo foo2 = new Foo();

//lot of code

if(Objects.equals(foo,foo2)) {
System.out.println("Two Men");
} else {
System.out.println("And a Half");
}
}



Podemos hacer el hash con Objects, que sera de org.apache.commons.lang.builder.HashCodeBuilder

@Override public int hashCode() {
return Objects.hash(name, age, job);
}



Podemos chequear que un objeto no sea null

public void showFoo(Foo foo) {
this.bar = Objects.requireNonNull(foo);
}



Podemos tomar tomar el toString si no es nulo, y de lo contrario devolver un valor:

return Objects.toString(foo, “Foo is Empty”);


Interesante no? que les parece la nueva librería?

Fuente: http://alexsotob.blogspot.com/2011/04/another-shot-of-whiskey-cant-stop.html


sábado, 9 de abril de 2011

La historia de linux

Con motivo de los 20 años de Linux se realizo el siguiente vídeo que explica la historia del sistema operativo.



domingo, 3 de abril de 2011

GO


...no voy a cambiar, no voy a cambiar mi modo
ellos me dicen : "nena,
nena vos lo tenes todo."
Oh, negro go...

Rara forma de empezar un post del no tan famoso lenguaje de google Go!

El pequeño párrafo de la canción de los piojos “go negro go” resume un poco mi sensación con respecto a este lenguaje, es como que tiene todo pero hecho como le gusta a google. Que no digo que este mal, pero por ahí tantas vueltas de rosca no son muy buenas a veces.

El lenguaje de programación Go es un proyecto de código abierto con el objetivo de la productividad en los programadores.

Go es expresivo, conciso, limpio y eficiente. Sus mecanismos de concurrencia hace fácil escribir programas que sacan el máximo provecho a múltiples núcleos y las máquinas en red, mientras su novedoso sistema de tipado permite la construcción de programas flexibles y modulares. Compila rápidamente a código de máquina, pero tiene la comodidad del garbage collection y el poder de reflexión en tiempo de ejecución.

Veamos un ejemplo:

package main

// fib returns a function that returns
// successive Fibonacci numbers.
func fib() func() int {
a, b := 0, 1
return func() int {
a, b = b, a+b
return b
}
}

func main() {
f := fib()
// Function calls are evaluated left-to-right.
println(f(), f(), f(), f(), f())
}

La salida de este programa es: 1 2 3 5 8

Se puede ver fácilmente la influencia de python y c++

Veamos un hola mundo:

package main

import fmt "fmt" // Package implementing formatted I/O.

func main() {
fmt.Printf("Hello, world; or Καλημέρα κόσμε; or こんにちは 世界\n")
}

Go es un lenguaje compilado. Para compilar este programa podemos utilizar Gccgo que utiliza GCC. También hay una serie de compiladores para diferentes arquitecturas por ejemplo: 6g para 64-bit x86, 8g para 32-bit x86, etc. Estos compiladores corren más rapido que Gccgo pero generan codigo menos eficiente. Veamos como compilar y correr go:

$ 6g helloworld.go # compile; object goes into helloworld.6
$ 6l helloworld.6 # link; output goes into 6.out
$ 6.out
Hello, world; or Καλημέρα κόσμε; or こんにちは 世界
o
$ gccgo helloworld.go
$ a.out
Hello, world; or Καλημέρα κόσμε; or こんにちは 世界


Dejo links como siempre:
http://golang.org/
http://wh3rd.net/practical-go/



sábado, 2 de abril de 2011

Recursos sobre Rails

Estoy estudiando un poco rails y encontré unos links de la apis de Rails.

Si quieren ver el código de rails:

git clone http://github.com/rails/rails.git
cd rails

Para ver la api de rails

http://api.rubyonrails.org
http://apidock.com/rails
http://railsapi.com

Espero que les sirva.