sábado, 11 de diciembre de 2010

Primeros pasos en C

Porque todos hemos sido novatos en esto de la programación, este post va dirigido a todos los que están empezando a programar y están un poco perdidos.
El lenguaje C, es un lenguaje de alto nivel creado en 1972 para implementar sistemas operativos, aunque no creo que ninguno de vosotros tenga intención de usarlo para eso ^^
Antes de ponernos a programar como locos, hay que tener en cuenta una serie de cosas:


El compilador
Es un programa que necesitaremos para transformar nuestro código fuente (el programa que haremos en C) a código maquina (el lenguaje que entiende nuestro ordenador).
Existen muchos compiladores, la elección depende de vosotros (bueno y de vuestro sistema operativo, pero eso como cualquier programa).
Yo usaré el gcc de mi Mac OS X, es decir, compilare mediante comandos con el terminal.


La estructura de un programa en C
Una vez que hemos elegido la herramienta de desarrollo que usaremos, ahora es cuando podemos empezar a programar, pero no al tun tun. Primero tendremos que saber que es lo que vamos a hacer y para ello lo primero es conocer la estructura que tiene un programa en C.
  • Directivas del preprocesador
Son una colección de instrucciones especiales que se ejecutan al principio de la compilación.
Las mas habituales son:
#include: incluir ficheros de cabecera
Existentes en el compilador: #include < nombreFich.h>
#include < stdio.h>
Existentes en el directorio actual (pueden ser ficheros propios): #include "nombreFich.h"
#include "misFunciones.h"

#define: definir constantes
#define identificador valor
#define pi 3.1416
NOTA: Un identificador valido es una secuencia de letras, números y subrayado que siempre empieza por letra. Distingue entre mayúsculas y minúsculas. Se aplica esta norma tanto a constantes, como a variables, nombres de funciones, etc.

  • Declaraciones globales
Declaraciones accesibles desde cualquier punto del programa. Pueden ser variables o prototipos de funciones.

Variables: Representan información que varía durante la ejecución, de ahí su nombre
tipoDato idVariable nombre=valor;
int numero=10;
No es obligatorio inicializarlas en la declaración:
int numero;
Tipos de datos simples:
- Enteros:
int: -32768 - 32767
unsigned int: 0 - 65535
short int: -128 - 127
long: -2147483648 - 2147483647
unsigned long: 0 - 4294967295
- Reales
float: 3.4 x 10^-38 - 3.4 x 10^38 (precision 7 digitos)
double: 1.7x10^-308 - 1.7x10^308 (precision 15 digitos)
long double: 3.4x10^-4932 - 3.4x10^4932 (precision 19 digitos)
- Caracteres
char: 0 - 255
- Lógicos
Verdadero o falso: se representa con un dato de tipo int (1:verdadero, 0:falso)

Prototipos de funciones: Son las cabeceras de las funciones (ver Declaración de otras funciones) seguidas de ;

  • Función main
Punto de entrada al programa. Solo puede haber una.
void main()
{
//bloque de sentencias
}
void: significa que no devuelve nada.

Otra forma de escribir la función main es esta:
int main()
{
//bloque de sentencias
return 0;
}
en este caso main devuelve un int por lo que al final del método habrá que hacer un return (ver Declaración de otras funciones)

  • Declaración de otras funciones
Las funciones son conjuntos de sentencias que realizan una función. Mejoran la legibilidad, depuración y mantenimiento de los programas.
Las funciones tienen dos partes: cabecera (corresponde con el prototipo) y cuerpo.
tipoDevuelto idFuncion (parametrosFormales)//cabecera de la función
{
//aqui empieza el cuerpo
//sentencias
return expresion;
}
Una función termina cuando se encuentra un return, si no hay return termina cuando acaba el cuerpo.

Tipo devuelto: puede ser cualquiera de los tipos fundamentales explicados anteriormente. Si no devuelve nada se usa void. . Para devolver un valor a la función se usa return.
int suma ()
{
...
return expresion; //el tipo de la expresión tiene que coincidir con el tipo devuelto
}

void suma()
{
...
}

Identificador: debe cumplir las restricciones de los identificadores expuestas anteriormente.

Parámetros formales: Son opcionales, puede que la función no reciba nada en la llamada. En el caso de que se pongan, hay que especificar el tipo de cada uno de ellos.
int suma (int a, int b)
{
...
}

Las funciones las explicaré con más detalle en post futuros.

martes, 7 de diciembre de 2010

Cómo compilar y ejecutar un servlet en Tomcat

Si os fue bien la instalación y configuración de Tomcat en Mac OS X ha llegado el momento de programar un servlet.
Estoy segura que hay montones de herramientas para hacerlo, pero después de haberme pegado con unas cuantas y ver que los resultados no eran muy buenos, os voy a contar cual es la solución más fácil que he encontrado y que por supuesto funciona.
Antes de empezar, para los que no lo sepan, un servlet es una clase en java que necesita un contenedor de servlets para funcionar. Puede que así dicho no quede muy claro. Si pensáis en el típico proyecto en java, solo necesitáis compilarlo y ya estaría listo para su ejecución. Un servlet, en cambio, después de su compilación necesita un contenedor de servlets (en nuestro caso Tomcat) para poder ser ejecutado, y eso es lo que yo os voy a explicar hoy, como compilar esa clase java y ejecutarla después desde Tomcat.

Lo primero de todo (después de instalar Tomcat y configurarlo) es crear un directorio donde colocar los servlets. Tomcat tiene, dentro de su directorio raiz, un directorio llamado webapps (/usr/local/apache-tomcat-6.0.29/webapps). Ahí es donde crearemos nuestros servlets, pero no podemos ponerlos de cualquier forma, es importante que cumplan una estructura determinada, sino Tomcat no los reconocerá. La estructura que tendrá nuestro directorio de servlets será la siguiente:



Proyecto:
El proyecto será el directorio que contedrá, como su nombre indica, todo el proyecto. Es un directorio que crearemos dentro de webapps y por supuesto lo podéis llamar como queráis. Si lo hacéis mediante la consola bastará con escribir esta linea:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales

Como podéis ver yo lo he llamado tutoriales.
Aquí dentro podéis poner paginas estáticas (html) o paginas dinámicas JSP, pero nada más, los servlets irán en otro sitio.



WEB-INF:
Este directorio hay que crearlo dentro de nuestro proyecto, contendrá otro subdirectorio classes con todos los servlets y el fichero web.xml que luego explicaré con detalle lo que es.
Para crear WEB-INF bastará con escribir en la consola:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales/WEB-INF

e inmediatamente podemos crear el directorio classes que contendrá los servlets:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales/WEB-INF/classes

Una vez hecho, prácticamente tenemos la estructura de nuestro proyecto, ahora empezaremos a programar. Yo he optado por usar el editor vi como os explique en post anteriores, pero podéis usar el que queráis.
Crearemos nuestro primer servlet que será el típico hola mundo y tendrá extensión .java:
Nos movemos al directorio del proyecto por comodidad:

cd /usr/local/apache-tomcat-6.0.29/webapps/tutoriales

y creamos el servlet:

vi HolaMundo.java

Tened cuidado con el nombre que le dais ya que tiene que coincidir con el nombre de la clase java que vamos a implementar dentro del servlet (java distingue entre mayúsculas y minúsculas)
El contenido de nuestro servlet será el siguiente:


Guardamos y cerramos pulsando esc :wq
Una vez guardado el servlet hay que compilarlo utilizando el api para servlets incluido en Tomcat (que se encuentra en la ruta /usr/local/apache-tomcat-6.0.29/lib/servlet-api.jar), para ello escribimos la siguiente linea:

javac -classpath /usr/local/apache-tomcat-6.0.29/lib/servlet-api.jar HolaMundo.java

Tras compilar, si todo ha ido bien, se generará un archivo HolaMundo.class que contendrá el servlet ya compilado. Este archivo hay que cambiarlo al directorio classes que creamos dentro de WEB-INF. Si lo hacéis por consola, basta con escribir esta linea:

mv HolaMundo.class classes



web.xml:
Si habéis llegado hasta aquí ya casi tenemos el servlet listo para ejecutarlo en Tomcat, lo único que nos queda es indicarle al servidor donde se encuentran los servlets, para ellos crearemos dentro de WEB-INF un archivo xml con la siguiente estructura:


display-name: Nombre identificativo para todos los servlets del documento
description: Una descripción de los servlets
servlet: Descripción de un servlet. Contiene dos elementos:
- servlet-name: Nombre del servlet
- servlet-class: Nombre de la clase del servlet, normalmente coincide con el nombre
servlet-mapping: Indica al servidor cómo se ejecuta un servlet en concreto. También tiene dos elementos:
- servlet-name: Nombre del servlet que queremos referenciar
- url-pattern: Ruta del servlet. Puede contener directorios virtuales. Será la ruta que usemos para lanzar el servlet con el Tomcat

Podéis crear este fichero con el vi como ya hemos visto.

Y una vez terminados todos estos pasos ya podemos arrancar Tomcat y probar el servlet. Arrancais Tomcat, abrís el explorador y escribís localjost:8080. Se os abrirá la página principal de Tomcat. Si pinchais en Tomcat Manager, en la parte izquierda (introducir user y pass), se os abrirá el gestor de aplicaciones web de Tomcat donde tendrá que aparecer el servlet que hemos creado:



Si os fijáis a la parte derecha del servlet aparece un menú como este:



Si el servlet no aparece como arrancado lo tenéis que arrancar, sino no funcionará.

Y llegó la hora de la verdad, para probar nuestro servlet escribiremos en el explorador la ruta que le indicamos en el documentos web.xml de la siguiente forma:
localhost:8080/tutorial/servlet/HolaMundo (o la ruta que hayáis puesto). Si todo ha ido bien deberiais ver en vuestro explorador algo como esto:


domingo, 5 de diciembre de 2010

Cómo cambiar la contraseña de Tomcat en Mac OS X

Si os fue bien la instalación de Tomcat que os expliqué en el post anterior, ya podreis usarlo y administrarlo escribiendo en vuestro explorador http://localhost:8080 y pinchando en alguna de las opciones que aparece en la parte izquierda de la pagina de inicio de Tomcat. Oh no!! me pide un usuario y una contraseña, pero no se cuales son :S



Seguro que a más de un@ os ha pasado eso. Que no cunda el pánico. Existe un fichero .xml en el directorio de Tomcat llamado tomcat-users.xml con esta estructura:



El fichero está en /usr/local/apache-tomcat-6.0.29/conf/tomcat-users.xml
Podeis abrirlo con el vi como os explique en el post anterior escribiendo en la consola:

vi /usr/local/apache-tomcat-6.0.29/conf/tomcat-users.xml

Simplemente tenéis que borrar los símbolos de comentario que os he marcado con unos asteriscos y definir un usuario nuevo con privilegios de administrador añadiendo estas lineas:



Los role y user que vienen definidos no hay que borrarlos, pero el que usaremos para entrar será el nuevo que hemos definido (el username y el password pueden ser el que queráis)

Finalmente lo guardais (si habéis usado el vi pulsais esc :wq) y volveis a arrancar el tomcat en vuestro explorador e intentais acceder con el user y password que habeis definido. Si todo ha ido bien os aparecerá el gestor de aplicaciones web de Tomcat.

Cómo instalar Apache Tomcat en Mac OS X

Como inauguración de este blog, voy a enseñaros cómo instalar Tomcat en Mac OS X, ya que ayer mismo lo hice.
Tomcat, para quien no lo sepa, es un servidor web con soporte para paginas web dinámicas (servlets y JSP) y lejos de lo que pueda parecer, es muy fácil de instalar.

Antes de empezar teneis que descargaros Tomcat de la pagina oficial del proyecto. La descarga es gratuita por tratarse de software libre.
Como veréis (en la parte izquierda de la pagina) hay varias versiones. Yo voy a explicaros como se instala Tomcat 6.0, ya que la versión 7.0 es una beta.



Para Mac OS X teneis que bajaros el archivo .tar.gz


Una vez descargado el Tomcat, teneis que descomprimirlo, yo os recomiendo que lo hagáis a mano (donde queráis, simplemente haciendo doble click sobre el archivo .tar), también podríais hacerlo con la consola, pero yo os cuento la forma mas fácil de hacerlo y que menos problemas os puede dar.

Una vez hecho esto, abrís la consola para instalarlo (Aplicaciones/Utilidades/Terminal) y entrais en el directorio donde hayáis descomprimido el archivo. En mi caso, está en mi directorio Home, que es el que abre por defecto la consola.
El primer paso es mover la carpeta de tomcat al directorio /usr/local, para ello escribís las siguientes linea de comandos en la consola:

sudo sh: Con esta linea conseguís los privilegios de seguridad del root y ejecutamos comandos en un subsell. Nos pedirá la contraseña de administracion de nuestro equipo.

mv apache-tomcat-6.0.29 /usr/local: Con esta linea moveis la carpeta que contiene el Tomcat descomprimido al directorio /usr/local

Una vez hecho esto hay que dar privilegios, para ello escribís esta linea de comandos:
chmod -R 775 /usr/local/apache-tomcat-6.0.29

Y ya casi está, ahora solo queda configurar las variables de entorno, para ello os recomiendo crear un par de scripts donde las definis y además podéis arrancar o detener el Tomcat. Para crear los scripts, podéis hacerlos dentro de vuestro directorio Home con el editor vi (tenéis que cambiar de usuario, pasar de root a vuestro usuario, para eso simplemente escribís exit y le dais a intro).
Las variables a definir son estas dos:
CATALINA_HOME: Contendrá la ruta donde instalasteis el Tomcat
JAVA_HOME: Contendrá la ruta donde está instalado el JDK. Que nadie se asuste, en Mac OS X, el JDK ya viene instalado con el sistema. La ruta es /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home.
Por ultimo hay que indicar que quereis que Tomcat arranque o se detenga. Por tanto el script para arrancar Tomcat seria algo asi:

vi start_tomcat: esta linea abre el editor vi y crea un fichero llamado start_tomcat (podéis llamarlo como queráis)
y escribis esto:

#!/bin/sh
export CATALINA_HOME=/usr/local/apache-tomcat-6.0.29
export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
$CATALINA_HOME/bin/startup.sh

pulsamos esc :wq y ya tenemos el scipt de arranque

Para el sript que detiene Tomcat hay que hacer lo mismo (podéis llamarlo stop_tomcat o como queráis) pero el contenido del script será este:

#!/bin/sh
export CATALINA_HOME=/usr/local/apache-tomcat-6.0.29
export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
$CATALINA_HOME/bin/shutdown.sh

Ya solo nos queda el ultimo paso, que es darle permisos de ejecución:

chmod ug+x start_tomcat stop_tomcat (o como los hayáis llamado)

Ya podemos arrancar Tomcat escribiendo en la consola ./start_tomcat (o como lo hayáis llamado). Para comprobar que todo ha ido bien tenéis que abrir vuestro explorador de internet y escribir:
http://localhost:8080 y os tiene que aparecer una ventana como esta:



Si no os sale, revisar todos los pasos.

Para detenerlo igual que para arrancar pero con el otro script:
./stop_tomcat