Rich y JavaFx

Este es un tema que esta entrando cada vez más fuerte y es necesario que tengamos algunos conceptos . y es por ello que los vamos a explicar en pocas palabra y esperando que esto sea un inicio del aprendizaje de estas tecnologías.

Rich :( Aplicaciones Ricas de Internet) es un nuevo tipo de aplicación con más ventajas que las tradicionales aplicaciones , aumentar la facilidad de multimedia de las aplicaciones Web , disminuir la recarga de la pagina Web (del servidor), para una mejor performance de ellas , Se pueden utilizar desde cualquier ordenador con una conexión a Internet sin depender del sistema operativo que este utilice. Bueno estas son unas de las mas importantes características , pero existen muchas mas.

Recordando algunas tecnologías de java como los applet este podría ser un pequeño acercamiento a estas tecnologías , pero ya hace muchos años atrás,por ello java a creado JavaFx para afrontar estas nuevas tecnologías , pero considero que se demoro un poco.

Bueno ahora vamos a comentar algunas alternativas que existen para desarrollar .

Adobe AIR : permite combinar Flash y tecnologías AJAX usadas hasta ahora para el desarrollo Web como Flex( leido que la lleva ). Se basa exclusivamente en tecnologías de programación web y permite ejecutar el software desarrollado sin requerir un navegador. Está disponible para Windows, Mac y Linux.

AJAX : tambiene esta considerada como tecnología Rich.

Silverlight de Microsoft :lleva la programación nativa de Windows, con sus tecnologías .Net a la web y lo mezcla con Flash y HTML,

Mozilla tiene Prism :como un apaño, una forma de que el usuario no dependa de tecnologías externas de terceros para disfrutar de aplicaciones offline. La idea de Mozilla es poder convertir servicios web en aplicaciones independientes del navegador.

Google Gears es una solución de Google para los usuarios que quieren disponer de sus aplicaciones y servicios web sin estar constantemente conectados a.

Y nuestro JavaFx : que por lo leido no se a desviado de la multiplatadorma al desarrollar esta tecnologia , trantando de integrar escritorio , celulares , web , etc.
para potenciar esta tecnologia java esta estipulando la descarga de su plataforma por medio de modulo y no por la maquina virtual que generalmente expanta a mucha gente , por motivo de incomodidad.

bueno no quiero detallar mas sobre esta tecnologia , porque como no soy experto , pero aqui dejare algunos link muy interesantes para aprender.

http://blogs.sun.com/chrisoliver/
http://es.sun.com/sunnews/press/2008/20080506.jsp
http://docs.google.com/Present?docid=avn83j2j7zf_10dzgx4ngh
http://learnjavafx.typepad.com/
http://www.sun.com/software/javafx/index.jsp
http://blogs.sun.com/Argentina_ambassador/entry/demos_de_javafx_en_javaone
http://javafx.com/

Patron de diseño MVC

bueno considero que este tema es muy importante , aunque esto es una parte muy pequeña , pero por lo menos tomamos una pequeña nocion sobre este tema.

El principal objetivo de la arquitectura MVC es aislar tanto los datos de la aplicación como el estado (modelo) de la misma, del mecanismo utilizado para representar (vista) dicho estado,así como para modularizar esta vista y modelar la transición entre estados del modelo(controlador). Las aplicaciones MVC se dividen en tres grandes áreas funcionales:


Vista :la presentación de los datos

Controlador :el que atenderá las peticiones y componentes para toma de decisiones
de la aplicación
Modelo :la lógica del negocio o servicio y los datos asociados con la
aplicación

El propósito del MVC es aislar los cambios. Es una arquitectura preparada para los cambios, que desacopla datos y lógica de negocio de la lógica de presentación, permitiendo la actualización y desarrollo independiente



Cada componente Swing tiene un modelo, y la vista y el controlador están unidos en el mismo componente. Además, la vista usa un UI Manager para renderearse. El modelo es el modelo de datos de la aplicación, está relacionado con los datos que la aplicación maneja.

Cuando se crea, cada componente crea un modelo interno. Se pude también crear un modelo por aparte, y asignárselo a uno o más componentes, que entonces compartirán los datos que presentan.

un buen link es :
http://java.sun.com/products/jfc/tsc/articles/architecture/

Swing empaqueta todos los controladores y vistas de un componente
dentro de un objeto denominado delegado UI. Por esta razón, la arquitectura
subyacente de Swing se denomina más acertadamente como modelo-delegado
que como modelo-vista-controlador. Idealmente, la comunicación entre el
modelo y el delegado UI es indirecta, permitiendo así tener asociado más de
un modelo a un delegado UI.

todo lo que mencione es una pinselada del tema y es necesario averiguar mas sobre el tema.

http://www.programacion.net/java/tutorial/jdcbook/7/#jdcbook_componentesymodelos

Observación a ArrayList

cuando queremos trabajar con un famoso array ,pero que no sabemos su largo ,
es necesario ocupar el ArrayList que pertenece a la interfaz List de las famosas colecciones de java , existen muchas otras interfaces que seria importante de averiguar , en mi caso me baje unos manuales de colecciones y de las otras interfaces como set y map aprendi lo básico y sus principales características , y considero que con eso me podré defender si alguna vez me salen en un código y así no daré la hora jajajajaja .
regresando al ArrayList o también el LinkedList que su forma de trabajar son las mismas , pero tienen rendimiento diferentes en algunas circunstancias , cabe destacar que cuando guardamos elementos estos son de tipo object y no del tipo que estamos guardando , esta es una gran diferencia con los array que si guardan un tipo .
entonces cuando necesitemos obtener un objeto tenemos que realizar un casting del tipo de objeto que guardamos.

Bueno existen muchas mas observaciones ,pero como experiencia personal realmente son muy útiles .

Un sencillo ejemplo:

/////////////////////////////////////////////////////////////////////////////
public class gato {

private String nombre=null;

public gato(String nombre) {

this.nombre=nombre;
}

public String me_llamo(){

return nombre;
}

}

////////////////////////////////////////////////////////////////////////////////


import java.util.*; // libreria necesaria

public class ejemplo_ArrayList {

public ejemplo_ArrayList() {
}

public static void main(String[] args){

ArrayList al=new ArrayList();
// es posible ArrayList al=new ArrayList(); asi no nos da una
//advertencia el compilador y tiene otros motivos pero para la otra lo explicamos

al.add(new gato("perla"));
al.add(new gato("timoteo"));
al.add(new gato("wily"));

Iterator it=al.iterator(); // nos sirve para recorrer el arrayList

while(it.hasNext()){

gato g=(gato)it.next(); // el casting que hable
System.out.println(g.me_llamo());

}

}

}

Transacciones en jdbc

Bueno despues que uno aprende a trabajar con jdbc seria interesante aprender este concepto que es muy util , imaginate que estas haciendo un programa que tengas que asegurarte que en un proceso se guarden obligatoriamente tres insert,por ello JDBC permite agrupar instrucciones SQL en una sola transacción. Así, podemos asegurar las propiedades ACID (Atomicidad, Consistencia, Aislamiento, Durabilidad) usando las facilidades transaccionales del JDBC.
El control de la transacción es realizado por el objeto Connection. Cuando una conexión se crea, por defecto es en modo auto - commit. Esto significa que cada instrucción individual SQL se trata como una transacción en sí misma, y se comprometerá en cuanto la ejecución sea terminada.

Ejemplo : tenemos dos insert , para que se guarden se tienen que guardar los dos bien .osea si aceptamos el primero y el segundo nunca se guarda o da un error el primero no se guarda.



//////////////////////////////////////////////
// primer boton


try{

if (con.getAutoCommit() )
con.setAutoCommit( false );

stat = con.createStatement();
//vamos hacer le primer insert


String unsql = "insert into persona values ('"+jTextField1.getText()
+ "', '" + jTextField2.getText() + "', '"
+jTextField3.getText()+ "', '" +jTextField4.getText()
+ "' )";
stat.executeUpdate(unsql);

}
catch(Exception e){
System.out.println(" "+e);
}

///////////////////////////////////////////////////////////

// segundo boton

try{

String unsql = "insert into persona values ('"+jTextField5.getText() + "', '" + jTextField6.getText() + "', '" + jTextField7.getText() + "', '" +jTextField8.getText() + "' )";
stat.executeUpdate(unsql);

con.commit();

}
catch(Exception e){

deshacer( ); // este metodo es importante

System.out.println(" "+e);
}

////////////////////////////////////////////////////////////

void deshacer( ) {
try {
con.rollback();
}
catch (SQLException e) {
System.out.println("Error. No hemos podido deshacer." + e.getMessage() );
}
}

////////////////////////////////////////////////////////////


aunque esta un podo desordenado el codigo, espero que dando una vuelta lo entiendan, sobre la conexion

Connection con; // variables de instancia
Statement stat ;

/** Creates new form ventana */
public ventana() { // en el constructor
initComponents();

try{

Class.forName("org.postgresql.Driver"); // este busca el jar de postgres
con = DriverManager.getConnection("jdbc:postgresql://localhost/arq2 tier", "postgres", "1234");


}
catch(Exception e){
System.out.println(" "+e);
}
}

Friendly , un modificador de acceso

que sucede si no se indica ningun tipo de especificador de acceso a la clase , entonces se define implicitamente como amistoso lo cual significa que todas las clases del paquete actual tienen acceso al miembro amistoso , pero todas las clases fuera del paquete tienen un accesos privado a esta clase.
el acceso amistoso permite agrupar clases relacionadas en un mismo paquete de forma que esta puedan interactuar entre si de forma sencilla .

este puede ser un detalle muy simple , pero en el momento de programar nos puede hacer pasar un mal momento y principalmente si programamos por capa( presentacion , controlador , logica de negocio , base de dato , factoria de servicios )

Mi propia excepcion

seria muy interesante poder crear nuestras propias excepciones , puesto que la logica de negocio lo puede solicitar


public class miExcepcion extends Exception {

public miExcepcion(String msg) {

super(msg);
}
}

/////////////////////////////////////////////

public class llamadaException {

public static void llamada() throws miExcepcion{

System.out.println("envio de error");
throw new miExcepcion("error enviado por mi");
}

public static void main(String[] args){

try{
llamada();

}catch(miExcepcion e){

e.printStackTrace(System.err);
}

}
}
///////////////////////////////////////////////////////////