Quantcast
Channel: CoDejaVu
Viewing all 129 articles
Browse latest View live

Ejemplo eventos del mouse en Java

$
0
0
En nuestra secuencia Java Swing no podemos dejar pasar un tema muy importante cuando trabajamos con interfaces graficas......los eventos son fundamentales para este tipo de aplicaciones, por esa razón en está entrada veremos como funcionan los eventos del Mouse con un ejemplo básico pero útil para futuros desarrollos....


Que son?

Los eventos son básicamente las acciones que suceden al ejecutar o realizar alguna invocación..........a?........ un evento es una acción que podemos controlar cuando por ejemplo se ejecuta algún proceso, si ingresamos a cierto componente, presionamos un botón, movemos el mouse etc internamente el sistema identifica que es lo que se está haciendo, si hacemos clic, presionamos una tecla, movemos el mouse, todas esas son acciones que pueden ser identificadas y controladas.......

En Java estos eventos son conocidos como Listeners o escuchadores, cuando trabajamos con esto a la vez estamos aplicando conceptos de POO como es el trabajo con interfaces (en este enlace trabajamos con interfaces), ya que para poder hacer uso de cualquier tipo de evento debemos implementar la interface adecuada que nos permite realizar el proceso....en este ejemplo al trabajar con eventos del mouse implementaremos la interface MouseListener, que nos provee una serie de métodos importantes para controlar las acciones del ratón...

El Ejemplo.



Nuevamente como es costumbre, el ejemplo es muy simple, validaremos el funcionamiento mas común sobre los eventos del mouse.........tan solo vamos a presentar una ventana con un titulo y Botón central, el cual nos permitirá evaluar cuales son las acciones ejecutadas sobre el.....adicionalmente se le vincularán eventos al titulo para probar que estos no solo son aplicados a los botones sino a cualquier componente, ya que los eventos a utilizar dependen exclusivamente del mouse..........

La Aplicación.

El sistema consta de 2 clases, una clase principal que se llamará  Aplicacion.java que será la encargada de inicial el programa, también tenemos la clase Ventana.java que tendrá toda la parte gráfica de la ventana principal.

Aplicacion.java

Esta clase como se mencionó tan solo tendrá la instancia de la clase ventana y permitirá el llamado de la misma, como es común en los ejemplos presentados, se realiza así por organización....
public class Aplicacion {
public static void main(String args[]) {
Ventana ventana;
ventana = new Ventana();
ventana.setVisible(true);
}
}

Ventana.Java

Esta clase representa la ventana principal del sistema, como vemos implementa la interface MouseListener que permite el uso de los métodos mouseClicked(), mousePressed(), mouseReleased(), mouseExited(), mouseEntered(), los cuales capturan los eventos para cuando se hace clic, se presiona, se suelta, se sale, o se entra en algún componente respectivamente.....
class Ventana extends JFrame implements MouseListener {
JLabel etiqueta1, etiqueta2;
JLabel labelTitulo;
JButton boton1;

public Ventana() {
setLayout(null);
/**Propiedades del Label, lo instanciamos, posicionamos y
* activamos los eventos*/
labelTitulo= new JLabel();
labelTitulo.setText("Eventos del Mouse");
labelTitulo.setFont(new java.awt.Font("Comic Sans MS", 0, 28));
labelTitulo.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
labelTitulo.setBorder(javax.swing.BorderFactory.createBevelBorder
(javax.swing.border.BevelBorder.LOWERED));
labelTitulo.setBounds(40, 10, 300, 40);
labelTitulo.addMouseListener(this);

etiqueta1 = new JLabel();
etiqueta1.setBounds(10, 160, 190, 20);
etiqueta2 = new JLabel();
etiqueta2.setBounds(10, 180, 190, 20);

boton1 = new JButton();
boton1.setBounds(110, 75, 150, 75);
boton1.setText("Presioname");
boton1.addMouseListener(this);

add(labelTitulo);
add(etiqueta1);
add(etiqueta2);
add(boton1);

setTitle("CoDejaVu Eventos del Mouse");
setSize(400, 240);
}

public void mouseClicked(MouseEvent evento) {
if (evento.getSource() == boton1){
etiqueta1.setText("Hizo clic en mi botón");
}
if (evento.getSource() == labelTitulo){
etiqueta1.setText("Hizo clic en el Titulo");
}
}

public void mousePressed(MouseEvent evento) {
etiqueta1.setText("");
if (evento.getSource() == boton1){
etiqueta2.setText("Presiono el botón");
}
if (evento.getSource() == labelTitulo){
etiqueta2.setText("Presiono el Titulo");
}
}

public void mouseReleased(MouseEvent evento) {
if (evento.getSource() == boton1){
etiqueta2.setText("Libero el botón");
}
if (evento.getSource() == labelTitulo){
etiqueta2.setText("Libero el Titulo");
}
}

public void mouseExited(MouseEvent evento) {
if (evento.getSource() == boton1){
etiqueta1.setText("Salio del botón");
}
if (evento.getSource() == labelTitulo){
etiqueta1.setText("Salio del Titulo");
}
etiqueta2.setText("");
}

public void mouseEntered(MouseEvent evento) {
if (evento.getSource() == boton1){
etiqueta1.setText("Entro a mi botón");
}
if (evento.getSource() == labelTitulo){
etiqueta1.setText("Entro al Titulo");
}
etiqueta2.setText("");
}
}

Como vemos cada uno de los métodos de la interface MouseListener permite identificar cual es el componente al que se le asigna el evento y basado en eso interpreta cual es el mensaje que se debe mostrar en pantalla.

Es importante tener muy presente que se debe indicar que componentes van a hacer uso de los eventos del mouse, esto mediante el uso de addMouseListener(this), por ejemplo para el botón se pone:
labelTitulo.addMouseListener(this);

diciendo así que el botón va a escuchar los eventos del ratón, si esta linea se omite, el boton no podria interpretar los eventos......... y listo!!!

un ejemplo simple, rápido y fácil de entender.....mas adelante veremos otros eventos comunes pero con el uso del teclado, espero que les pueda servir ;)



También te podría Interesar.


¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir
 y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Ejemplo Eventos del Teclado en Java

$
0
0
En la entrada anterior tocamos el tema de los eventos del Mouse, en esta ocasión continuaremos trabajando con Eventos pero ahora del Teclado...

Vamos a hacer un ejemplo muy simple teniendo en cuenta que ya sabemos lo que es un evento (si no lo sabes, revisa el articulo anterior).....
en el ejemplo escribiremos en un área de texto y mediante eventos del teclado identificaremos y contaremos la cantidad de vocales escritas...

Este ejemplo es muy similar al anterior ya que también es necesario implementar una interface, en este caso la elegida es la KeyListener, que nos provee los métodos para controlar los eventos del teclado...

Al implementar la interface debemos implementar también los métodos que la componen, veamos cuales son y su funcionamiento básico:

keyPressed(KeyEvent e): Se ejecuta cuando el usuario presiona una tecla.
keyReleased(KeyEvent e): Se ejecuta cuando el usuario libera una tecla
keyTyped(KeyEvent e): Se ejecuta cuando el usuario presiona una tecla, pero solo cuando la tecla corresponde a caractéres, teclas especiales como F1, F2 entre otras no son identificadas.

Por lo regular el uso de estos métodos es muy especifico todo depende de lo que necesitemos ya que el evento de presionar y soltar pasa muy rápido y casi nunca nos damos cuenta cual evento se ejecutó, estos métodos son usados básicamente cuando queremos controlar al detalle lo que queremos que suceda si se hace una u otra acción...... mas abajo veremos esto en el ejemplo.....bueno ahora si a lo que vinimos.....

El Ejemplo.
Ventana Principal
Como se mencionó para este ejemplo vamos a trabajar con 2 JTextArea, una donde introduciremos el texto y otra donde veremos las vocales presionadas, así mismo podremos saber la cantidad de vocales que contiene el texto escrito.........adicionalmente agregaremos un evento a la tecla Esc para indicarle al sistema que el usuario quiere cerrar la aplicación....

Clase Aplicacion.

Esta clase es muy conocida pero nunca sobra ponerla, simplemente desde aquí por medio del método main() hacemos el llamado a la ventana principal...
public class Aplicacion {
public static void main(String args[]) {
Ventana ventana;
ventana = new Ventana();
ventana.setVisible(true);
}
}

Clase Ventana.

Esta clase corresponde a la interfaz gráfica de nuestro sistema, podemos ver que implementa la interface por medio del implementsKeyListener,  sin esto no podríamos capturar los eventos......veamos
class Ventana extends JFrame implements KeyListener {
JLabel labelTitulo;
JLabel labelAreaEntrada;
JLabel labelAreaSalida;
JLabel labelSalida;
JLabel labelContadorVocales;
JTextArea areaEntradaDeTexto;
JScrollPane scrollPaneAreaEntrada;
JTextArea areaSalidaDeTexto;
JScrollPane scrollPaneAreaSalida;

int cantidadVocales=0;
String vocales="";

public Ventana() {
setLayout(null);
iniciaComponentes();
//Asigna un titulo a la barra de titulo
setTitle("CoDejaVu : Ventana Eventos del Teclado");
//tamaño de la ventana
setSize(550,350);
//pone la ventana en el Centro de la pantalla
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

private void iniciaComponentes() {
labelTitulo= new JLabel();
labelTitulo.setFont(new java.awt.Font("Comic Sans MS", 0, 28));
labelTitulo.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
labelTitulo.setText("Eventos del Teclado");
labelTitulo.setBorder(javax.swing.BorderFactory.
createBevelBorder(javax.swing.border.BevelBorder.RAISED));
labelTitulo.setBounds(110, 20, 300, 40);

labelAreaEntrada= new JLabel();
labelAreaEntrada.setBounds(10, 70, 180, 40);
labelAreaEntrada.setText("Area Entrada de Texto");

areaEntradaDeTexto = new JTextArea();
areaEntradaDeTexto.setLineWrap(true);
areaEntradaDeTexto.addKeyListener(this);

scrollPaneAreaEntrada = new JScrollPane();
scrollPaneAreaEntrada.setBounds(10, 100, 513, 70);
scrollPaneAreaEntrada.setViewportView(areaEntradaDeTexto);

labelAreaSalida= new JLabel();
labelAreaSalida.setBounds(10, 170, 180, 40);
labelAreaSalida.setText("Area Salida de Texto");

areaSalidaDeTexto = new JTextArea();
areaSalidaDeTexto.setLineWrap(true);
areaSalidaDeTexto.addKeyListener(this);

scrollPaneAreaSalida = new JScrollPane();
scrollPaneAreaSalida.setBounds(10, 200, 513, 70);
scrollPaneAreaSalida.setViewportView(areaSalidaDeTexto);

labelContadorVocales = new JLabel();
labelContadorVocales.setBounds(380, 280, 190, 20);

labelSalida = new JLabel();
labelSalida.setText("Para salir presione la tecla Escape");
labelSalida.setBounds(10, 280, 210, 20);

add(labelTitulo);
add(labelSalida);
add(labelContadorVocales);
add(labelAreaEntrada);
add(labelAreaSalida);
add(scrollPaneAreaEntrada);
add(scrollPaneAreaSalida);

}

/**Este metodo se ejecuta cuando se presiona una tecla*/
@Override
public void keyPressed(KeyEvent e) {

if (e.getSource()==areaEntradaDeTexto)
{
if (e.VK_A==e.getKeyCode())
{
vocales+="a ";
cantidadVocales++;
}
if (e.VK_E==e.getKeyCode())
{
vocales+="e ";
cantidadVocales++;
}
if (e.VK_I==e.getKeyCode())
{
vocales+="i ";
cantidadVocales++;
}
if (e.VK_O==e.getKeyCode())
{
vocales+="o ";
cantidadVocales++;
}
if (e.VK_U==e.getKeyCode())
{
vocales+="u ";
cantidadVocales++;
}
}
areaSalidaDeTexto.setText(vocales);
labelContadorVocales.setText("Numero Vocales: "+cantidadVocales);
}

/**Este metodo se ejecuta cuando se suelta una tecla*/
@Override
public void keyReleased(KeyEvent e) {
System.out.println("Soltó la tecla: "+e.getKeyText(e.getKeyCode()));
if (e.getSource()==areaEntradaDeTexto)
{
if (e.VK_ESCAPE==e.getKeyCode())
{
int respuesta = JOptionPane.showConfirmDialog(this,
"Esta seguro que desea salir?", "Confirmación",
JOptionPane.YES_NO_OPTION);
if (respuesta == JOptionPane.YES_NO_OPTION)
{
System.exit(0);
}
}
}
}

/**Este metodo funcionará solo cuando se presionan caracteres,
*si se presionan teclas como F1, F2, inicio etc no ejecutará
*ningun evento*/
@Override
public void keyTyped(KeyEvent e) {
}
}

Es importante recalcar que también es de suma importancia indicarle al sistema cual es el componente que va a escuchar los eventos del teclado, en este caso vamos a escribir en un área de texto, si no se hace aunque tengamos la interface, no se reconocerán los eventos.... para eso se debe indicar agregando el addKeyListener(this) así:

areaSalidaDeTexto.addKeyListener(this);

Bueno teniendo esto mas claro ahora vamos a centrarnos en los métodos keyPressed(KeyEvent e) y keyReleased(KeyEvent e)...

En keyPressed validamos cuando se presionan las vocales para ir asignando los valores correspondientes al área de texto y a la variable que las cuenta......

En KeyReleased lo que hacemos es validar el evento cuando se presiona la tecla Escape para salir del sistema, al presionar la tecla se carga el mensaje....

Adicional a esto también imprimimos en consola cual es la tecla presionada, de esta manera nos damos cuenta cada espacio, enter, delete y cualquier tecla que utilicemos....


Viendo el código podríamos preguntarnos el porque hicimos el evento de salir en el KeyReleased, si esto también lo podríamos haber hecho sin problemas en el
KeyPresed.......o no?

Simplemente lo hicimos ahí para ver el ejemplo del que hablamos al principio..... cual método usar depende básicamente de lo que necesitemos.... los eventos suceden muy rápido pero en este caso, como queremos imprimir que tecla se liberó.... si hubiéramos puesto la validación de la tecla Escape al presionar el botón, entonces se cargaría el dialogo de confirmación y si es afirmativo se cerraría la aplicación, sin darnos tiempo de ver en consola que la tecla Escape fue liberada.... mientras que en el KeyReleased si alcanzamos a ver en consola que el escape se presionó....... en este caso no es algo tan grave, pero supongamos que eso sea algo muy importante y que no solo es mostrarse en consola sino almacenarse esa información en un archivo de texto siendo necesaria toda la información posible......

También es importante saber que aunque no utilicemos el método keyTyped, se debe dejar enunciado, ya que es un principio del trabajo con interfaces y debemos implementar todos los métodos de esta.... si no sabes a que me refiero te invito a leer esta entrada sobre interfaces...

Y listo aquí termina nuestro ejemplo, espero que les pueda servir y sea de fácil entendimiento...


También te podría Interesar.


¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir
 y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Como crear Interfaces Graficas en Eclipse con WindowBuilder

$
0
0
Después de mucho meditarlo, voy a explicarles cómo crear aplicaciones con interfaz gráfica desde Eclipse, similar a como se hace en Netbeans, para eso primero que todo instalaremos el plugin necesario y posteriormente crearemos una ventana con la herramienta….

En una entrada anterior vimos el procedimiento de vincular un plugin usando la actualización de Software desde el IDE, ahora veremos otro proceso descargando el empaquetado y copiándolo en los archivos de instalación del Eclipse….al final tambien dejaré un video paso a paso para mayor facilidad....


Y porque meditarlo?

Las personas que siguen el blog saben que hace un tiempo hice una entrada donde doy mi opinión sobre la eterna discusión Eclipse Vs Netbeans… 

Allí expongo mi punto de vista y doy las razones del porqué me gusta más Eclipse…. 

Una de esas razones es porque a pesar de que la paleta de componentes en Netbeans es una gran herramienta (que además nos ahorra mucho tiempo),  en algunos casos (No estoy diciendo que en todos) afecta el crecimiento del desarrollador, ya que la gente empieza a depender de lo que esta paleta nos genera y deja a un lado el aprender a programar por nuestra cuenta….

Si vieron la entrada entonces por esa y otras razones sabrán que prefiero recomendar que se aprenda a programar y después se haga uso de esas herramientas que nos facilitan tanto las cosas….

Sin embargo a pesar de lo anterior (Y gracias a los comentarios en la entrada) no puedo desconocer lo útil que puede llegar a ser, por tal razón me parecería muy egoísta no compartir un equivalente de esta paleta en Eclipse para todos aquellos que ya se encuentren en condiciones de usarla (en condiciones ya que se le sacará el provecho sin depender de ella)……….Empecemos….


Que es WindowBuilder?

Es un Plugin de Eclipse que nos permite desarrollar rápidamente una interfaz Gráfica de Usuario (GUI)por medio de una paleta de componentes con tan solo arrastrar y soltar, generándonos el código necesario para su funcionamiento…


Instalación.

Para instalarlo se debe obtener de la página oficial (http://www.eclipse.org/windowbuilder/download.php) el enlace o como en este caso el empaquetado del plugin…….

Es importante saber que debemos escoger el enlace o zip correspondiente a nuestra versión de Eclipse para este caso como estoy trabajando con Eclipse Indigo, descargaré su plugin (En caso de que escojan el procedimiento mediante el enlace, al hacer clic en el otro link deberán copiar la url de la página que se carga y ejecutan los pasos como lo hicimos en esta entrada)…


Al hacer esto nos re direcciona  a una página donde podemos descargarlo.


Le damos clic en el enlace y se muestra la ventana donde definimos la ruta de descarga.


Cuando descarguemos el archivo zip, lo descomprimimos y vemos el contenido, de aquí debemos sacar las librerías necesarias para vincular al Eclipse


Copiamos el contenido de las carpetas features y plugin en las carpetas de instalación de Eclipse con el mismo nombre….


Y listo, de esta manera con solo copiar las librerías ya finalizamos el proceso de instalación, ahora solo es cuestión de iniciar Eclipse y crear nuestra primera aplicación por medio del Editor…


Creando una Ventana…

El uso de la herramienta es demasiado simple, para verificarlo crearemos un Java Project normal (File/New/Java Project…)


Ahora crearemos nuestra ventana, para eso damos clic derecho en el proyecto o vamos a File/new/Other… y buscamos WindowBuilder, posteriormente ingresamos a Swing Designer y seleccionamos Application Window y damos next…


Al hacer esto se carga otra ventana donde está definido el proyecto… ingresamos el nombre de nuestra ventana y le damos finish


Automáticamente se crea una clase con el nombre que definimos y el código necesario para nuestra ventana…


También podemos ver 2 pestañas, source donde nos encontramos y vemos el código y la otra Design que nos permitirá ver la paleta de componentes para crear nuestras aplicaciones de forma gráfica…


Encontramos la paleta de componentes, el árbol de componentes usados, las propiedades y la parte gráfica donde vemos la ventana que estamos diseñando, debemos saber que estos paneles pueden ser cambiados de posición como cualquier panel de los usados en Eclipse, además podemos modificar el código y nuestra parte gráfica se actualiza según la modificación…

Y Listo!!! Ya tenemos nuestra aplicación creada por medio de la herramienta sin programar una sola línea de código (Ventaja para quienes ya saben, posible desventaja para quienes apenas aprenden… si no se sabe aprovechar…)

Entrada en Video.

 


Conclusiones.

Como vemos ya generamos rápidamente nuestra aplicación…. Si observamos la clase generada nos daremos cuenta que se crea con todo el código y la lógica necesaria para el funcionamiento de la aplicación, allí encontramos el método main por ejemplo y algunas otras líneas autogeneradas…

La herramienta nos facilita mucho el trabajo y nos ahorra gran cantidad de tiempo que tendríamos que invertir en el diseño de la interfaz…

Sin embargo insisto en que a pesar de darnos ventajas, si no se usa como debe de ser y nos mal acostumbramos a su utilización, puede generar dependencia y poca calidad en el código… 

Igual que Netbeans esta herramienta genera gran cantidad de "código basura" que podría optimizarse con pocas líneas de código y resultados iguales…

A pesar de lo anterior, a diferencia de Netbeans, con este plugin tenemos control total sobre el código autogenerado lo que nos permitirá modificarlo para ajustarnos a lo que queremos…

Que mas?

Nada mas, solo espero que esta entrada les pueda servir y usen esta herramienta a conciencia, teniéndola precisamente como eso, una herramienta, no un generador de código!!!!

Y por último teniendo en cuenta el último párrafo, en la próxima entrada vamos a ver cómo podemos optimizar el código de nuestra aplicación, comparando lo que nos genera con lo que nosotros podemos generar…..... Un Saludo!!!


También te podría Interesar.


¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir
 y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

¿ Como Hacer un Juego Concentrese en Java ?

$
0
0
Hola, en esta entrada quiero compartirles una serie de vídeos que hice en mi canal de YouTube en la que veremos como construir un juego de concentrese utilizando arreglos.
Este juego aunque teóricamente pueda parecer muy simple, en realidad posee cierta lógica de programaciòn que dependiendo de nuestro nivel o experiencia con el lenguaje, puede llegar a ser compleja.

El Juego.

En los vídeos partimos de una interface ya creada, inicialmente explicaré los componentes y cual va a ser la logica general del juego. A medida que vamos avanzando le daremos cuerpo a nuestra aplicaciòn, poniendo la lógica necesaria y realizando las modificaciones correspondientes a los posibles errores que vamos encontrando.


Aunque hay muchas formas de crear un concentrese, este va a ser muy "Simple" ya que solo usaremos eventos del teclado para realizar toda nuestra lógica, si queremos agregarle complejidad, podemos vincular hilos para generar un cronometro, agregar mas validaciones o almacenar resultados por usuario.

Índice de Vídeos.

Descarga.

El ejemplo es muy básico y simple, para entenderlo les dejo el link de descarga para que lo prueben ;).....está en Eclipse pero si usas NetBeans te interesará esta entrada con un vídeo paso a paso de como abrirlo en el........ [recuerden que es gratis.....nada cuesta opinar, compartir o agradecer :)]


También te podría Interesar.  


¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Hangouts y Comunidades

$
0
0
Ultimamente he estado enfocandome en mi Canal de youtube como complemento al blog, sin embargo eso ha hecho que descuide un poquito este espacio, asi que tengo como meta retomarlo y seguir compartiendo material que tal vez les pueda servir...


¿Que ha pasado? 


Aparte de mis ocupaciones diarias, trabajo, proyectos personales y "vida social", he estado participando en una seria de charlas y talleres online, compartiendo espacios gratificantes con personas de diferentes lugares del pais y del mundo, personas que tienen la misma visión de compartir conocimiento, personas que como yo, tratan de compartir lo poco o mucho que saben en pro del mejoramiento y crecimiento de este campo tan bonito, no solo en torno a desarrollo de software sinó tambien en torno al diseño, seguridad, redes y entre otros temas de interés...


Basado en lo anterior quice hacer esta entrada donde les comparto algunos enlaces de hangouts realizados, así como los contactos de las personas participantes, profesionales en el campo que vale la pena seguir para estar al tanto del material y enseñanzas que nos puedan brindar.


Hangouts en los que participo.

A continuación les comparto los enlaces de los hangouts en los que he participado como ponente y como invitado.


Lista de reproducción con todos los talleres: http://adsiar.com/TallerDeSabado
 

Contactos:

Redes de Alexys Lozada
Youtube: https://www.youtube.com/user/Alexyslo...
Facebook: https://www.facebook.com/AlexysLozada

Redes de Cristian Henao
Youtube: https://www.youtube.com/user/Cristian...
Blog: http://codejavu.blogspot.com.co/

FanPage: https://www.facebook.com/codejavu 
Facebook: https://www.facebook.com/profile.php?id=100011348864767&fref=ts

Redes de Fabian Sepulveda
Facebook: https://www.facebook.com/Fascomp/
Youtube: https://www.youtube.com/channel/UCvgB...

Redes de Daniel Romero
Facebook: https://www.facebook.com/adsiar
Youtube: http://adsiar.com


Jaime Medina - MitoCode
Facebook: https://www.facebook.com/mitocode/
Youtube: https://www.youtube.com/user/MitoCode 


Facebook Taller de Sabado: https://www.facebook.com/groups/958318100930244/

 
Como siempre espero que esta información les pueda servir.... un saludo...



También te podría Interesar.  


¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Uso de JCheckbox en Java

$
0
0
Siguiendo con las entradas Java Swing ahora es el turno del componente JCheckbox sobre este  hablamos de forma rápida en la entrada sobre Componentes Atómicos, ahora vamos a dedicarle este espacio para un ejemplo sencillo sobre el uso de estas opciones de selección.... pueden consultar el paso a paso en un vídeo de explicación.




Que Son?

Retomando la entrada donde hablamos de ellos, se mencionó  que son Casillas de verificación que permiten al usuario seleccionar una o mas de las opciones propuestas, ideales en aplicaciones con preguntas de selección múltiple con múltiples respuestas (Api de Java).

 

El Ejemplo.

Este ejemplo es muy muy básico pero nos sirve para conocer su funcionamiento, les comparto el código de la ventana principal, en el pueden ver la lógica de creación y funcionamiento,  recuerden que deben crear un método main para poder ejecutar el sistema...
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class VentanaCheck extends JFrame implements ActionListener{

JCheckBox check1,check2,check3;
JButton boton;

public VentanaCheck() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(385, 300);
getContentPane().setLayout(null);
iniciarComponentes();
}

private void iniciarComponentes() {

check1=new JCheckBox();
check1.setText("check1");
check1.setBounds(20, 30, 120, 30);

check2=new JCheckBox();
check2.setText("check2");
check2.setBounds(20, 60, 120, 30);

check3=new JCheckBox();
check3.setText("check3");
check3.setBounds(20, 90, 120, 30);

boton=new JButton();
boton.setText("Boton");
boton.setBounds(230, 90, 120, 40);
boton.addActionListener(this);

add(check1);
add(check2);
add(check3);
add(boton);
}

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==boton) {
valideSeleccion();
}
}

private void valideSeleccion() {
String cad="";

if (check1.isSelected()) {
cad+="Check 1 Seleccionado, ";
}
if (check2.isSelected()) {
cad+="Check 2 Seleccionado, ";
}
if (check3.isSelected()) {
cad+="Check 3 Seleccionado, ";
}

JOptionPane.showMessageDialog(null, cad);
}
}


Un saludo y espero que les pueda servir...

También te podría Interesar.
 
¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Uso de JRadioButton

$
0
0
En la entrada anterior hablamos del JCheckbox ,  ahora es el turno del componente JRadioButton, igual que el anterior sobre este  hablamos de forma rápida en la entrada sobre Componentes Atómicos, ahora vamos a ver cual es el uso de estas opciones de selección.... pueden consultar el paso a paso en un vídeo de explicación.


Que Son?

Retomando la entrada general de Componentes Atómicos, estos permiten presentar opciones de selección similares a las checkbox, solo que el enfoque es de única selección, para trabajar con los RadioButtons se debe hacer uso de un ButtonGroup para determinar la selección única, ideales en aplicaciones con preguntas de selección múltiple con única respuesta (Api de Java).

El Ejemplo.


Igual que el anterior, este ejemplo es muy sencillo, les comaparto el codigo muy similar al trabajado con los JCheckbox, la diferencia aquí radica en el uso del ButtonGroup para el conjunto de opciones que queremos procesar.
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JRadioButton;

public class VentanaPrincipal extends JFrame implements ActionListener{

JRadioButton radio1,radio2,radio3;
ButtonGroup grupoDeRadios;
JButton boton;

public VentanaPrincipal() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(385, 300);
getContentPane().setLayout(null);
iniciarComponentes();
}

private void iniciarComponentes() {

grupoDeRadios=new ButtonGroup();

radio1=new JRadioButton();
radio1.setText("Radio1");
radio1.setBounds(20, 30, 120, 30);

radio2=new JRadioButton();
radio2.setText("Radio2");
radio2.setBounds(20, 60, 120, 30);

radio3=new JRadioButton();
radio3.setText("Radio3");
radio3.setBounds(20, 90, 120, 30);

grupoDeRadios.add(radio1);
grupoDeRadios.add(radio2);
grupoDeRadios.add(radio3);

boton=new JButton();
boton.setText("Boton");
boton.setBounds(230, 90, 120, 40);
boton.addActionListener(this);

add(radio1);
add(radio2);
add(radio3);
add(boton);
}

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==boton) {
valideRadios();
}
}

private void valideRadios() {
String cad="";

if (radio1.isSelected()) {
cad+="Radio 1 Seleccionado, ";
}
if (radio2.isSelected()) {
cad+="Radio 2 Seleccionado, ";
}
if (radio3.isSelected()) {
cad+="Radio 3 Seleccionado, ";
}

JOptionPane.showMessageDialog(null, cad);
}

}

y listo, de esta manera terminamos con este componente, un saludo y nuevamente espero que les pueda servir...

También te podría Interesar.
¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Uso Básico de JComboBox en Java

$
0
0
Retomando las entradas sobre Java Swing, voy a mostrarles como trabajar con el componente JComboBox.... ya en el post sobre los Componentes Atómicostrabajamos con los combos de selección pero de una forma general, ahora nos enfocaremos en lo que debemos saber... aquí también podrás ver un vídeo con el paso a paso de la entrada....



Ya hemos hablado que los JCombobox permiten definir listas de selección, siendo muy útiles cuando queremos mostrar diferentes opciones o información de nuestra base de datos, esta se mantendrá oculta hasta que se despliega el componente...

El Ejemplo.

Con este ejemplo tan solo mostraré como crearlo y como asignarle valores directamente, esto lo podemos realizar mediante 2 formas, inicialmente crearemos la clase principal que contiene el método main y luego iremos viendo el paso a paso en la construcción del combo.

Clase Principal

Esta clase tan solo se encargará de llamar a la ventana con el combo...
public class Principal {
public static void main(String[] args) {
VentanaPrincipal miVentana=new VentanaPrincipal();
miVentana.setVisible(true);
}
}

Clase VentanaPrincipal.

Esta clase corresponde a la ventana de nuestro sistema, tan solo cuenta con 2 componentes, el JComboBox y un JLabel el que nos mostrará cual fue la opción seleccionada.


Al ejecutar nuestro sistema tan solo veremos la ventana con un combo vacio y un texto en pantalla, ahora veamos las 2 formas que podemos usar para el llenado de los items


Forma 1.
La primer forma es muy común cuando usamos una paleta de componentes, pues estas nos auto generan el código necesario para llenar nuestro combo

Para hacerlo debemos importar DefaultComboBoxModel...
import javax.swing.DefaultComboBoxModel;

posteriormente creamos las opciones de la siguiente manera.
combo1.setModel(new DefaultComboBoxModel<>(new String[]{"Seleccione","Opcion1","Opcion2"}));

como vemos podemos agregar los items directamente, o tambien dependiendo de la cantidad podriamos generar un arreglo de valores y asignarlo en los parentesis, remplazando todo desde el new String...
String arregloItems[]=new String[]{"Seleccione","Opcion1","Opcion2"};
combo1.setModel(new DefaultComboBoxModel<>(arregloItems));

Independiente de la forma el resultado será el mismo, puedes verificarlo ejecutando tu aplicación.

Forma 2.
Esta segunda forma a mi parecer es la mas simple y fácil de entender, ya que tan solo debemos utilizar el método additem() que nos provee el componente, comentamos la forma anterior y agregamos lo siguiente.
combo1.addItem("Seleccione");
combo1.addItem("Opcion 1");
combo1.addItem("Opcion 2");
combo1.addItem("Opcion 3");
combo1.addItem("Opcion 4");
combo1.setSelectedIndex(3);

Adicionalmente el uso de el método addItem() nos da mayor libertad para agregar elementos de forma dinámica, por ejemplo en un ciclo cuando obtenemos datos de nuestra base de datos...

Por ultimo podemos implementar la interface ActionListener para reconocer cuando seleccionamos una opción..... al final debemos tener algo así:
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.DefaultComboBoxModel;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class VentanaPrincipal extends JFrame implements ActionListener{

JComboBox combo1;
JLabel lblMsj;

public VentanaPrincipal() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(219, 200);
getContentPane().setLayout(null);
setLocationRelativeTo(null);

iniciarComponentes();
}
private void iniciarComponentes() {

lblMsj=new JLabel();
lblMsj.setText("Selección: ");
lblMsj.setBounds(29, 100, 180, 20);
combo1=new JComboBox();
combo1.setBounds(29, 35, 148, 20);

//FORMA 1
//String arregloItems[]=new String[]{"Seleccione","Opcion1","Opcion2"};
//combo1.setModel(new DefaultComboBoxModel<>(arregloItems));

//FORMA 2
combo1.addItem("Seleccione");
combo1.addItem("Opcion 1");
combo1.addItem("Opcion 2");
combo1.addItem("Opcion 3");
combo1.addItem("Opcion 4");
combo1.setSelectedIndex(3);

add(combo1);
add(lblMsj);
}

@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==combo1) {
lblMsj.setText(combo1.getSelectedIndex()+" - "+combo1.getSelectedItem());
}
}
}

//

Notemos que se usa el método setSelectedIndex(3) esto permitirá cargar el combo con el valor definido por el indice 3, mostrando así la "Opcion 3", si quisiéramos que se mostrara la palabra "Seleccione" entonces el parámetro enviado debería ser 0...

Y listo, si ejecutamos nuestra aplicación veremos el funcionamiento del JComboBox, en la próxima entrada veremos algo similar pero obteniendo la información desde una Base de Datos....un saludo y espero que les pueda servir.



También te podría Interesar.

¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir
 y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Como llenar un JComboBox con datos de la BD?

$
0
0

En la entrada anterior vimos como usar los JComboBox, nos enfocamos en lo básico y las formas simples de llenarlos, ahora les voy a mostrar como realizar el llenado por medio de una consulta a una Base de Datos, para esto usaremos el mismo Script que trabajamos en una entrada anterior sobre el MVC.


Como se mencionó, en el vídeo anterior vimos lo básico de este componente, aprendimos a crearlo y llenarlo de forma manual, en esta oportunidad actualizaremos el proyecto que consiste en una ventana con un combo y un botón, al presionar el botón automaticamente traemos la información de una tabla de nuestra base de datos.




Es importante tener en cuenta que se debe vincular el driver mysql para que se establezca la conexión con la BD, si no sabes como se realiza el proceso te comparto este otro video con el paso a paso...

En esta entrada como les dije reutilizaremos el proyecto anterior, por esa razón solo mostraré el código de las clases nuevas para que se puedan apoyar en el vídeo, igual al final pondré el enlace de descarga para que lo puedan consultar.

PersonaVO.java

Esta clase seria la encargada  de tener el equivalente a las tablas de nuestra base de datos, en este caso como el proyecto cuenta solo con una tabla "persona" generamos la clase PersonaVO con los atributos correspondientes a los campos de nuestra tabla.
public class PersonaVO {

private String id;
private String nombre;
private int edad;
private String profesion;

public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getProfesion() {
return profesion;
}
public void setProfesion(String profesion) {
this.profesion = profesion;
}
}


PersonaDAO.java 

Esta clase será la encargada de centralizar todo el acceso a la tabla "persona" de nuestra base de datos, en este caso contará con el método consultarListaPersona() que obtendrá la información de nuestra tabla
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;


public class PersonaDAO {

public ArrayList consultarListaPersona() {

ArrayList estudiantesList=new ArrayList<>();

Connection connection=null;
Conexion miConexion=new Conexion();
PreparedStatement statement=null;
ResultSet result=null;

PersonaVO estudianteVo;

connection=miConexion.getConnection();

String consulta="SELECT id,nombre,edad,profesion FROM persona ";

try {
if (connection!=null) {
statement=connection.prepareStatement(consulta);
result=statement.executeQuery();

while(result.next()==true){
estudianteVo=new PersonaVO();
estudianteVo.setId(result.getString("id"));
estudianteVo.setNombre(result.getString("nombre"));
estudianteVo.setEdad(result.getInt("edad"));
estudianteVo.setProfesion(result.getString("profesion"));

estudiantesList.add(estudianteVo);
}
}
} catch (SQLException e) {
System.out.println("Error en la consulta de Estudiantes: "+e.getMessage());
}finally{
try {
connection.close();
miConexion.desconectar();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return estudiantesList;
}

}


Conexion.java

Esta clase será la encargada de establecer la conexión con nuestra base de datos.
import java.sql.*;
public class Conexion {
private String nombreBd="codejavu";
private String usuario="root";
private String password="";
private String url="jdbc:mysql://localhost/"+nombreBd;

Connection conn=null;
//constructor de la clase
public Conexion(){
try {
//obtener el driver
Class.forName("com.mysql.jdbc.Driver");
//obtener la conexion
conn=DriverManager.getConnection(url,usuario,password);
if (conn!=null) {
}
} catch (ClassNotFoundException e) {
System.out.println("ocurre una ClassNotFoundException : "+e.getMessage());
} catch (SQLException e) {
System.out.println("ocurre una SQLException: "+e.getMessage());
}
}
public Connection getConnection(){
return conn;
}
public void desconectar(){
try {
conn.close();
conn=null;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}


VentanaPrincipal.java

Por ultimo nuestra ventana principal contará con el combo y el botón que ejecutará el evento para obtener la información, todo este proceso se realiza en el método consultarPersonas() el cual hace el llamado a nuestro DAO y asigna la información al JComboBox.
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class VentanaPrincipal extends JFrame implements ActionListener {

private JComboBox comboBox;
private JLabel lblMsj;
private JButton btnConsultar;

public VentanaPrincipal() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(306, 211);
getContentPane().setLayout(null);
setLocationRelativeTo(null);

iniciaComponentes();
}

private void iniciaComponentes() {
comboBox = new JComboBox();
comboBox.setBounds(10, 35, 270, 20);
comboBox.addItem("Seleccione");
comboBox.addItem("Opcion 1");
comboBox.addItem("Opcion 2");
comboBox.addActionListener(this);

lblMsj = new JLabel("");
lblMsj.setBounds(10, 11, 270, 14);

btnConsultar = new JButton("Consultar");
btnConsultar.setBounds(191, 139, 89, 23);
btnConsultar.addActionListener(this);

getContentPane().add(lblMsj);
getContentPane().add(btnConsultar);
getContentPane().add(comboBox);
}

@Override
public void actionPerformed(ActionEvent e) {

if (e.getSource() == btnConsultar) {
consultarPersonas();
}

if (e.getSource() == comboBox) {
if (comboBox.getSelectedIndex() >= 0) {
lblMsj.setText(comboBox.getSelectedItem().toString());
}
}
}

private void consultarPersonas() {
comboBox.removeAllItems();
PersonaDAO miPersonaDao = new PersonaDAO();
ArrayList < personavo > listaPersonas = miPersonaDao.consultarListaPersona();

for (int i = 0; i < listaPersonas.size(); i++) {
comboBox.addItem(listaPersonas.get(i).getId() + " - " + listaPersonas.get(i).getNombre());
}
lblMsj.setText(comboBox.getSelectedItem().toString());
}
}
Como vemos en el método consultarPersonas() inicialmente se eliminan todos los items del combo para que se llene cada vez con lo obtenido en la base de datos, de está manera no quedarán items repetidos.

Y listo, básicamente aquí podemos ver de forma rapida como obtener la información de la base de datos y presentarla en nuestro componente JComboBox...


Descarga!!!

El ejemplo es muy simple, sin mayores complicaciones, aquí dejo el enlace de descarga por si lo quieren revisar ;)..está en Eclipse pero si usas NetBeans te interesará esta entrada con un vídeo paso a paso de como abrirlo en el....... recuerden que es gratis, y nada cuesta opinar, compartir o agradecer :)


También te podría Interesar.
¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Como llenar JTable desde la Base de Datos en Java ?

$
0
0
En esta oportunidad les mostraré como trabajar con el componente JTable en Java y veremos como cargar información directamente desde la base de datos.

Al final pueden descargar el proyecto....... es muy sencillo pero será de mucha útilidad. 




En el vídeo pueden ver como realizo el proceso paso a paso, a continuación explicaré las principales clases de nuestro sistema y al final compartiré el enlace de descarga para que puedan obtener la información.

Igual que en la entrada anterior tendremos una estructura de proyecto muy similar, está será compuesta por una clase conexión, la ventana de consulta, la clase con el main y los correspondientes Dao y Vo.



La base de datos será la misma trabajada en ejemplos anteriores, para esto es importante tener en cuenta que se debe vincular el driver mysql para que se establezca la conexión con la BD, si no sabes como se realiza el proceso te comparto este otro video con el paso a paso...

Script BD

Este script es el mismo usado en el ejemplo anterior...


CREATE DATABASE codejavu;

/*Table structure for table `persona` */

CREATE TABLE `persona` (
`id` int(10) NOT NULL,
`nombre` varchar(30) DEFAULT NULL,
`edad` int(3) DEFAULT NULL,
`profesion` varchar(30) DEFAULT NULL,
`telefono` decimal(10,0) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

insert into `persona`(`id`,`nombre`,`edad`,`profesion`,`telefono`) values (111,'admin',25,'Ingeniero','5555'),(123,'Cristian David Henao',28,'Instructor','34566'),(258,'Carlos Andrés Henao',25,'Ingeniero','4567');


PersonaVO.java

Esta clase igual que el ejemplo anterior, será la encargada  de tener el equivalente a las tablas de nuestra base de datos, en este caso como el proyecto cuenta solo con una tabla "persona" generamos la clase PersonaVO con los atributos correspondientes a los campos de nuestra tabla.
package vo;

public class PersonaVo {

private Integer idPersona;
private String nombrePersona;
private Integer edadPersona;
private String profesionPersona;
private Integer telefonoPersona;

/**
* @return the idPersona
*/
public Integer getIdPersona() {
return idPersona;
}
/**
* @param idPersona the idPersona to set
*/
public void setIdPersona(Integer idPersona) {
this.idPersona = idPersona;
}
/**
* @return the nombrePersona
*/
public String getNombrePersona() {
return nombrePersona;
}
/**
* @param nombrePersona the nombrePersona to set
*/
public void setNombrePersona(String nombrePersona) {
this.nombrePersona = nombrePersona;
}
/**
* @return the edadPersona
*/
public Integer getEdadPersona() {
return edadPersona;
}
/**
* @param edadPersona the edadPersona to set
*/
public void setEdadPersona(Integer edadPersona) {
this.edadPersona = edadPersona;
}
/**
* @return the profesionPersona
*/
public String getProfesionPersona() {
return profesionPersona;
}
/**
* @param profesionPersona the profesionPersona to set
*/
public void setProfesionPersona(String profesionPersona) {
this.profesionPersona = profesionPersona;
}
/**
* @return the telefonoPersona
*/
public Integer getTelefonoPersona() {
return telefonoPersona;
}
/**
* @param telefonoPersona the telefonoPersona to set
*/
public void setTelefonoPersona(Integer telefonoPersona) {
this.telefonoPersona = telefonoPersona;
}
}


PersonaDAO.java 

De la misma manera esta clase será la encargada de centralizar todo el acceso a la tabla "persona" de nuestra base de datos, en este caso contará con el método consultarListaPersona() que obtendrá la información de nuestra tabla
package dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;

import javax.swing.JOptionPane;

import vo.PersonaVo;
import conexion.Conexion;

/**
* Clase que permite el acceso a la base de datos
*
* @author chenao
*
*/
public class PersonaDao {

public ArrayList buscarUsuariosConMatriz() {

Conexion conex = new Conexion();
ArrayList miLista = new ArrayList();
PersonaVo persona;
try {
Statement estatuto = conex.getConnection().createStatement();
ResultSet rs = estatuto.executeQuery("SELECT * FROM persona ");

while (rs.next()) {
persona = new PersonaVo();
persona.setIdPersona(Integer.parseInt(rs.getString("id")));
persona.setNombrePersona(rs.getString("nombre"));
persona.setEdadPersona(Integer.parseInt(rs.getString("edad")));
persona.setProfesionPersona(rs.getString("profesion"));
persona.setTelefonoPersona(Integer.parseInt(rs.getString("telefono")));
miLista.add(persona);
}
rs.close();
estatuto.close();
conex.desconectar();

} catch (SQLException e) {
System.out.println(e.getMessage());
JOptionPane.showMessageDialog(null, "Error al consultar", "Error",
JOptionPane.ERROR_MESSAGE);

}
return miLista;
}
}


Conexion.java

Encargada de establecer la conexión con nuestra base de datos.
package conexion;

import java.sql.*;


/**
* Clase que permite conectar con la base de datos
* @author chenao
*
*/
public class Conexion {
static String bd = "codejavu";
static String login = "root";
static String password = "";
static String url = "jdbc:mysql://localhost/"+bd;

Connection conn = null;

/** Constructor de DbConnection */
public Conexion() {
try{
//obtenemos el driver de para mysql
Class.forName("com.mysql.jdbc.Driver");
//obtenemos la conexión
conn = DriverManager.getConnection(url,login,password);

if (conn!=null){
//System.out.println("Conección a base de datos "+bd+" OK");
}
}
catch(SQLException e){
System.out.println(e);
}catch(ClassNotFoundException e){
System.out.println(e);
}catch(Exception e){
System.out.println(e);
}
}
/**Permite retornar la conexión*/
public Connection getConnection(){
return conn;
}

public void desconectar(){
conn = null;
}

}


VentanaConsulta.java

Esta ventana presentará la tabla con la información, la cual se cargará inmediatamente, también contará con el botón que ejecutará el evento para obtener la información en caso de que la base de datos sea actualizada, todo este proceso se realiza en los métodos construirTabla() encargado de armar nuestra tabla y el método obtenerMatriz() el cual hace el llamado a nuestro DAO y asigna la información al JTable.
package ventanas;

import java.awt.event.ActionEvent;

public class VentanaConsulta extends JFrame implements ActionListener {

private JLabel labelTitulo;
JTable miTabla1;
JScrollPane mibarra1;
private JButton btnNewButton;

/**
* constructor de la clase donde se inicializan todos los componentes de la
* ventana de registro
*/
public VentanaConsulta() {
setSize(462, 281);
setTitle("CoDejaVu : Componentes JTable");
setLocationRelativeTo(null);
setResizable(false);

inicializaComponentes();
construirTabla();
}

private void inicializaComponentes() {
getContentPane().setLayout(null);

labelTitulo = new JLabel();
labelTitulo.setBounds(27, 11, 400, 30);
labelTitulo.setHorizontalAlignment(SwingConstants.CENTER);
labelTitulo.setText("CONSULTA DE PERSONAS");
labelTitulo.setFont(new java.awt.Font("Verdana", 1, 18));
getContentPane().add(labelTitulo);

mibarra1=new JScrollPane();
mibarra1.setBounds(27, 72,400,130);
getContentPane().add(mibarra1);

btnNewButton = new JButton("Actualizar");
btnNewButton.setBounds(335, 219, 89, 23);
getContentPane().add(btnNewButton);
btnNewButton.addActionListener(this);

}

private void construirTabla() {
String titulos[]={ "Codigo", "Nombre", "Edad", "Profesión","Telefono" };
String informacion[][]=obtenerMatriz();

miTabla1=new JTable(informacion,titulos);
mibarra1.setViewportView(miTabla1);

}

private String[][] obtenerMatriz() {

PersonaDao miPersonaDao=new PersonaDao();
ArrayListmiLista=miPersonaDao.buscarUsuariosConMatriz();

String matrizInfo[][]=new String[miLista.size()][5];

for (int i = 0; i < miLista.size(); i++) {
matrizInfo[i][0]=miLista.get(i).getIdPersona()+"";
matrizInfo[i][1]=miLista.get(i).getNombrePersona()+"";
matrizInfo[i][2]=miLista.get(i).getProfesionPersona()+"";
matrizInfo[i][3]=miLista.get(i).getEdadPersona()+"";
matrizInfo[i][4]=miLista.get(i).getTelefonoPersona()+"";
}

return matrizInfo;
}



@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource()==btnNewButton) {
construirTabla();
}
}
}


Principal.java   
Por ultimo tenemos la clase principal la cual consiste simplemente en el metodo main() que perimitirá iniciar el sistema.
package principal;

import ventanas.VentanaConsulta;

public class Principal {

/**
* Llama la ventana principal
* @param args
*/
public static void main(String[] args) {
VentanaConsulta miVentanaConsulta;
miVentanaConsulta= new VentanaConsulta();
miVentanaConsulta.setVisible(true);
}
}


Y listo, básicamente aquí podemos ver de forma rapida como obtener la información de la base de datos y presentarla en nuestro componente JTable... 

Descarga!!!

El ejemplo es muy simple, sin mayores complicaciones, aquí dejo el enlace de descarga por si lo quieren revisar ;)..está en Eclipse pero si usas NetBeans te interesará esta entrada con un vídeo paso a paso de como abrirlo en el....... recuerden que es gratis, y nada cuesta opinar, compartir o agradecer :)

También te podría Interesar.
¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Tipos de Aplicaciones Moviles - WebApp vs Nativas vs Hibridas

$
0
0
Hola, con esta entrada daré inicio a una secuencia sobre desarrollo de aplicaciones móviles pero antes quiero dar una breve explicación sobre los tipos de aplicaciones y la diferencia entre estas....


Tipos de Aplicaciones Móviles... 


Qué debemos tener en cuenta para desarrollar nuestras Apps?

Cuando ya tenemos la idea de lo que queremos hacer o cual es el enfoque de nuestra aplicación, debemos saber que existen 3 tipos o categorías de aplicaciones móviles :
  • Aplicaciones Web (WebApp). 
  • Aplicaciones Nativas. 
  • Aplicaciones Hibridas.
Es importante saber las características de cada una para así tomar la mejor decisión, sea enfocarnos por una sola línea o desarrollar nuestra aplicación de las 3 formas…

Web App

LasWeb App son aplicaciones web enfocadas a dispositivos móviles, podemos decir que son paginas web optimizadas para trabajar en móviles, sin embargo estas son un poco restringidas para realizar procesos mas avanzados que tengan relación directa con el dispositivo móvil ya que no pueden aprovechar los recursos propios de este.

Son desarrolladas en html, css, javaScripty ejecutadas en un navegador del dispositivo, lo que permite su adaptación a la pantalla del mismo
...


Ventajas

  • No necesitan ninguna aprobación externa para publicarse(no requieren de googlePlay por ejemplo) 
  • El usuario siempre dispone de la ultima versión 
  • El mismo código reutilizable en otras plataformas (multiplataforma) 
  • Proceso de desarrollo mas sencillo y económico 
  • Pueden reutilizarse sitios ya diseñados

Desventajas

  • Requiere de mayor esfuerzo para su promoción 
  • Requiere de acceso a internet 
  • La navegación,tiempo de respuesta y experiencia de usuario en general es mas lenta que otro tipo de aplicaciones 
  • Acceso limitado a los recursos hardware del dispositivo

App Nativas

Las aplicaciones nativas son creadas para dispositivos especificos, es decir si vamos a desarrollar una aplicación para dispositivos que soportan android entonces el desarrollo es nativo para android y de la misma manera para otros dispositivos como Iphone, blackberry entre otros, aprovechando así al máximo las capacidades del dispositivo.

  • En Android el lenguaje para desarrollarlas es Java aunque también existe soporte para C/C++ 
  • En IOS el lenguaje es Objetive-C. -Swift 
  • En Windows Phone o Windows 10 se desarrollan en .Net

El desarrollo nativo facilita el acceso al hardware del dispositivo, así como acceso a todos los recursos y cualidades del sistema, al trabajar directamente sobre la máquina, por lo regular las aplicaciones son de mejor calidad.

Hay que tener en cuenta que las aplicaciones nativas hacen uso de un SDK (Software Development Kit) especifico para cada sistema operativo, por lo tanto cada app seria diferente y poseería su propio sdk en caso de que queramos desarrollar de forma especifica para cada una...

Ventajas 
  • Actualización de aplicaciones constantemente. 
  • Se dispone de un AppStore(tienda de aplicaciones) desde donde se promociona y muestra la aplicación. 
  • Acceso total al dispositivo,por ende mejor aprovechamiento de recursos. 
  • Mejor experiencia de usuario. 
  • Mayor calidad en términos generales.

Desventajas
  • Por lo regular es mucho mas cara desarrollar App Nativas.
  • No es multiplataforma, el código fuente desarrollado no se puede reutilizar en otros sistemas.
  • Se deben conocer los lenguajes específicos para cada plataforma, sintaxis, idioma etc
  • Mayor tiempo de desarrollo comparado con otro tipo de App.

App Híbridas

Las aplicaciones hibridas son parte nativas y parte web, básicamente esto puede traducirse en paginas web que quedan embebidas en un componente nativo (llamado webView) que permite que corra dentro del dispositivo y así acceder al hardware del celular.

Las aplicaciones híbridas mejoran las aplicaciones web pero no del todo comparado con nativo, ya que aunque hace uso de los recursos del sistema, no lo hace totalmente.


Ventajas 
  • Acceso a parte del hardware del dispositivo
  • Se puede distribuir en una AppStore (tienda de aplicaciones) desde donde se promociona y muestra la aplicación.
  • Se puede instalar como una aplicación nativa, pero el desarrollo se hace como una aplicación web Multiplataforma
  • Actualmente hay muchas plataformas para trabajo Híbrido que facilitan bastante el desarrollo y conservan el aspecto o linea visual de la App
Desventajas
  • En muchos casos Las aplicaciones son genéricas, es decir, el aspecto visual es igual en todas las plataformas. 
  • La experiencia de usuario depende de la aplicación como tal, mas no del dispositivo.

En proximas entradas continuaremos revisando temas en torno al desarrollo de aplicaciones móviles, conoceremos las etapas a tener en cuenta, carácteristicas y posteriormente profundizaremos en el desarrollo de aplicaciones Android!!!!


También te podría Interesar.
 
¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

Etapas en el desarrollo de Apps

$
0
0
El proceso de desarrollo de una App no es solamente entrar a programar y ya, al contrario tiene una serie de etapas que se deben considerar y tener muy en cuenta si queremos lograr un producto de calidad.




En esta entrada quiero basarme en un libro que a mi parecer enmarca claramente este proceso...

Etapas en el Desarrollo de Apps

Diseñando Apps para Móviles

Como les mencioné para esta entrada me basaré  en el libro "Diseñando Apps para Móviles" al que pueden acceder totalmente gratis desde AQUÍ eneste libro se menciona claramente cuales son esas etapas a tener muy en cuenta si queremos iniciar con este mundo del desarrollo de aplicaciones móviles...

Con este libro nos damos cuenta que Crear una aplicación móvil va mucho mas allá de simplemente sentarnos a programar, al contrario para realizar esto debemos tener en cuenta otros factores que vienen desde la concepción de la idea hasta el análisis posterior a su lanzamiento.

Es importante tener muy claro que en todo este proceso intervienen diferentes etapas y roles tales como analistas, diseñadores, desarrolladores, entre otros que trabajan de forma organizada para lograr el objetivo propuesto.



Etapas

En un proceso de desarrollo de software se tienen las etapas de análisis, diseño, implementación, pruebas y entrega. 

Una App también es un software por ende cuenta con estas mismas etapas, sin embargo en el contexto móvil pueden ser agrupadas en:
  • Conceptualización. 
  • Definición. 
  • Diseño. 
  • Desarrollo. 
  • Publicación.

Estas etapas se pueden observar en el siguiente gráfico tomado del libro "Diseñando Apps para Móviles" 




Como vemos se mencionan los roles de Diseño y Desarrollo como 2 de los principales, los cuales deben trabajar de la mano en todas las fases....

Conceptualización

El resultado de esta etapa es una idea de aplicación, que tiene en cuenta las necesidades y problemas de los usuarios. La idea responde a una investigación preliminar y a la posterior comprobación de la viabilidad del concepto.

  • Ideación 
  • Investigación 
  • Formalización de la idea

Definición

En este paso del proceso se describe con detalle a los usuarios para quienes se diseñará la aplicación, para esta fase es importante implementar metodologías como las historias de usuario que facilitan la identificación de estos y sus necesidades....

En esta fase debemos establecer claramente la funcionalidad, teniendo esto claro podremos definir también el alcance del proyecto, que tan complejo puede ser el diseño y los primero indicios para la programación de la app.
  • Definición de usuarios
  • Definición funcional 

Diseño

En la etapa de diseño podemos empezar a darle cuerpo a eso que definimos en etapas anteriores, primero debemos tener claro el aspecto visual de nuestra aplicación, esto por medio de wireframes o mockupslos cuales permitirán crear los primeros prototipos para ser probados con usuarios, y posteriormente, unos diseños de alta fidelidad que serán la base parael desarrollador, esto como modelo para la programación del código.
  • Wireframes 
  • Prototipos 
  • Test con usuarios 
  • Diseño visual

Desarrollo

Está etapa es la que da realmente vida a nuestra aplicación, aquí es donde gira en torno todo el proceso de construcción de nuestra App.

Dependiendo del tipo de App que queramos construir y que se debió definir previamente iniciamos el proceso de desarrollo en el lenguaje o tecnología deseado, es importante tener claro que a medida que vamos construyendo debemos ir solucionando los errores que esta pueda ir presentando, así iremos garantizando el funcionamiento de la App...
  • Programación del código 
  • Corrección de bugs (Errores)
Es importante tener claro que despues del desarrollo es importante garantizar el correcto funcionamiento de la App, y si bién el proceso de validación se realiza usando prototipos, también es importante vincular otra serie de pruebas de usuarios donde se pueda medir la aceptación y usabilidad de nuestra aplicación...

    Publicación

    Después de haber pasado por todas las etapas anteriores, en esta fase se espera que la aplicación se encuentre lista para su publicación, es importante tener en cuenta que depende del tipo de App (WebApp, Híbrida, Nativa)definiremos el proceso de publicación, siendo lo mas normal su publicación en una tienda de aplicaciones.
    • Lanzamiento 
    • Seguimiento 
    • Actualización

    Con la publicación no quiere decir que llega el final del proceso, al contrario en esta etapa inicia otro proceso de suma importancia, que tiene que ver con el seguimiento y como se menciona también, las actualizaciones de nuestra App dependiendo de los comentarios y retroalimentación que nos hagan los usuarios, aspectos a los que debemos prestar mucha atención...

    Y listo, básicamente según nuestro libro de referencia, estas etapas son las que definen el proceso de Diseño y Desarrollo de nuestra aplicación, definitivamente recomiendo el libro para que tengamos un panorama mayor de estas importantes fases.... en proximos vídeos iremos profundizando en el desarrollo de aplicaciones móviles con Android.... espero que estén pendientes, un saludo!!!!


    También te podría Interesar.
     
    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

    Requisitos Para desarrollo de Apps en Android

    $
    0
    0
    Quieres iniciar el desarrollo de aplicaciones android? 

    Sabes cuales son los requisitos para crear tus aplicaciones rapidamente? 
    en esta entrada te cuento cuales son los requisitos basicos para iniciar.





    El desarrollo de aplicaciones móviles ha ido creciendo cada vez mas, android por su parte es uno de los sistemas operativos para dispositivos moviles de mayor crecimiento y cobertura, en esta entrada te quiero mostrar cuales son los requisitos básicos y herramientas necesarias para adentrarnos en este mundo de la programación para este tipo de dispositivos.

     
    JDK (Java Development Kit)

    Inicialmente debemos saber que las aplicaciones android son ejecutadas en una maquina virtual basada en java, por lo tanto es indispensable que tener instalado el jdk, como recomendacion se puede instalar el jdk en la versión 1.7 en adelante.



    Android Studio.

    Android studio es el entorno de desarrollo oficial de google, google es el dueño de android por lo cual este es un gran argumento para utilizar este IDE

    también podrías trabajar con eclipse, sin embargo desde hace mucho tiempo google dejó de brindar soporte para este, poniendo toda su atención y documentación precisamente a android studio.



    SDK de Android (Software Development Kit)

    El sdk es el kit de desarrollo para android, básicamente sin este no podríamos hacer nada, pues el nos provee ese conjunto de librerías, clases y herramientas para crear nuestras aplicaciones 

    Emulador o Dispositivo.

    Es  fundamental tener una herramienta para probar nuestras aplicaciones, android studio tiene integrado un emulador, sin embargo puedes probar otras opciones un poco mas rápidas, o bien ejecutar las aplicaciones en tu dispositivo físico. 






    Conceptos Básicos JAVA - POO.

    Si ya eres desarrollador se te va a dar muy fácil aprender a crear aplicaciones android, sino, te recomiendo entonces que aprendas un poco los fundamentos básicos de java y la programación orientada a objetos, ya que este lenguaje es el utilizado para programar la lógica de nuestras aplicaciones (recuerda que en mi canal puedes encontrar muchos tutoriales sobre este lenguaje)
     



    Muchas Ganas!!!


    Por ultimo pero no menos importante... las ganas son fundamentales si quieres aprender a desarrollar aplicaciones.

    por eso, si tienes la intención de estudiar, repasar, practicar y trasnochar, no tendrás problemas para crear aplicaciones de gran calidad.

     



    Y listo, espero que este vídeo y esta entrada te hayan gustado, en las próximas entradas seguiremos profundizando en este sistema operativo!!!!



    También te podría Interesar.
     
    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

    Caracteristicas y Arquitectura de Android

    $
    0
    0

    Hola, vamos a adentrarnos al desarrollo de aplicaciones android, pero antes quiero hablarte un poco sobre lo que es y cuales son sus principales características.



    ¿QUE ES ANDROID?

    Android es uno de los sistemas operativos para dispositivos móviles más populares, aunque google no es el creador si lo adquirió en el 2005 y desde su lanzamiento hemos visto una constante evolución en todos los sentidos.

    Es un sistema operativo basado en Linux con un entorno de ejecución basado en java lo que le brinda buenas garantías a nivel de seguridad, adicional a esto cuenta con un conjunto de librerías de bajo y medio nivel así como aplicaciones integradas para el usuario.

    Es de plataforma abierta, portable y adaptable a diferentes tipos de hardware, no es enfocado solamente a smarthphones o tablets sinó también a dispositivos como relojes inteligentes, google glass, televisores entre otros.

    VERSIONES

    Una característica curiosa de android es que todas sus versiones tienen nombres alusivas a dulces, actualmente nos encontramos en android 8.0 Oreo


    Cada versión es trae mejoras a la anterior, en algunos casos son cambios pequeños pero en otros se agregan cambios muy significativos, como por ejemplo la versión 3.0 (Honeycomb) de android trajo consigo el soporte para tablets y con ella el uso de fragments, la versión 5.0 (Lollipop) nos obsequió oficialmente material design, estos solo como ejemplos a muy groso modo ya que si entramos en detalle podríamos hablar de aspectos de rendimiento, funcionalidades entre otras que no vamos a abarcar aquí...

    Arquitectura:

    El núcleo de Android está formado por el sistema operativo Linux versión 2.6. Esta capa proporciona servicios como la seguridad, el manejo de la memoria, el multiproceso el soporte de drivers para dispositivos entre otros.




    El runtime de android esta basado en el concepto de maquina virtual utilizado en java, inicialmente se crea una maquina virtual llamada dalvik y posteriormente evolucionó a lo que hoy conocemos como ART.

    Esta capa es la que permite que las aplicaciones puedan ser ejecutadas.



    En La capa de librerías  se proveen un conjunto de librerías encargadas de la compatibilidad entre animaciones, gestión de datos, entre otros




    La capa de aplication framework brinda una serie de herramientas a los desarrolladores que pueden ser vinculadas en sus aplicaciones, esto es un conjunto de clases para el uso de sensores, localización, servicios, gps entre otras.

    Por ultimo la capa de aplicaciones que permite la interacción con el usuario, donde se puede acceder tanto a nuestras app como a las que vienen por defecto.


    Y listo, espero que esta entrada te pueda servir, recuerda que esto es un pequeño resumen de un tema muy extenso que te invito a revisar directamente en la documentación oficial https://developer.android.com/guide/platform/index.html tan solo te traigo una descripción general para darte una idea de todo lo que esconde este maravilloso mundo del desarrollo para Android.


    También te podría Interesar.
     
    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

    Paycores nueva pasarela de pagos.

    $
    0
    0
    Paycores.com, como se llama esta nueva pasarela que desde hace un tiempo comenzó a operar en Colombia, llega cargada de soluciones óptimas e innovadoras para los comercios electrónicos que desean tener un medio de pagos virtual. 


    Esta pasarela cuenta con unas alianzas estratégicas, certificaciones y demás, permite que cualquier comercio pueda recibir pagos con tarjetas de crédito y débito de franquicias como Visa, Mastercard, Amex, Diners y Discover.

    Actualmente ya cuenta con varios clientes en Colombia que están recibiendo pagos a través de paycores por sus ventas realizadas, muchos de estas empresas  estaban con pasarelas muy reconocidas que a falta de un buen servicio y tarifas de comisiones más bajas han decidido migrar a este nuevo proponente de las transacciones en Colombia.

    Darwin Tusarma CEO de la compañía nos comparte su visión donde expresa que Paycores.com es una pasarela de pagos que al cabo de pocos años estará posicionada de forma exponencial no solo en Colombia sino en gran parte de latino América donde sus ideas innovadoras con productos que están desarrollando se estarán lanzando periódicamente, podrán suplir muchas necesidades que actualmente se evidencian en temas de ventas no presente.

    "El público objetivo de Paycores.com son aquellas empresas, o emprendimientos que aún no cuentan con un sistema de pagos para ventas presentes y no presentes, en este caso las no presentes son las tiendas en línea. Brindamos  confianza, seguridad  y tranquilidad a la hora de comprar en algún comercio que use nuestra pasarela.

    Queremos que nuestros clientes se sientan satisfechos acomodándonos a las necesidades del mismo, Paycores.com es fácil de usar, es amigable con el usuario, trabajamos continuamente por la protección de la información y agilidad en nuestros  procesos.
    Buscamos que nuestros clientes puedan expandir su mercado ofreciendo diferentes medios de pagos, utilizamos dos modelos: agregador donde recepcionamos en nuestro banco aliado y después realizamos la trasferencia al banco del cliente, Gateway el dinero entra a su propia cuenta de banco aliado."



    ¿Y ustedes que opinan? a mi en lo personal me parece una muy interesante y nueva alternativa para realizar mis pagos seguros!!!

    Los invito a explorar un poco mas sobre esta plataforma y recuerden, no duden en preguntar!.

    También te podría Interesar.
     
    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)




    ¿Qué es java - Características y Generalidades?

    $
    0
    0
    ¿Saben Qué es Java? en esta entrada les cuento generalidades de este lenguaje y algunas de sus características.



    ¿Qué es Java? 


    Java es uno de los lenguajes mas populares en la actualidad y desde hace mucho ha estado en los primeros lugares en diferentes rankins sobre lenguajes de programación. 


    Esto se debe a características como robustez, seguridad, el hecho de que sea multiplataforma, el enfoque tecnológico (jse,jme,jee) entre muchas otras razones.

    Pros vs Contras

    Como en todo tenemos lo pro y los contras, uno de los contras más sonado tiene que ver con la dificultad del lenguaje, lo verboso y complejo que se torna en ocasiones programar o realizar ciertos procesos que en teoría pueden hacerse más cortos en otros lenguajes de programación.


    Sin embargo en mi concepto pesa mucho más la robustez y las múltiples características que lo hacen ser tan estable y brindar tantas alternativas para el desarrollo de soluciones de software… no por nada ha venido ocupando los primeros lugares.


    Plataformas.


    Las alternativas a las que me refiero se enfocan en las plataformas o tecnologías insignia de java, estas son:


    JME (java Micro Edition)

    JME (java Micro Edition): esta plataforma es enfocada para aplicaciones que se ejecutan en dispositivos móviles compatibles con java, hablamos de celulares, cajeros electrónicos, electrodomésticos entre otros, sin embargo esta plataforma no es tan popular en la actualidad, teniendo en cuenta los grandes avances tecnológicos y con estos la llegada de nuevos sistemas operativos para dispositivos móviles, pero aun así, java sigue siendo parte activa de ese proceso pues es uno de los lenguajes oficiales para el desarrollo de aplicaciones móviles en Android.


    JSE (Java standar edition)

    JSE (Java standar edition): el jse se enfoca principalmente en aplicaciones stand alone o simplemente aplicaciones de escritorio y applets, brinda una gran cantidad de librerías con las que podemos trabajar interfaces graficas de usuario, redes, acceso a bases de datos entre muchas otras facilidades, esta plataforma es por excelencia la más conocida ya que casi siempre todos empezamos por aquí, siendo este nuestro primer acercamiento al lenguaje.
    Por lo regular este es el java que conocemos a nivel educativo para aprender el lenguaje, a nivel empresarial no es muy llamativo ya que actualmente su aplicación es muy específica para ciertas soluciones de software tal vez no tan grandes y no pensadas en una arquitectura cliente servidor como en la que se enfoca el JEE.


    Pero no por eso pierde popularidad, pues  aún existen muchas necesidades que se pueden solucionar fácilmente con software de escritorio.


    JEE (Java Enterprise Edition)

    JEE (Java Enterprise Edition) : JEE es enfocado para aplicaciones empresariales en un entorno cliente servidor, básicamente es una especificación para crear sistemas de información web con altos nivel de robustez y seguridad al vincular varias tecnologías o apis java para la construcción de estos sistemas.

    En jee se empiezan a ver a más detalle diferentes conceptos como el uso de patrones de diseño, protocolos, desarrollo por capas, componentes, módulos, clientes web, servidores o contenedores de aplicaciones… Ya no solo hablamos de clases y objetos sino también de servlets, paginas html, jsp, jsf entre otros conceptos que iremos descubriendo.


    Este es el java que debemos conocer a nivel empresarial ya que el internet es el medio por el cual esta plataforma se desenvuelve y obviamente al cual debemos apuntar.


    ¿Donde encuentro más?

    En mi blog y en mi canal les he venido compartiendo material en torno a este gran lenguaje de programación, pueden encontrar muchos artículos y vídeos desde cero, les muestro como descargar las herramientas necesarias para empezar a programar, vamos subiendo cada vez más por los conceptos básicos, pasando por los conceptos de programación orientada a objetos, patrones, hilos, estructuras de datos, acceso a bases de datos entre otros,  hasta construir aplicaciones con interfaces grafías de usuario.


    Además podrán encontrar un curso desde cero donde les enseño a crear aplicaciones móviles en androidmediante una secuencia de vídeos paso a paso que constantemente se está actualizando.


    Y ahora iniciaré la secuencia también desde cero donde nos adentraremos al mundo del java Enterprise edition, les mostraré como configurar el ambiente de desarrollo y como crear sus primeras aplicaciones web con java.


    Por eso los invito a que visiten a codejavu.blogspot.com, que visiten mi canal Cristian Henao y que estén muy pendientes de las nuevas secuencias


    Y Tu!!!... Que otras ventajas o Desventajas conoces? Anímate y comparte tu opinión....


    También te podría Interesar. 

    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)



    ¿Cuales son los componentes de una App Android?

    $
    0
    0
    Saben ¿cuales con los componentes de Una App Android? en esta entrada les contaré de manera general cuales son estos componentes como primer paso antes de iniciar con el proceso. 



    ¿Qué compone una App en Android?



    Antes de iniciar en el proceso de desarrollo de aplicaciones android debemos conocer algunos componentes básicos que la componen.


    es importante tener en cuenta que aquí les muestro la generalidad pero los invito a profundizar en estos conceptos para tener una mayor claridad.


    VIEW

    Los view son componentes gráficos de la aplicación descendientes de la clase View.




    son elementos que componen la interfaz de usuario de una aplicación como por ejemplo un botón o entradas de texto, definen esa serie de componentes gráficos que usara nuestra aplicación, todos estos componentes heredan de la clase view por lo tanto pueden ser creados directamente mediante código java, pero Android facilita este proceso haciéndolo por medio de los archivos xml, todos estos componentes deben estar en un View Group, en este caso los Layout.

    ACTIVITY

    Las Actividades definen las pantallas de nuestra App Representan la "Actividad" que el usuario puede hacer.



    Internamente la Activity es una clase Java donde se define la lógica de la Interfaz

    básicamente son controladores de vista, es decir  representan nuestras “Ventanas” en android, sin embargo es importante tener muy claro que estas se asocian directamente con los layout, si buscamos una definición más técnica podemos ir a la documentación oficial de android que nos brinda la siguiente descripción:

    http://developer.android.com/intl/es/guide/components/activities.html
     

    “Una actividad es un componente de aplicación que proporciona una pantalla que permite al usuario interactuar con el fin de hacer algo, tal como marcar el teléfono, tomar una foto, enviar un correo electrónico, o ver un mapa. Cada actividad se da una ventana en la que extraer su interfaz de usuario. La ventana normalmente llena la pantalla, pero puede ser menor que la pantalla y flotar en la parte superior de otras ventanas.”

    Es importante saber que las activities tienen un ciclo de vida que indica los estados en los que se encuentra la actividad cada vez que se usa.




    LAYOUTS

    Representan las GUI de nuestra Aplicación, son archivos xml donde se construyen las Pantallas de la App



    Un layout define la estructura visual de mi aplicación, es un conjunto de vistas agrupadas de una forma determinada, indicando la manera en la que se pueden presentar los componentes graficos de nuestra aplicación, también heredan de la clase View pero el uso ideal es mediante los xml.

    SERVICES

    Permite la creación de tareas que se ejecutan en un segundo plano sin requerír una interfaz.

    Ej:
    - Notificaciones
    - Transacciones de Red
    - Reproducción de Música

    INTENTS

    Un intent es un objeto de acción para solicitar una acción de otro componente de la Aplicación, estos permiten:

    - Lanzar una Actividad
    - Iniciar un Servicio
    - Entregar un Mensaje

    CONTENT PROVIDERS

    Los proveedores de contenido son la interfaz estándar que conecta datos en un proceso con código que se ejecuta en otro proceso.

    Administran el acceso a datos de otras aplicaciones.

    BROADCAST RECEIVER


    Controla la forma en la que Android reacciona ante anuncios del sistema batería baja, llamadas entrantes, encendido del dispositivo, mensajes entre otros...

    Lanza Aplicaciones o realiza notificaciones al usuario dependiendo del anuncio recibido.

    FRAGMENTS

    Un fragment representa un comportamiento o una parte de la interfaz de usuario en una Activity estas pueden contener uno o mas Fragments



    Android introduce los fragmentos en Android 3.0 (Nivel de Api 11), principalmente para admitir diseños de IU más dinámicos y flexibles en pantallas grandes como las tablets.

    En el siguiente enlace pueden encontrar la descripción desde la página oficial de android veamos la descripción que nos provee la documentación oficial de android.


    http://developer.android.com/intl/es/guide/components/fragments.html

    Existen muchos más conceptos pero estos son los básicos que debemos conocer antes de adentrarnos en este mundo de la programación para dispositivos móviles... más adelante iremos profundizando en todos estos elementos, un saludo y espero que les pueda servir!!!



    También te podría Interesar.
     
    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)


    Introducción y Generalidades Java Enterprise Edition (JEE)

    $
    0
    0
    Java Enterprise edition es una de las 3 ramas tecnológicas en las que se enfoca java junto con JME y JSE.
    Como se ha mencionado anteriormente JEE es una 

    especificación para crear sistemas de información web con altos nivel de robustez y seguridad al vincular varias tecnologías o apis java para la construcción de estos sistemas.

    En este video les mostraré generalidades sobre esta tecnología y mencionaré algunas de sus principales características (es importante que refuercen estos temas ya que no voy a entrar en detalles, pues la idea es que lo vayamos revisando en otras oportunidades.)



    J2EE

    Debemos hablar inicialmente del estándar de desarrollo J2EE, se puede decir que fue la primer especificación de esta tecnología web, nace gracias a la necesidad de construir aplicaciones a nivel empresarial teniendo en cuenta la llegada del internet y con el el nacimiento de nuevas tecnologías y un sinfín de posibilidades.


    Dentro de las características del j2ee podemos mencionar que se vincula el concepto de desarrollo por capas así como otros conceptos como el desarrollo de componentes, el trabajo con servidores, conceptos como Enterprise java beans, servlets, jsp, la asociación de la capa de presentación y la de negocio gracias a los archivos de configuración como el descriptor de despliegue, el faceConfig para establecer reglas de navegación entre otros.


    Sin embargo esta especificación presentó molestias ya que se tornaba muy complejo el desarrollo de aplicaciones web pues se requería de varios procesos, gran cantidad de código y configuración para poner a tope un sistema de información, esto hizo que el jee tuviera que ir realizando mejoras en su especificación.



    JEE5

    Se da un salto a nivel de mejoras de la especificación... deja de nombrarse la versión de de la especificación y pasa a ser conocida solo como JEE...

    Sin embargo dadas las mejoras aún se hace referencia a la versión de java del momento (JEE5, JEE6, JEE7, JEE8...) siendo JEE5 la que marca la diferencia en torno a dicho cambio...


    Con la evolución a JEE5 se dio un nuevo aire al desarrollo empresarial, está nueva especificación brindó a los desarrolladores nuevas apis que permitieron reducir tiempos de desarrollo, reducir la complejidad, aumentar la eficiencia de los sistemas en cuanto a velocidad y rendimiento.


    Jee5 vincula el uso de anotaciones y se da un nuevo enfoque de programación basado en pojos, se habla de la inyección de dependencias,  se da una nueva alternativa para el manejo de la persistencia gracias al uso de jpa entre otras mejoras.


    Las aplicaciones JEE5 en teoría son mucho más concisas y eficientes que antes ya que reducen considerablemente el código fuente, pues gracias al uso de anotaciones y jpa ya no es necesario realizar procesos como reglas de navegación en el faceconfig o la aplicación del patrón DAO para hacer referencia a entidades de la BD (recordemos que este patrón nos indica que debemos crear una clase por cada tabla de la base de datos, y dichas clases son las encargadas de centralizar todos los procesos asociados a ella), con jpa no es necesario lo que nos permite evitar la creación de todas estas clases.


    JEE6 y JEE7


    Continúan con el mismo enfoque de JEE5 al realizar mejoras en la forma como desarrollamos software, la adecuación de nuevas tecnologías y optimización de procesos existentes, se mejora el tema de pruebas unitarias, se vinculan nuevas Appis para manejar la concurrencia, trabajo con webSockets, JSON, HTML5. 


    Mejoras que cada vez van facilitando el trabajo de los desarrolladores que si bien sigue siendo un poco complejo si lo comparamos con la primer especificación a la actualidad nos daremos cuenta que se ha reducido considerablemente.

    ¿Que veremos próximamente?

    En las próximas entradas y vídeos nos adentraremos más en este mundo de la programación JEE, veremos las características que trae consigo esta especificación y pasaremos a los aspectos técnicos acompañados de ejemplos que nos permitirán crear nuestras propias aplicaciones empresariales...

    ¿Donde encuentro más?

    En mi blog y en mi canal les he venido compartiendo material en torno a este gran lenguaje de programación, pueden encontrar muchos artículos y vídeos desde cero, les muestro como descargar las herramientas necesarias para empezar a programar, vamos subiendo cada vez más por los conceptos básicos, pasando por los conceptos de programación orientada a objetos, patrones, hilos, estructuras de datos, acceso a bases de datos entre otros,  hasta construir aplicaciones con interfaces grafías de usuario.


    Además podrán encontrar un curso desde cero donde les enseño a crear aplicaciones móviles en androidmediante una secuencia de vídeos paso a paso que constantemente se está actualizando.


    Y ahora iniciaré la secuencia también desde cero donde nos adentraremos al mundo del java Enterprise edition, les mostraré como configurar el ambiente de desarrollo y como crear sus primeras aplicaciones web con java.


    Por eso los invito a que visiten a codejavu.blogspot.com, que visiten mi canal Cristian Henao y que estén muy pendientes de las nuevas secuencias





    También te podría Interesar. 

    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)







    Conceptos Básicos Java Enterprise Edition

    $
    0
    0
    En la entrada anterior vimos una introducción rapida y general de la especificación JEE, en esta entrada veremos algunas de sus principales carácteristicas o conceptos básicos, conceptos fundamentales para el trabajo JEE.


    servlet

    Los servlets llegan con la especificación j2ee y básicamente son un componente web escrito en java que se usa para extender la funcionalidad del protocolo http, es una clase java que extiende de httpServlet y hace uso de los métodos doGet y doPost para procesar peticiones y respuestas.



    Dentro del código de la clase creábamos código html embebido y lo hacíamos mediante un string que luego se retornaba y se transformaba en la página web, lo que claramente era un poco desorganizado pues se mezcla código java con código html.
     

    JSP

    Los java serper pages son páginas que permiten vincular parte de lógica java, si en los servlet tenemos una clase y metemos código html aquí es lo contrario, estas permiten crear contenido web dinámico que luego se procesa traduciendo el jsp a un servlet que es compilado y ejecutado

    JSF

    Java server faces es un framework para la capa de presentación, puede usar páginas jsp o xhtml para la construcción de las páginas web y se crea como solución para independizar la lógica de negocio de la capa de presentación gracias al patrón MVC pues como se mencionó tanto los servlets como los jsp permitían esta mezcla de códigos.

    Jsf permite la reutilización de componentes de la interfaz de usuario, hace uso de etiquetas jsf para vincular diferentes componentes gráficos así como validaciones a formularios directamente desde la página. 


    Beans / java beans

    Un bean es una clase java compuesta por un constructor vacio, métodos set y métodos get, los típicos pojos que alguna vez hemos escuchado,  estos permiten ser la referencia directa de nuestras páginas, si por ejemplo tengo un formulario para el registro de personas, podría tener mi clase PersonaBean que haga referencia a los diferentes campos con el fin de que el sistema los pueda procesar.

    EJB

    Un Enterprise java bean es un componente del servidor que encapsula la lógica de negocio de una aplicación.


    Es el eje central del concepto de componentes ya que estos pueden ser portables, reutilizables, escalables, pues como se menciona encapsulan comportamientos de la lógica de negocio que luego son desplegados en un contenedor para proveer servicios.

    En la especificación j2ee  se debían crear interfaces remotas y locales para poder darle vida al ejb pero en jee5 con la nueva versión se vuelve mas fácil el desarrollo de esta lógica de negocio gracias al uso de anotaciones, de esta manera podemos convertir un bean normal en un ejb al que le daremos una nueva implementación o uso dentro de nuestro sistema, permitiendo características como seguridad, procesos asíncronos, trabajo con webservices, inyección de dependencias, mensajería entre otros.

    Anotaciones.

    Ya antes hemos usado anotaciones, cuando heredamos o implementamos métodos encontramos la anotación @override lo cual nos indica que estamos sobreescribiendo algo por ejemplo, esta y otras anotaciones son incluidas por defecto en java, para la parte web y principalmente desde jee5 las anotaciones forman parte activa de todo el proceso ya que nos proporcionan un contexto adicional a nuestro sistema, gracias a estas podemos podemos reducir bastante procesos que se realizaban antes.


    Por ejemplo Como se mencionó anteriormente en la j2ee debíamos hacer uso del descriptor de despliegue y reglas de navegación para poder comunicar nuestras páginas con los ejb ahora este proceso es opcional ya que gracias al uso de anotaciones se puede hacer directamente ahorrándonos tiempo considerable en desarrollo, otro ejemplo ya mencionado es el tema de las entidades, podemos anotar una clase como entity y con esto indicamos que hace referencia a una entidad de la base de datos, lo que no ahorra tener que implementar el patrón DAO.

    Contenedor

    Cuando trabajamos con jse y compilamos un proyecto java normal, estamos haciendo uso de los servicios que nos provee la máquina virtual de java, en entorno web es igual, además de la máquina virtual hacemos uso de un contenedor, siendo este  lo que conocemos como un servidor de despliegue, el que nos permite instalar nuestro sistema y desplegarlo, básicamente esa instalación consiste en la ejecución de los archivos empaquetados los cuales son hubicados dentro del contenedor que proporciona el entorno necesario para que los componentes ejb puedan vivir y ejecutarse sin problema.


    ¿Donde encuentro más?

    Existen muchas mas características y elementos a tener en cuenta en torno a java web, sin embargo quise contar solo la generalidad y a medida que vamos avanzando iremos conociendo muchas mas.

    En los próximos videos y entradas empezaremos a configurar nuestro ambiente de desarrollo para poder crear un primer proyecto web.

     
    En mi blog y en mi canal les he venido compartiendo material en torno a este gran lenguaje de programación, pueden encontrar muchos artículos y vídeos desde cero, les muestro como descargar las herramientas necesarias para empezar a programar, vamos subiendo cada vez más por los conceptos básicos, pasando por los conceptos de programación orientada a objetos, patrones, hilos, estructuras de datos, acceso a bases de datos entre otros,  hasta construir aplicaciones con interfaces grafías de usuario.

    Además podrán encontrar un curso desde cero donde les enseño a crear aplicaciones móviles en androidmediante una secuencia de vídeos paso a paso que constantemente se está actualizando.


    Y ahora iniciaré la secuencia también desde cero donde nos adentraremos al mundo del java Enterprise edition, les mostraré como configurar el ambiente de desarrollo y como crear sus primeras aplicaciones web con java.


    Por eso los invito a que visiten a codejavu.blogspot.com, que visiten mi canal Cristian Henao y que estén muy pendientes de las nuevas secuencias


    Y Tu!!!... Que otras ventajas o Desventajas conoces? Anímate y comparte tu opinión....


    También te podría Interesar. 

    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)

     

    Configuración Ambiente de Desarrollo Java Web

    $
    0
    0
    Para crear nuestro primer proyecto java web debemos adecuar el ambiente de trabajo, en esta entrada veremos como montar nuestro entorno de desarrollo donde les explicaré lo necesario para vincular el JDK, el IDE Eclipse y el Servidor Wildfly con el que vamos a trabajar en el blog y la secuencia de vídeos del canal.


    Preparando el Entorno.

    Como se mencionó para  poder crear proyectos web con Java se debe tener el ambiente de trabajo ideal de modo que podamos crear nuestros sistemas y con ellos la vinculación de diferentes tecnologías...

    Descarga e instalación JDK 

    El JDK (Java Development Kit) es el kit de desarrollo para poder trabajar con el lenguaje java, nos provee el conjunto de herramientas que nos permiten desarrollar en este lenguaje, sin el JDK no podríamos compilar, ejecutar o desplegar nuestras aplicaciones.

    Anteriormente hice una entrada donde explico el proceso de descarga e instalación, esto lo pueden consultar aquí, adicionalmente para la nueva secuencia preparé el siguiente vídeo donde se ve nuevamente el proceso paso a paso.



    Descarga de Eclipse.

    Eclipse es uno de los entornos integrados de desarrollo (IDE's) más populares para el trabajo con Java, no es el único ya que existen muchos otros muy potentes y robustos como por ejemplo Netbeans siendo este (creo yo) la principal competencia de Eclipse (más cuando netbeans es el IDE oficial de java), sin embargo a nivel empresarial Eclipse es muy apetecido gracias a la libertad que brinda a nivel de configuración, velocidad entre otros aspectos que no entraré a profundizar aquí, sin embargo los invito a revisar este video donde hago una comparativa general sobre estos dos entornos de desarrollo.

    Igual que con el JDK en mi blog pueden encontrar esta entrada donde muestro como descargar Eclipse sin embargo teniendo en cuenta que actualmente hay muchas versiones de este IDE, voy a realizar el proceso aquí nuevamente...

    De la misma manera pueden consultar el proceso en el siguiente vídeo...


    Actualmente desde la página oficial de eclipse encontramos la versión Oxygen de este IDE, sin embargo para efectos del laboratorio trabajaremos con la versión Neon ya que está nos brindará soporte para la vinculación del servidor WildFly con el que vamos a trabajar.

    La descarga pueden realizarla desde el siguiente enlace https://www.eclipse.org/downloads/packages/release/neon/3  desde allí pueden elegir el entorno Neon, o si ustedes quieren pueden descargar igual la última versión de Eclipse.



    Desde allí seleccionamos la arquitectura de nuestro sistema (32 o 64 bit) y damos clic en el, al hacerlo se carga una nueva página desde la cual podemos descargar el IDE.



    Al dar clic en "download" se presenta una ventana donde definimos el lugar en el que almacenaremos el entorno, guardamos y descomprimimos.

    Al hacerlo podemos ingresar a la carpeta y ejecutar el eclipse.exe que nos permitirá iniciar el IDE.


    Descarga del Servidor Wildfly.

    El servidor representa el contenedor de despliegue en el cual podemos "instalar" nuestro sistema (desplegarlo), estos contienen el entorno necesario para que el sistema pueda vivir y ser ejecutado...

    Wildfly es una variante del popular JBoss, es un servidor de aplicaciones JEE de código abierto desarrollado  en Java, por tal razón se puede trabajar con el desde cualquier sistema operativo que tenga previamente instalado un JDK (Java Virtual Machine).

    Existen muchas otras alternativas para desplegar nuestras aplicaciones, una de ellas es el popular Tomcat que se usa bastante en este tipo de tutoriales y a nivel educativo, sin embargo en un entorno de producción, dependiendo del tamaño del sistema y las tecnologías que vincule, Tomcat puede quedarse corto, ya que este es un contenedor de Servlets mientras que Wildfly es un contenedor de aplicaciones JEE completo  lo que permite brindar soporte para tecnologías como EJB, JMS entre otros, tecnologías mas robustas para el caso de la especificación JEE...

    Descarga.

    Igual que en los procesos anteriores, preparé un vídeo donde explico y realizo la descarga del servidor.


    Para la descarga del Servidor vamos a dirigirnos a la página oficial desde el enlace de descarga http://wildfly.org/downloads/  desde allí seleccionamos la versión que queremos descargar.


    en mi caso realicé la descarga de la versión 10.1 ya que siempre me gusta trabajar con una versión anterior dado que en ocasiones las últimas versiones aún no son estables.

    Después de descargarlo podemos descomprimir el servidor en cualquier directorio de nuestro equipo, sin embargo recomiendo realizar la copia en la partición C:/ 


    ya con esto tenemos el servidor en nuestro equipo y podemos proceder a crear la variable de entorno JBOSS_HOME 

    Creación de la variable de Entorno JBOSS_HOME

    Después de descomprimir el servidor en la raíz de C:/ procederemos a crear la variable de entorno JBOSS_HOME tal como se hace cuando creamos la variable JAVA_HOME, pero en este caso apuntamos a la ruta de instalación del servidor.




    Después de esto y si todo está bien podemos verificar el funcionamiento ejecutando el servidor por medio del archivo standalone.bat que se encuentra en el directorio bin del servidor.

    Al hacerlo se carga una consola donde al final nos indica que el servidor está iniciado y listo para usar.


    Por ahora no usaremos el servidor de esta manera, por esa razón podemos detenerlo estando dentro de la consola y haciendo “Ctrl+c” esto detiene el servidor, el cual nos preguntara si queremos cerrarlo (S/N) ingresamos S y damos Enter.

    Nota: Puede que el proceso anterior no funcione correctamente y se presenten mensajes similares a estos



    Esto se da porque el sistema presenta un problema al intentar identificar la variable de entorno JBOSS_HOME, para esto se debe revisar que la variable si exista y que la ruta corresponde a la misma ruta donde se almacenó el servidor (en ocasiones al descomprimir el server queda en 2 carpetas con el mismo nombre) adicionalmente se debe revisar que la variable de entorno JAVA_HOME exista. 


    IMPORTANTE: Las variables deben crearse en la sección “Variables del Sistema” no en “Variables de usuario”

    Agregar Server al Eclipse (Para versión Neon o Superiores)


    Ahora el siguiente paso es vincular el Servidor al IDE Eclipse, para hacerlo primero abriremos la vista server, para esto vamos a Window/Show View/Servers


    Al hacerlo se carga la vista Servers donde podemos dar en el enlace o simplemente clic derecho/New/Server lo que permite cargar la siguiente ventana.


    como vemos desde aquí podemos comprobar que se cuenta con soporte directo para el servidor WildFly en el directorio “Red hat JBoss Middleware” seleccionamos la opción del servidor y damos next, después de un rato se nos presenta una pantalla en la que debemos aceptar los términos de licencia y presionamos finish.

    Acto seguido se presenta una ventana de carga indicando el proceso de instalación, posteriormente un dialogo de confirmación al cual le diremos “ok” para continuar con la instalación.


    Después de un momento se presentará otro dialogo solicitando autorización para reiniciar el IDE y que los cambios surtan efecto damos clic en “Yes” y esperamos el reinicio.

    Después de reiniciar el entorno de desarrollo procedemos a realizar el mismo paso de agregar nuevo server desde la pestaña “Servers” pero esta vez veremos que ya aparecen vinculadas las diferentes alternativas de servidores que acabamos de configurar.



    Seleccionamos alguna de las alternativas disponibles y damos clic en “next” (para este ejemplo se seleccionó la opción WildFly 10.x) 


    En la ventana que se presenta dejamos las configuraciones por defecto y damos clic en “Next” Después de esto se presenta una nueva ventana donde debemos agregar la ruta del servidor que tenemos almacenado en nuestra máquina.


    Al agregar la ruta damos clic en “finish” y ya tendríamos el servidor en el IDE, el cual podemos desplegar desde la pestaña donde vinculamos el servidor, damos clic derecho y luego "start"


    Al ejecutarlo se presenta en consola el started indicando que el servidor está listo para usar. 

    Instalar Plugin JBossTools.

    JBoss Tools es una herramienta compuesta por un conjunto de plugins con características enfocadas al desarrollo y soporte de aplicaciones Web pudiendo vincular además tecnologías como J2EE, JBoss, Seam, Hibernate, JSF, JSP,  Maven, servidores de aplicaciones, Struts, HTML, CSS, en fin, un gran listado de características útiles brindando un soporte muy completo para el desarrollador.


    ya antes en este blog hice esta entrada donde muestro el proceso de vinculación, sin embargo se hizo para una versión de Eclipse diferente a la aquí trabajada, por esa razón realizaré el proceso nuevamente.

    para vincularlo nos vamos al MarketPlace desde el menú Help de Eclipse.



    al hacerlo se carga una ventana donde debemos buscar el jboss tools y seleccionar su instalación

    luego de esto el sistema empieza a descargar los paquetes necesarios para el trabajo con esta herramienta, se van presentando avances sobre la instalación en los cuales damos clic en confirmar o siguiente (este proceso puede ser un poquito demorado)


    posteriormente se carga una ventana donde se nos pide que aceptemos los términos de licencia para poder continuar con la instalación, allí seleccionamos  el radio de aceptar y damos finish


    ya con esto se ejecuta nuevamente el proceso de instalación hasta que nos presentan unas ventanas emergentes pidiendonos que reiniciemos el Eclipse, le damos clic en aceptar y listo, al arrancar nuevamente el IDE este ya tendría vinculado el plugin JBoss Tools...

    Y Listo!!!

    Esta es una configuración base para empezar nuestros desarrollos, la idea es que puedan seguir el paso a paso para tener el entorno completamente listo, en los próximos vídeos y entradas continuaremos trabajando con nuestro ambiente de desarrollo para poder crear un primer proyecto web.
     
    En mi blog y en mi canal les he venido compartiendo material en torno a este gran lenguaje de programación, pueden encontrar muchos artículos y vídeos desde cero, les muestro como descargar las herramientas necesarias para empezar a programar, vamos subiendo cada vez más por los conceptos básicos, pasando por los conceptos de programación orientada a objetos, patrones, hilos, estructuras de datos, acceso a bases de datos entre otros,  hasta construir aplicaciones con interfaces grafías de usuario.

    Además podrán encontrar un curso desde cero donde les enseño a crear aplicaciones móviles en androidmediante una secuencia de vídeos paso a paso que constantemente se está actualizando.


    Y ahora iniciaré la secuencia también desde cero donde nos adentraremos al mundo del java Enterprise edition, les mostraré como configurar el ambiente de desarrollo y como crear sus primeras aplicaciones web con java.


    Por eso los invito a que visiten a codejavu.blogspot.com, que visiten mi canal Cristian Henao y que estén muy pendientes de las nuevas secuencias




    También te podría Interesar. 

    ¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó, te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)
    Viewing all 129 articles
    Browse latest View live