domingo, 22 de febrero de 2015

Configurar Liferay para Tomcat y MYSQL

Hola, esta vez veremos como configurar Liferay en un servidor Tomcat y con una base de datos MySQL:

1.- Creamos el fichero : C:\Servidores\liferay-portal-tomcat-6.0.6\liferay-portal-6.0.6\tomcat- 6.0.29\webapps\ROOT\WEB-INF\classes\portal-ext.properties y añadimos lo siguiente:

#
# MySQL
#
jdbc.default.driverClassName=com.mysql.jdbc.Driver
jdbc.default.jndi.name=jdbc/LiferayPool
jdbc.default.url=jdbc: mysql://localhost/nombreDeLaBaseDeDatos?useUnicode=true&characterEncoding=UTF-8&useFastDateParsing=false
jdbc.default.username=user
jdbc.default.password=pass

Cambiamos nombreDeLaBaseDeDatos, user y pass por los tuyos.

2.- Añadimos el fichero : C:\rutaAlServidor\liferay-portal-6.0.6\tomcat-6.0.29\conf\Catalina\localhost\ROOT.xml

<Resource
name="jdbc/LiferayPool"
auth="Container"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost/nombreDeLaBaseDeDatos?useUnicode=true&characterEncoding=UTF-8"
username="user"
password="pass"
maxActive="100"
maxIdle="30"
maxWait="10000"
/>

Cambiamos nombreDeLaBaseDeDatos, user y pass por los tuyos.

3.- Reiniciamos Tomcat y listo

martes, 2 de septiembre de 2014

Enviar y recibir json con ajax, jquery y php.

Hola; en este post veremos como recoger los datos de un formulario con jquery y enviar una petición con ajax a un servidor php.
El servidor php envia un json como resultado y finalmente ajax recibe ese resultado y lo lanza en un alert.

1. Creamos el fichero "index.html" con un formulario.

<!DOCTYPE html>
<html>
<head>
<script src="https://code.jquery.com/jquery-2.1.1.min.js"></script>
<script src="conexionServidor.js"></script>
</head>
<body>
<form id="formulario_prueba_ajax">
<input type="text" id="nombre">
<input type="submit" value="Enviar">
</form>
</body>
</html>

2. Creamos el fichero "conexionServidor.js" que contiene la recogida de datos del formulario y la petición ajax al servidor y muestra los mensajes que este devuelve.

$(document).ready(function() {

// Al pulsar el botón submit del formulario
$('#formulario_prueba_ajax').submit(function() {

// Obtengo los valores de los input de mi formulario
var nombre = $('#nombre').val();

var datos = {
'nombre' : nombre
}

// Hacemos la petición ajax
$.ajax({
type : 'POST',
url : 'servidor.php',
data : datos,
dataType : 'json',
success : success,
error : error
});

function success(data) {
var valor = data.mensaje;
alert(valor);
alert(data.saludo);
};

function error(){
alert("error");
}

// detiene el submit por defecto
return false;
});

});

3. Creamos el fichero servidor.php que recibirá lo que le mandamos por ajax y devuelve un json que será porcesado en la función success de conexionServidor.js

<?php
$nombre = $_POST['nombre'];

$data = array();

/ / aqui se hace cualquier procesamiento con la base de datos por ejemplo o cualquier otra cosa

$data['mensaje'] = $nombre." se ha conectado.";
$data['saludo'] = "Que disfrutes ".$nombre;

echo json_encode($data);
?>

Listo hemos terminado. Un saludo....hasta el próximo post.

viernes, 15 de agosto de 2014

JSON y PHP : Leer y devolver JSON

Hola, este post va dedicado a un par de amigos entusiastas de la programación que van junto a mi de la mano en este camino del saber. En esta ocasión veremos como recibir parámetros en PHP y comporbar su existencia en una fuentes de datos; en nuestro caso, un fichero JSON ( podría de un base de datos, un fichero xml e incluso un fichero de texto plano). La intensión es poder leer desde el JSON y devolver un JSON.
Manos a la obra:

Para esta "receta" necesitamos:

1. Un servidor xamp, wamp o lamp dependiendo del gusto del "chef"
1. Un fichero JSON
2. Un programa PHP que haga que deseamos.

1. Fichero JSON ( usuarios.json )
--------------------------------

[{"usuario":"yo","contrasenia":"si"}]

2. Fichero PHP (servidor.php )
--------------------------------
<?php

$parametroRecibidoUsuario =$_GET['usuario'];
$parametroRecibidoPass =$_GET['contrasenia'];

// Guardo el contenido del fichero de usuarios
$ficheroUsuarios = file_get_contents('usuarios.json');

 // Decodifico el fichero JSON en un array
 $datosJSON =  json_decode($ficheroUsuarios,true);

// Construyo mi array de mensajes para los resultados
$resultados = array();

// Recorro los elementos del array JSON ($datosJSON)
foreach($datosJSON as $obj){

// Por cada elemento del array obtengo el usuario y contraseña
$usuario = $obj['usuario'];
$contrasenia = $obj['contrasenia'];

// Creo un array para los mensajes
$mensajes = array();

// Comparo los datos envidos con los datos leídos
if($usuario == $parametroRecibidoUsuario && $contrasenia ==
parametroRecibidoPass){

// Creo el elemento 'mensajeok' en el array 'mensajes'
$mensajes['mensaje'] = 'Hola '.$usuario;

// Aqui se pueden introducir muchos mas campos; de momento solo uno
// Meto en array de mensajes en el array 'resultados'
array_push($resultados, $mensajes);
}else{
$mensajes['mensaje'] = 'No te has podido conectar';
array_push($resultados, $mensajes);
}
}

/* Finalmente convierto los resultados a formato json*/
$resultadosJson = json_encode($resultados);

/* Devuelvo el json */
echo $resultadosJson;
?>

¡¡¡ Listo !!! para probar si funciona haremos los siguiente:

http://nombredemidominio.com/servidor.php?usuario=yo&contrasenia=si

¿Quieres descargar el código?.... has click aqui

domingo, 8 de junio de 2014

CANVAS - Figuras, Texto, Degradado y Transformaciones

Hola en este post veremos como usar la etiqueta <canvas></canvas> en HTML5.

En todo los casos se siguen los siguientes pasos:

1. Creamos la etiqueta canvas en html

En HTML usamos la etiqueta canvas y definimos su ancho y altura:

<canvas id="id_del_canvas" width="" heigth=""></canvas>

2. Dibujamos en el canvas con javascript

En JavaScript obtenemos el canvas y dibujamos:

var canvas = document.getElementById("id_del_canvas");

var dibujo = canvas.getContext("2d");

..... dibujamos con las funciones definidas para canvas

Vamos con los ejemplos:

// DIBUJAR RECTÁNGULOS


function dibujarRectangulo(){
    var canvas = document.getElementById("el_canvas"); // declarmos el canvas
    var dibujo = canvas.getContext("2d"); // se usará gráficos en dos dimensiones
    dibujo.rect(10,10,20,20);       // definimos el rectangulo
    dibujo.fill();                  // creamos o mostramos el rectángulo     
}

Para definir el rectángulo se utilizan las coordenadas x (horizontal) e y (vertical), 10 píxeles y 10 píxeles, contados a partir del ángulo superior izquierdo del elemento canvas, con un ancho de 200 píxeles y una altura de 100 píxeles (dibujo.rect(10,10,200,100)).
La cuarta línea solicita que se cree o se muestre el rectángulo definido mediante: dibujo.fill().
Aunque, también se podría haber usado el método fillRect() para definir y dibujar el rectángulo en una sola sentencia.

// DIBUJAR CÍRCULOS


function dibujarCirculo(){
    var canvas = document.getElementById("el_canvas");
    var dibujo = canvas.getContext("2d");
    dibujo.fillStyle="rgb(0,255,127)";
    dibujo.arc(50,50,40,0,2*Math.PI,true);
    dibujo.fill();
}

Para dibujar un arco o un círculo en la posición (x,y), se utiliza la función arc(x, y, radio, ángulo inicio, ángulo final, dirección) donde sus parámetros son:

x: coordenada horizontal calculada a partir del centro del óvalo.
y: coordenada vertical calculada a partir del centro del óvalo.
radio: radio del óvalo.
ángulo inicio: punto de partida del arco en radianes.
ángulo final: punto de llegada del arco en radianes.

direccción: alor boleano que indica que el arco será dibujado en el sentido de las agujas del reloj (valor true) o al contrario (valor false).

// DIBUJAR TRAZADOS


function dibujarTrazados(){
    var canvas_trazado = document.getElementById("canvas_trazado");
    var dibujo = canvas_trazado.getContext("2d");
    dibujo.beginPath();                 // Inicio el trazado
    dibujo.moveTo(150,50);              // Coordenadas de inicio
    dibujo.lineTo(200,120);             // Dibuja una línea desde el punto 
                                        // anterior hasta el punto 200,120
    dibujo.lineTo(90,120);              // Crea una línea hasta las nuevas coordenadas
    dibujo.closePath();                 // Cierra el trazo.
    dibujo.stroke();                    // Dibuja el contorno del trazado definido
}

beginPath(): esta función le indica al contexto del canvas que se va a comenzar a dibujar un camino. No tiene ningún parámetro y por sí sola no hace ninguna acción visible. Se invoca en primer lugar, antes de comenzar a dibujar el camino o trazado incorporando segmentos.
moveTo(x,y): esta función mueve el puntero imaginario a una posición específica donde comenzar o continuar el trazado. En realidad, no dibuja nada en sí, pero permite definir el primer punto del camino.
closePath(): esta función sirve para cerrar un trazado o camino a su punto inicial, dibujando una línea recta desde el último punto hasta el punto de partida (definido con moveTo()). Tampoco recibe ningún parámetro.
stroke(): esta función dibuja el contorno de un trazado a diferencia de fill() que rellena de color el trazado.
fill(): Este método dibuja el trazado como una figura sólida. Cuando se usa este método no es necesario cerrar el trazado con closePath(), el trazado es automáticamente cerrado con una línea recta trazada desde el punto final hasta el origen.
lineTo(x,y): esta función dibuja una línea recta, desde la posición actual del puntero de dibujo, hasta el punto (x,y) que se indique como parámetro.

// DIBUJAR COLORES Y SOMBRAS


function dibujarColoresSombras(){

    var canvas_sombras=document.getElementById('colores_sombras');  
    var dibujo=canvas_sombras.getContext('2d');
    dibujo.fillStyle="#2E64FE";
    dibujo.shadowBlur=40;
    dibujo.shadowColor="black";
    dibujo.shadowOffsetX=20;
    dibujo.shadowOffsetY=10;
    dibujo.arc(50,50,40,0,2*Math.PI,true);  // Crea una línea hasta las nuevas coordenadas
    dibujo.fill();                          // Cierro el trazado y relleno la figura
}

Existe un atributo del contexto del canvas que permite cambiar el color de relleno: fillStyle()

dibujo.fillStyle="#000099";

El atributo strokeStyle() funciona de la misma forma que fillStyle con la diferencia que permite definir el trazado del dibujo.

dibujo.strokeStyle="#000099";

shadowBlur: para definir el difuminado de la sombra.
shadowColor: para definir el color.
shadowOffsetX: para definir la distancia horizontal (si no se indica nada, la sombra aparecerá alrededor del dibujo).
shadowOffsetY: para definir la distancia vertical (si no se indica nada, la sombra aparecerá alrededor del dibujo).

// DIBUJAR TEXTO


    function dibujarTexto(){
         var canvas_texto=document.getElementById('texto');  
         var dibujo=canvas_texto.getContext('2d');
         dibujo.textBaseline="ideographic";
         dibujo.textAlign="center";
         dibujo.font="2em Nueva";
         dibujo.fillStyle="purple";
         dibujo.fillText("TEXTO CANVAS",150,75);
   }

strokeText(texto, x, y): este método dibujará el texto especificado en la posición x,y como una figura vacía (solo los contornos). Puede también incluir un cuarto valor para declarar el tamaño máximo. Si el texto es más extenso que este último valor, será encogido para caber dentro del espacio establecido.
fillText(texto, x, y): Este método es similar al método anterior excepto que esta vez el texto dibujado será sólido.

// DIBUJAR DEGRADADO

function dibujarDegradado(){

    var canvas_degradado=document.getElementById('canvas_degradado');  
    var dibujo=canvas_degradado.getContext('2d');
    var degradado = dibujo.createRadialGradient(50,50,5,90,60,100);
    degradado.addColorStop(0,"OrangeRed");
    degradado.addColorStop(1,"Gold");
    dibujo.fillStyle=degradado;
    dibujo.arc(120,80,60,0,2*Math.PI,true);
    dibujo.fill();
}

createLinearGradient(x0, y0, x1, y1) Este método crea un objeto que luego será usado para aplicar un gradiente lineal al lienzo. Donde sus parámetros son: x0: coordenada x del punto inicial del degradado. y0: coordenada y del punto inicial del degradado. x1: coordenada x del punto final del degradado y1: coordenada y del punto final del degradado.
createRadialGradient(x1, y1, r1, x2, y2, r2) Este método crea un objeto que luego será usado para aplicar un gradiente circular o radial al lienzo usando dos círculos. Los valores representan la posición del centro de cada círculo y sus radios. x1: coordenada x del círculo inicial del degradado. y1: coordenada y del círculo inicial del degradado. r1: radio del círculo desde donde comenzar. x2: coordenada x del círculo final del degradado. y2: coordenada y del círculo final del degradado. r2: radio del círculo desde donde comenzar.
addColorStop(posición, color) Este método especifica los colores a ser usados por el gradiente. El atributo posición es un valor entre 0.0 y 1.0 que determina dónde la degradación comenzará para ese color en particular.

// DIBUJAR TRANSFORMACIONES

function dibujarTransformacion(){

    var canvas_degradado=document.getElementById('canvas_transformaciones');  
    var dibujo=canvas_degradado.getContext('2d');
    dibujo.fillStyle="gold";
    dibujo.arc(120,80,30,0,2*Math.PI,true);
    dibujo.fill();
    
    dibujo.translate(90,70);
    dibujo.arc(120,80,40,0,2*Math.PI,true);
    dibujo.fill();
}

translate(x,y): Este método de transformación es usado para mover el origen del lienzo. Es decir, permite mover el punto 0,0 a una posición específica para usar el origen como referencia para nuestros dibujos o para aplicar otras transformaciones.
rotate(angulo): Este método de transformación rotará el lienzo alrededor del origen tantos ángulos como sean especificados.
scale(x, y): Este método de transformación incrementa o disminuye las unidades de la grilla para reducir o ampliar todo lo que esté dibujado en el lienzo.
Otros.

Descargar el código

jueves, 29 de mayo de 2014

Instalar Flash en Ubuntu 14.04 con un solo comando

Este comando te permite instalar Adobe Flash en un comando.

Probado con Ubuntu 14.04

Abrimos una terminal y escribimos el siguiente comando :

sudo apt-get install flashplugin-installer

Listo a ver vídeos, escuchar la radio y un montón de cosas....que lo disfrutes!!!

sábado, 19 de abril de 2014

Programación de Red - JAVA ( 6. Programación de sockets: Más allá de los protocolos estándar)

Contenidos:

6. Programación de sockets: Más allá de los protocolos estándar.

Esta parte de Java es una de las más emocionantes; o por lo menos eso fue para mi cuando empecé a conocer los Sockets; ya que estos permiten especificar en cierta medida tu propia forma de comunicación entre cliente y servidor. Esta capacidad de poder definir tu forma de comunicación te permite enviar solo los datos necesarios, reduciendo los encabezados o eliminándolos completamente. Como consecuencia la comunicacion por socket es menos pesada que la comunicación con protocolos estandar; ademas la comncicacion por socket es bireccional ( flujo de bites doble); al contrario de lo que sucede en la comunicacion basada en solicitudes y respuestas.

En java tenemos las clases Socket y ServerSocket del paquete java.net para trabajar con socket "normales"; digo normales por que también existe la posibilidad de los Socketc SSL que conectan de forma segura con https y certificados, pero que en este artículo pasaremos de largo sobre el tema...intentaré hablar sobre sockets SSL en otro artículo.

Un socket es una conecxion en un extremo de una red IP. La direccion de un socket contiene una IP y un puerto. Cuando instanciamos la clase ServerSocket se crea un servidor que se ejecuta en memoria y escucha las solicitudes de cliente ( otros programas que se conectarán con Socket ).

El programa cliente debe crear una instancia de Socket ( el socket cliente ) que apunte a la direcciín IP y puerto del ServeSocket que está ejecutándose.

Los puertos recomendados para un ServerSocket son los mayor a 1024 para evitar conflictos con programas del sistema. Algunos puertos conocidos son : 8080 para HTTP, 443 para HTTPS, 21 para FTP, 389 para LDPA, etc.

Para poder intercambiar datos; tanto el cliente como el servidor deben obtener referencias a flujos de entrada y salida. Bueno y ahora vamos a lo nuestro, a lo que nos gusta.....¡¡¡ a programar !!!!

Vamos a ver un ejemplo muy bien comentado escrito en NetBeans donde se programa por un lado el servidor y por otro el cliente. Consiste en que el cliente se conecta al servidor para solicitar un dato, en nuestro ejemplo el precio de un producto. Nuestro servidor buscará el precio y le devuelve el resultado al cliente. Claro que para ejemplo nos bastará con generar un número aleatorio que represente el precio solicitado, en una aplicación real el almacen de datos para obtener el precio podría ser una base de datos de productos

El Servidor:


package com.pelusadev.programacionenlared;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
 *
 * @author pelusadev
 */

public class Servidor {

public static void main(String[] arg)
{
     ServerSocket serverSocket;
     Socket cliente;

     BufferedReader entrante = null;
     OutputStream saliente = null;

     try {
          // Creamos el socket server escuchando en el puerto 4000
             serverSocket = new ServerSocket(4000);
             System.out.println("Esperando a que los clientes consulten precios");
             while(true)
             {
                // Esperar la solicitud
                cliente = serverSocket.accept();
                 
                // Obtenemos los flujos
                entrante = new BufferedReader(new InputStreamReader(cliente.getInputStream()));      
                saliente = cliente.getOutputStream();
               
                // Recibimos el nombre del producto que se desea consultar;
                String nombreProducto = entrante.readLine();
        
               // Generamos un precio aleatorio
               Double precioAleatorio = new Double(Math.random()*100);
               String precio = precioAleatorio.toString();
         
               // Escribimos la salida
               byte[] mensajeDeSalida = ("El precio del producto " + nombreProducto + " es "+precio).getBytes();
               saliente.write(mensajeDeSalida);
             }
         } catch (IOException ex) {
             Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
         }finally{
          try{
              entrante.close();
              saliente.close();
          }catch(Exception ex){
              System.out.println("Error en el servidor: " + ex);
          }
        }
   }
}

El Cliente:


package com.pelusadev.programacionenlared;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 *
 * @author pelusadev
 */
public class Cliente {
    
    public static void main(String[] arg)
    {
        OutputStream salida = null;
        BufferedReader entrada = null;
    
        Socket clienteSocket=null;
        
        try{
            // Abrimos una conexión socket cliente
            clienteSocket = new Socket("localhost",4000);
            
            System.out.println("Cliente: " + clienteSocket);
            
            // Obtenemos los flujos
            salida = clienteSocket.getOutputStream();
            entrada = new BufferedReader(new InputStreamReader(clienteSocket.getInputStream()));
            
            // Enviar el nombre del producto al servidor
            salida.write(("GoogleGlass"+"\n").getBytes());
            salida.write(("Final"+"\n").getBytes());
            
            String respuesta;
            while(true)
            {
                respuesta = entrada.readLine();
                if(respuesta.equals("Fin"))
                {
                    break;
                }
                System.out.println("Precio: " + respuesta);
            }
        }catch(UnknownHostException uhe){
            System.out.println("UnknownHostException: " + uhe);
        }catch(IOException ex){
            System.out.println("IOException: " + ex);
        }finally{
            try{
                // Cerramos los flujos
                salida.close();
                entrada.close();
                clienteSocket.close();
            }catch(IOException e){
                System.out.println("No se puede cerrar la conexión: " + e.getMessage());
            }            
        }        
    }
}

Ejecución del servidor:

Ejecución del Cliente

Descárgate la clase Servidor
Descárgate la clase Cliente

Programación de Red - JAVA ( 5. Cotización en bolsa: Un programa aplicando lo aprendido )

Contenidos:

5. Cotización en bolsa: Un programa aplicando lo aprendido.

En este artículo lo que se pretende es mostrar como consumir información desde internet; en nuestro caso información bursátil proporcionada por yahoo. Podríamos traernos toda la página html e ir desmenuzando el string para quitar las etiquetas html y quedarnos con el dato que nos interesa. De esta forma corremos el riesgo de que si yahoo cambia las etiqueta de su web tendremos que adpatar nuestro código. Menos mal que estos servicios públicos ofrecen su información en variso formatos (más legible y fáciles de "parsear").

Manos a la obra:

Entramos en : http://finance.yahoo; introducimos un símbolo cualquiera, por ejemplo NKE( símbolo bursátil de Nike) y le damos en Get Quote. Nos aparece la cotización en bolsa de Motorola. Nos interesa la URL que aparece en el navegador: http://finance.yahoo.com/q?s=NKE.

Modificamos el código de nuestra clase LectorWebSite vista en el capítulo 2 Leyendo desde una URL : Hora de conectar y leer de Internet.

url = new URL("http://finance.yahoo.com/q?s=NKE");

Si lo que quieres es quedarte con toda la web; podemos almacenarla en un string:

      String todaLaPagina;
      String textoLeido;
      while(textoLeido = buff.readLine() != null)
      {
        todaLaPagina=todaLaPagina + textoLeido;
      }

Pero como dijimos líneas arriba; esto no es lo más recomendable ya que si yahoo cambia el nombre de los componentes de su web nos veremos obligados a cambiar nuestro código. Por tal motivo usaremos la URL del recurso con la información que necesitamos disponible en formato CSV el que se muestran los valores separados por comas. La dirección en cuestión es:

http://finance.yahoo.com/d/quotes.csv?s=NKE&f=sl1d1t1c1ohgv&e=.csv

Una vez descargado el fichero esta es la información que contiene:

MMI,17.10,"4/17/2014","4:03pm",-0.01,17.11,17.26,17.05,15070

Ahora todo se resume a hacer un "split" o usar StringTokenizer para obtener el dato que deseamos.

El código de la clase CotizaciónDeBolsa muestra todo el proceso:


package com.pelusadev.programacionenlared;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.StringTokenizer;

/**
 *
 * @author pelusadev
 */
public class CotizaciónDeBolsa {
    
    /**
     * static void printCotizaciónDeBolsa(String simbolo)
     * 
     * Se declara como método de la clase ( no es necesario instancia
     * un objeto para usar el método ).
     * Como no devuelve nada, solo pinta en pantalla; su valor de retorno
     * es void.
     * Recibe como parámetro un String.
     * 
     * @param simbolo 
     */
    static void printCotizaciónDeBolsa(String simbolo)
    {
       String csvString; // Para guardar la respuesta a la solicitud
       URL url=null; // La url :-).
       URLConnection urlConn=null; // El enlace de comunicación entre nuestra 
                                   //aplicación y una URL 
       InputStreamReader inStream=null; // Para leer flujos de byte a caracter
       BufferedReader buff=null; // Para leer desde el InputStream
       
       try{
           
           url = new URL("http://finance.yahoo.com/d/quotes.csv?s="+simbolo+"&f=sl1d1t1c1ohgv&e=.csv");
           urlConn = url.openConnection();
           inStream = new InputStreamReader(urlConn.getInputStream());
           
           buff = new BufferedReader(inStream);
           
           // Obtenemos la información como cadena
           csvString = buff.readLine();
           
           // Realizamos la descomposición de la cadena que está separada por comas
           // MMI,17.10,"4/17/2014","4:03pm",-0.01,17.11,17.26,17.05,15070
           StringTokenizer tokenizer = new StringTokenizer(csvString,",");
           
           String empresa = tokenizer.nextToken();
           String precio = tokenizer.nextToken();
           String fecha = tokenizer.nextToken();
           String tiempo = tokenizer.nextToken();
           
           System.out.println("Símbolo: " + empresa +
                   "Precio: " + precio + " Fecha: " + fecha + " Tiempo: " + tiempo);
           
       }catch(MalformedURLException emfurl){
           System.out.println("¿Has escrito bien la URL? : esto es lo que escribiste: " + emfurl.toString());
       }catch(IOException eio){
           System.out.println("No se puede leer desde internet: " + eio.toString());
       }finally{
           try{
               inStream.close();
               buff.close();
           }catch(Exception ex){
               System.out.println("CotizaciónDeBolsa no puede cerrar");
           }
       }
    }
    
    public static void main(String[] args)
    {
        printCotizaciónDeBolsa("NKE");
    }
}

Descárgate la clase CotizacionDeBolsa

Siguiente tema:

Programación de Red - JAVA ( 6. Programación de sockets: Más allá de los protocolos estándar).

Mr. Codi

domingo, 22 de febrero de 2015

Configurar Liferay para Tomcat y MYSQL

martes, 2 de septiembre de 2014

Enviar y recibir json con ajax, jquery y php.

viernes, 15 de agosto de 2014

JSON y PHP : Leer y devolver JSON

domingo, 8 de junio de 2014

CANVAS - Figuras, Texto, Degradado y Transformaciones

jueves, 29 de mayo de 2014

Instalar Flash en Ubuntu 14.04 con un solo comando

sábado, 19 de abril de 2014

Programación de Red - JAVA ( 6. Programación de sockets: Más allá de los protocolos estándar)

Contenidos:

6. Programación de sockets: Más allá de los protocolos estándar.

Programación de Red - JAVA ( 5. Cotización en bolsa: Un programa aplicando lo aprendido )

Contenidos:

5. Cotización en bolsa: Un programa aplicando lo aprendido.

Siguiente tema:

Lo más visto