Weblog de Victor Ramirez

Sábado, febrero 15, 2014

Crear aplicaciones para Twitter desde NetBeans

Filed under: java, jdk, jdk7, netbeans, tutorial, Twitter — Etiquetas: , , , , , , , — vramirez @ 3:05 PM

En el siguiente post crearemos una aplicación ejemplo muy básica y sencilla (sin GUI, de hecho) en NetBeans para conectarnos a Twitter y leer nuestro timeline. Los siguientes son los prerequisitos para este tutorial:

  • Cuenta en Twitter
  • NetBeans IDE 7.x
  • JDK 1.7
  • Twitter4J

Lo primero es loguearnos en el sitio web de desarrolladores para Twitter https://dev.twitter.com/apps. Una vez allí le damos click en crear nueva aplicación. A continuación, diligenciamos un formulario con el nombre que tendrá la aplicación, una breve descripción (10 o más caracteres), y una URL de la App, la cual se supone apunta a una direccion en Internet con información sobre la App. Por ahora, pueden poner cualquiera como en mi ejemplo y cambiarla después (La URL debe ser completa, por ejemplo, debe empezar por http o https…).

Twitter new app

Formulario de creación nueva aplicación en Twitter

Una vez la hemos creado, Twitter nos muestra una serie de opciones de configuración de la aplicación, acá las vamos a repasar brevemente mostrando lo que nos interesa para el tutorial.

En la pestaña “Details” verificar que la opción “Access level” tenga “read-only”. En esta misma pestaña, al final, se encuentra la opción para borrar la aplicación.

En API Keys esta toda la info que necesitaremos darle a nuestra aplicación en NetBeans. En la sección “Your access token” dar click en “Create my access token”. Darle “Refresh” a la página. Ahora tenemos 4 parámetros MUY importantes para nuestra App:

  • API key
  • API Secret
  • Access token
  • Access token secret

Ya veremos porqué debemos tener estos 4 hashes muy presentes. Cabe destacar que dichos hashes son SECRETOS, pues si alguien los obtiene, puede suplantar tu aplicación, incluso tu cuenta de Twitter.

Lo siguiente es descargar la librería de Twitter4j entrando a http://twitter4j.org/ y en el link Download descargar el .zip. Una vez descargado, entrar a NetBeans y en Tools –> Libraries  –> New Library. En el nombre, ponerle nombre a la librería, por ejemplo, “Twitter4j” o algo que la identifique con Twitter. En classpath, darle Add Jar/Folder y buscar la carpeta previamente descomprimida de Twitter4J y en la subcarpeta “lib”, se pueden seleccionar todos los archivos jar, sin embargo, agregando solo el que tenga nombre “core”, bastará.

Libreria de Twitter Twitter4J creada en NetBeans

Libreria de Twitter4J creada en NetBeans

Ahora, con la librería ya creada, debemos crear un nuevo proyecto tipo “Java Aplication” de NetBeans. Al proyecto ya creado, agregarle la librería que se creó en el paso anterior. Sobre el proyecto hacer click derecho –> Properties. Luego hacer click en la categoría “Libraries”, en la pestaña “Compile” agregar la librería de Twitter4J. En la clase

public static void main(String[] args) throws TwitterException {
        ConfigurationBuilder cb = new ConfigurationBuilder();
        TwitterFactory tf = new TwitterFactory(cb.build());
        Twitter twitter = tf.getInstance();
        List<Status> statuses = twitter.getHomeTimeline();
        System.out.println("Mostrando el timeline...");
        for (Status status : statuses) {
            System.out.println("@" + status.getUser().getScreenName()+": "+ status.getText());
        }
    }

Ahora, debemos pasar los parámetros de la API de Twitter a nuestra aplicación. Para ello existen varias alternativas. Una de ellas, es mediante un archivo .properties:

Lo primero es dar click derecho sobre el proyecto New –> Other… –> Other –> Properties File. Al archivo llamarlo twitter4j. El archivo debe quedar en la raíz del proyecto, al mismo nivel de carpetas como “src” y “dist”.

El archivo debe ser completado con estas cuatro líneas, con la información (los hashs) provista por Twitter:

oauth.consumerKey=<La Api Key>
oauth.consumerSecret=<La Api Secret>
oauth.accessToken=<El token access>
oauth.accessTokenSecret=<El token access secret>

Desde luego, todo esto sin los signos de <>.

Ahora podemos ejecutar la aplicación y mostrará por consola nuestro timeline más reciente. O

Otra opción es pasarle los parámetros a través del código Java directamente, (eliminando primero el archivo .properties) así:

public static void main(String[] args) throws TwitterException {
        // TODO code application logic here
        ConfigurationBuilder cb = new ConfigurationBuilder();
         cb.setDebugEnabled(true)
         .setOAuthConsumerKey("<API key>")
         .setOAuthConsumerSecret("<API key secret>")
         .setOAuthAccessToken("<Access token>")
         .setOAuthAccessTokenSecret("<Access token secret>");
        TwitterFactory tf = new TwitterFactory(cb.build());
        Twitter twitter = tf.getInstance();
        List<Status> statuses = twitter.getHomeTimeline();
        System.out.println("Showing home timeline.");
        for (Status status : statuses) {
            System.out.println("@" + status.getUser().getScreenName()+ status.getText());
        }
    }

En la sección Code Examples de  http://twitter4j.org se pueden encontrar distintos ejemplos más avanzados de código Java para Twitter. Espero que este corto tutorial les sea de utilidad.

Notas:

  • Un error de “401:Authentication credentials” es que alguno de los 4 hash fueron mal ingresados.
  • Un error de “Authentication credentials are missing” indica que a la aplicación le faltan los 4 hashs. Si se le están pasando los hashs a la aplicación mediante archivo .properties, es probable que el archivo no esté en la raíz del proyecto (debe estar en el mismo nivel del archivo manifest.mf).

Jueves, septiembre 19, 2013

Configurar NetBeans con Android: Parte 2

Filed under: android, netbeans — Etiquetas: , , , — vramirez @ 9:43 AM

En la primera parte del tutorial (hace ya varias semanas…), quedó configurado lo necesario para poder desarrollar una aplicación Android en NetBeans. En esta, crearemos un “Hola Mundo”. Lo primero es crear un AVD (Android Virtual Device), que no es más que un emulador de un dispositivo Android (una máquina virtual). Sin esto, no podemos emular nuestras aplicaciones hechas: cada vez que quisiéramos probar una App tendríamos que pasarla a un dispositivo Android físico. Para crear la AVD, estando en NetBeans seleccionar Tools > AVD Manager > New. Acá el asistente pregunta por un nombre para la máquina virtual (puede ser cualquiera). Luego vienen dos cosas muy importantes, el “device”, el cual es el dispositivo físico en el cual se basa nuestra AVD, y por último el target, es decir la versión API de Android que utilizará esa máquina (Gingerbraid, Ice Cream Sandwich, etc…). En el “device” aparecen algunos reconocidos modelos Nexus y otros genéricos. Estos “devices” lo que traen preconfigurado son las propiedades físicas del aparato como: tamaño de la pantalla (en pulgadas), memoria RAM, memoria interna o disco, número de cámaras, botones por hardware (estilo blackberry clásica) o por software (pantalla 100% touch). La siguientte figura muestra un ejemplo.

alt

AVD Manager

Si ningún dispositivo predeterminado satisface nuestras necesidades, crear un nuevo “device”. Ahi mismo en el AVD Manager, es solo cambiar de TAB hacia Device Definitions y luego en Edit. Es decir en, Tools > AVD Manager > Device Definitions > New Device. Allí podremos personalizar el número de cámaras del dispositivo, los dpi, el tamaño de la pantalla, etc. A continuación, un dispositivo que yo creé. Un supuesto Galaxy Note 2:

 Android Device

Hasta acá, ya está configurada nuestra “máquina virtual”. Ahora si, a crear el proyecto. En NEw project, escoger tipo Android:

android996

Luego, escoger el nombre del proyecto, el paquete y por último el API “Target”:

android995

Lo ideal es escoger una API en el mismo nivel que la del “device”, para no tener problemas de ejecución. Se genera un nuevo proyecto con una clase MainActivity. Ésta, es la clase principal o de entrada de la aplicación. Será lo primero que se ejecute, al iniciar la App. En ella, agregamos el siguiente código:

public void onCreate(Bundle icicle) {
 super.onCreate(icicle);
 setContentView(R.layout.main);
 TextView tv = new TextView(this);
 System.out.println("Enter the android zone...");
 tv.setText("Hello, Android");
 setContentView(tv);
}

Al ejecutar este proyecto, el resultado será:

android997

Nota: Cabe aclarar que este Tutotrial fue hecho bajo Ubuntu (12.04). Durante la ejecución tuve algunos problemas, sobre todo con la AVD (el device). Lo mejor es desde el AVD Manager darle “Start” a la máquina, y esperar que el Android virtual arranque. Luego, si ejecutar la aplicación y esperar unos segundos. Si aún la app no se muestra, probar desde el $Android_Home/platform-tools/ (donde Android_Home es la carpeta del Android SDK que descomprimimos en la primera parte de tutorial), ejecutar:

sudo adb kill-server && sudo adb start-server

Luego intentar correr nuevamente la AVD, y después ejecutar la App de NetBeans.

Miércoles, agosto 14, 2013

Configurar NetBeans con Android: Parte 1

Filed under: android, netbeans — Etiquetas: , , , — vramirez @ 7:32 AM

Este sencillo instructivo, será muy útil para aquellos que quieren empezar a desarrollar apps en el mundo Android y no saben por dónde empezar.

Prerequisitos

Son pocos y muy fáciles de conseguir:

  • NetBeans IDE
  • Android Plugin para NetBeans
  • Android SDK

Si aún no tenemos Netbeans, lo primero es descargarlo desde https://netbeans.org/downloads/ e instalarlo. Lo más recomendable es elegir la opción “All”; dependiendo de la velocidad de su conexión, tardará entre 10 mins y 1 hora. Luego, es necesario instalarle el plugin de Android. Éste no viene por defecto instalado, primero se hace necesario agregar el repositorio donde se encuentra y luego sí, instalarlo. Para esto, se debe agregar un nuevo “Update Center” al IDE. Esto lo hacemos vía Tools > Plugins > Tab de Settings. Ahí, hacer click en “Add”. En Nombre, ponerle alguna descripción significativa (“NBAndroid”, por ejemplo), y en URL: http://nbandroid.org/release73/updates/updates.xml “OK”. En este momento deben aparecer cuatro repositorios, como la siguiente imagen:

Android_001

Listado de Update Centers en NetBeans

A continuación en “Available plugins” hacer click en “Check for newest”. Esto hará una consulta en todos los repositorios, incluyendo el que se acaba de agregar. Una vez terminado el proceso de update, en “Search” escribimos “Android”, debe aparecer el nuevo plugin. Seleccionarlo y darle install. Luego de un par de “Next” y “OK” estará instalado el plugin.

Hasta acá solo hemos instalado el plugin, es decir, la posibilidad de que NetBeans entienda cuando se le hable de Android. Ahora falta lo más importante, la librería Android, para ellos entramos a http://developer.android.com/sdk/index.html y una vez allí abrir la pestaña “Use an existing IDE” y hacer click en el botón “Download the SDK Tools”. Esto descargará el tar.gz del SDK Android más reciente. Al terminar la descarga, descomprimir el archivo (En Linux, con el comando tar -xzvf <archivo.tar.gz> hará todo el trabajo en un solo comando).

Una vez descomprimido, vamos dentro de NetBeans a Tools > Options > Miscellaneous > Android. En SDK Location, la carpeta descomprimida, así:

Android_002

Configuración de la librería Android en NetBeans

Hasta acá tenemos configurado el Android SDK, sin embargo, aún falta un último paso y es validar que todos los componentes de Android estén instalados. Para ello vamos a Tools > Android SDK Manager. Esta ventana permite aregar o actualizar las últimas Tools del SDK y descargar un “Target”, es decir, la versión de Android con la cual vamos a trabajar (Ice Cream, Gingerbread, etc…) y puede ser una o más. Seleccionando una o más API y la sección “Tools” le damos “Install packages”. Ésto descargará el API (Target) que deseemos y las Tools para trabajar con dicho Target. Al final si seleccionamos solo el check de “installed” debe verse similar a este:

Configuracion SDK Android NetBeans

Configuración APIs del SDK Android para NetBeans

Hasta acá llega la primera parte, donde ya está todo configurado y listo para desarrollar en Android usando NetBeans. En la próxima entrega un típico Hola Mundo. Aunque, si son tan impacientes como yo, seguro lo harán antes. Hasta entonces.

Domingo, septiembre 7, 2008

Usando MySQL Workbench para diseñar y crear una base de datos

Filed under: mysql, tutorial — Etiquetas: , , , — vramirez @ 8:15 PM
La compra de MySQL AB por parte de Sun Microsystems a comienzos de este año, es sin lugar a dudas un reconocimiento al buen trabajo hecho por la comunidad de MySQL, para llevar a esta base de datos a ser una de las mejores bases de datos open source que se encuentre en el mercado, y que hoy por hoy es la base de datos predilecta por los desarrolladores, e incluso grandes empresas como Suzuki, Sagem, o la misma Adobe o sitios como Yahoo! Finance, para bases de datos transaccionales o bodegas de datos (Data Warehousing).MySQL provee entre sus herramientas, una denominada MySQL Workbench la cual nos permite desde una ambiente gráfico, diseñar un modelo E-R de una base de datos y luego crear la base de datos, como tal en una base de datos MySQL. Para este tutorial es necesario tener instalado:

NOTA: En esta demo, solo se mostrará el funcionamiento de MySQL Workbench, mas no la instalación de éste ni la de MySQL Server. El servidor mysql puede estar instalado en cualquier equipo y/o sistema operativo soportado (Windows, Linux, Aix, etc). MySQL Workbench solo se encuentra disponible para Windows.

En el ejemplo crearemos una base de datos muy sencilla, la cual no representa un ejemplo real. Simplemente es para probar las características.
Primero creemos el esquema “test”, haciendo click en el símbolo “+”. Abajo se abre una pestaña en que nos pregunta el nombre del esquema (test) y el idioma del esquema, el cual se recomienda dejar por default como se muestra en la figura. Si la aplicación pregunta si desean renombrar todos los objetos, seleccionen “Si”.

Ya creado el esquema, procedemos a crear las tablas. Existen dos formas, aunque muy similares de crearlas. La primera es desde la pantalla en la que estamos, la otra es mediante la ventana visual, en la cual podremos además, realizar las relaciones entre las tablas. Pero primero lo primero; las tablas.
Verifica que estes en el esquema “test” y luego haz doble click en el icono de “Add Table”.

Al hacer click en esta opción, se despliega al lado un icono representando la nueva tabla, mientras que debajo se abre una nueva pestaña, en la cual podemos editar todo al respecto de las tablas haciendo (Columnas, llaves, triggers, etc) click en cada una de las pestañas ubicadas en la parte inferior de esta nueva pestaña.
Nota: los triggers solo estan disponibles a partir de MySQL 5. Cualquier tabla con triggers generada en Workbench arrojará un error cuando se corra en una versión inferior a MySQL 5.0
Agregaremos un par de columnas a la tabla:

Al hacer click en la pestaña “Columns”, podemos editar todas las columnas dela tabla indicada. Podemos alterar el nombre, el tipo de dato, si es nulo o no (NN) y si es Auto incremental (AI), obviamente este último es sólo para datos de tipo numérico, De igual forma podemos especificar un valor por default para la columna. En la parte derecha, inmediatamente podemos indicar si la columna seleccionada hace parte de la llave primaria (PRIMARY KEY), si es UNSIGNED o ZEROFILL para las variables numéricas y si la variable es de tipo caracter, podemos especificar si es BINARY.

Ahora pasemos a crear una tabla por medio de un diagrama E-R. En la parte superior observamos la opción “Add Diagram”. Hacemos doble click sobre ella.

Luego se abre una nueva pestaña en la cual encontramos un grid. A la izquierda, ecnontramos una barra de herramientas, desde la cual podremos crear tablas y vistas, además de relaciones (1:1,1:n,n:m…) y a la derecha un árbol con los objetos de nuestro esquema (tablas, vistas, etc). De esa ventana, seleccionamos la tabla que creamos y la arrastramos hasta el grid. Luego hacemos click derecho y seleccionamos “Edit table”, abajo nos muestra la pestaña para editar la tabla y crear columnas, llaves, etc.

Buscamos a la izquierda el ícono que nos permite crear una nueva tabla. Hacemos un click en el ícono y luego un click en el grid.

Editamos las segunda tabla y ahora haremos una relación muchos a uno.Seleccionamos el icono, y luego cada una de las tablas (primero la de muchos y luego la de uno). En mi caso, la tabla de “muchos” es table1. Quedaría algo asi:

Como ven el Workbench se apega a la teoría relacional, donde en este caso la llave de a relación “uno” pasa a la tabla de “muchos”. Igualmente si creamos una relacion M.N (muchos a muchos) generará una relación entre las dos tablas. A continuación viene la mejor parte de esta herramienta: la generación del script SQL.

Como ven, podemos exportar el diseño, incluso como una imagen en pdf, o en png, entre otros. La primera pantalla, nos muestra las opciones con las que queremos que se genere el script DDL. Luego seleccionamos la ubicacion destino del archivo que se creará.

Luego nos muestra un resumen de lo que creará; usuarios, tablas, vistas, rutinas y triggers. Incluso si seleccionamos el botón “Detailed Selection” de cada sección, podemos especificar aún más, por ejemplo, qué tablas deseo realmente exportar.

Luego finalizar, y en la ruta que le hallamos indicado estará un archivo .sql, con nuestro script. Como se podrán dar cuenta Workbench, resuelve algunas limitantes en la comunidad open source de un buen software front-end para MySQL, y sobre todo de una herramienta que provea Forward Engineering, de una manera tan sencilla y bien ilustrada. Digamos que la única limitante de Worlbench es su ausencia en otras plataformas, o sea, en Linux :p.

Blog de WordPress.com.