Para asegurar que todo nuestro código está en UTF-8, aquí dejo cómo configurar:
eclipse
workspace concreto
Eclipse
Hace tiempo encontré una opción para el fichero eclipse.ini que me ha ahorrado muchos problemas de codificación y que fija por defecto la codificación en UTF-8.
En el fichero eclipse.ini añadimos esta línea:
-Dfile.encoding=utf8
Lo que hace es que por defecto nuestro eclipse fije a utf-8 la codificación de los workspaces que creemos, y la mayoría de los ficheros también se traten en UTF-8.
Workspace
La configuración anterior hay que combinarla configurando alguna cosa más en el workspace.
1. Entramos en el menú Window > Preferences
2. En el espacio de búsqueda ponemos “encoding”. Entre los resultados, nos interesa seleccionar General > Content Types.
3. Veremos entonces a la derecha varias opciones, y seleccionamos Text. En ese momento, seleccionado Text, en la parte de abajo tenemos una caja de texto con título “Default encoding”, lo rellenamos con UTF-8 y finalmente pulsamos en el botón Update.
4. Después desplegamos esa opción Text, y vamos una a una por las opciones internas, algunas de ellas tienen fijado otro valor diferente a UTF-8, y lo que haremos es cambiarlo.
Con esto haremos que todos los ficheros que manejemos con eclipse, se traten como UTF-8.
OJO: Si el proyecto es nuevo, todo irá como la seda, pero si estáis importando un fichero con ficheros que estaban en otra codificación, no es solución suficiente, ya que eclipse no cambia la codificación física de los ficheros existentes con estas configuraciones. Para esta tarea de transformar ficheros de otra codificación hacia UTF-8… no he encontrado nada por ahí automático, y siempre he utilizado herramientas tan básicas como Notepad++, en el que desde su menú Codificación, puedes seleccionar Convertir a UTF-8.
Trabajando con Tomcat 6 y jsp, me he encontrado con un problema cuando intento utilizar plantillas (templates) para utilizar desde la parte de javascript con jQuery o Prototype.
La sintaxis para utilizar estos templates tiene esta forma #{…}, pero al compilar las JSPs que tienen estos templates en su contenido, Tomcat arroja esta excepción:
(...)
org.apache.jasper.JasperException: /WEB-INF/jsp/home.jsp(45,5) #{..} no está permitido en texto de plantilla
at org.apache.jasper.compiler.DefaultErrorHandler.jspError(DefaultErrorHandler.java:40)
at org.apache.jasper.compiler.ErrorDispatcher.dispatch(ErrorDispatcher.java:407)
at org.apache.jasper.compiler.ErrorDispatcher.jspError(ErrorDispatcher.java:102)
at org.apache.jasper.compiler.Validator$ValidateVisitor.visit(Validator.java:706)
at org.apache.jasper.compiler.Node$ELExpression.accept(Node.java:958)
(...)
Buscando por el problema en Internet, la mejor solución que he encontrado es añadir en la JSP la siguiente sentencia:
<%@page deferredSyntaxAllowedAsLiteral="true"%>
En mi caso lo he incluido justo después de declarar las taglib que utilizo, quedando así:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"
%><%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"
%><%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"
%><%@ taglib prefix="spring" uri="http://www.springframework.org/tags"
%><%@ taglib prefix="json" uri="http://www.atg.com/taglibs/json"
%><%
/*Para evitar error #{..} is not allowed in template text */
%><%@page deferredSyntaxAllowedAsLiteral="true"%>
Existen herramientas que nos facilitan ‘medir’ la calidad del código de nuestras aplicaciones. El uso de estas herramientas resulta muy interesante en proyectos grandes donde sería una locura revisar una a una las clases que componen el proyecto, pero todavía pueden sernos más útiles si nos acostumbramos a utilizarlas desde el inicio de los proyectos, previniendo que nuestro código vaya tomando un volumen de incorrecciones que de otra forma costará mucho tiempo corregir.
Por mencionar alguno de los conceptos de corrección que se pueden medir:
Código duplicado
Variables no utilizadas
Casting imposible de variables
instanceof siempre devolverá false
Ojo, estas herramientas son altamente configurables, miden cantidad de conceptos de corrección parametrizables, y si no se ajustan correctamente pueden darnos resultados que no se ajustan a la realidad. Es por esto que uno no lo instala tal cual y se fía de todo lo que le dice la herramienta, ya que los ajustes variarán de un proyecto a otro.
Yo utlizo Eclipse, y por eso recomiendo los siguientes plugins que nos ayudan en estas tareas y que son complementarios:
PMD:
Web del proyecto: http://pmd.sourceforge.net/
Ruta para instalar la herramienta desde el menú Ayuda>Instalar software nuevo: http://pmd.sourceforge.net/eclipse
FindBugs:
Web del proyecto: http://findbugs.sourceforge.net/
Ruta para instalar la herramienta desde el menú Ayuda>Instalar software nuevo: http://findbugs.cs.umd.edu/eclipse/
Existen herramientas que actuan como contenedores de herramientas de este tipo y gestionan en un único entorno toda la información que proporcionan. Quizá la que más se está utilizando ahora es Sonar, y dejo aquí la ruta a la web del proyecto para que lo investigues si te parece interesante http://sonar.codehaus.org/.
En ocasiones es necesario realizar comportamientos javascript en pantalla de forma reiterada cada cierto intervalo de tiempo.
Por ejemplo realizar el refresco de una parte de la página, o esperar a que aparezca algo en pantalla para realizar cierta acción.
En algún caso lo he necesitado, y lo resolví de este modo, teniendo disponible la librería Prototype:
Prueba = {
atributo1: '',
atributo2: 1,
hemosTerminado: false,
inicializarComportamientoPeriodico: function(){
new PeriodicalExecuter(
function actualizacionDeLoQueSea(timer){
//Aquí realizamos las acciones que queramos
this.atributo1 = this.atributo1 + 'vuelta ' + this.atributo2 + ',';
this.atributo2 = this.atributo2 + 1;
//Comprobamos la condición de finalización
this.hemosTerminado = ........
if(this.hemosTerminado)
timer.stop();
}.bind(this),
2
);
}
}
Event.observe(window, "load", Prueba.inicializarComportamientoPeriodico.bindAsEventListener(Prueba));
Como vemos tenemos un objeto que hemos llamado Prueba.
Cuando la página se haya cargado llamaremos al método que inicializa nuestra función periódica.
El método que inicializa el comportamiento periódico crea un objeto PeriodicalExecuter que recibe como parámetros:
la función que ejecutará (en este caso le pasamos una función que definimos ahí mismo)
el intervalo de tiempo en segundos
Observaciones:
- Hay que tener en cuenta que será necesario en esta implementación el uso de bind al pasar la función a PeriodicalExecuter.
- Se ha incluido una condición de parada de las repeticiones que hace que deje de ejecutarse nuestra función.
Lo que haremos es incluir las librerías básicas de Spring y configurarlo para tener una prueba de concepto del patrón MVC.
El objetivo es tener una página de entrada desde la que mediante enlaces accedamos a dos operativas diferentes. Cada operativa funciona mediante un controlador que recibe la petición del navegador, realiza las operaciones necesarias y responde con una pantalla de resultado.
Cuando queramos lanzar un site que queramos posicionar bien en Google de forma natural, tendremos que tener algunas consideraciones en cuenta en el periodo de implementación y otras en el momento del lanzamiento.
Voy a hablar en este caso del periodo de implementación. Veamos qué es lo básico que tenemos que tener en cuenta:
Meta tags
Las meta tags añaden información asociada a una página. El propósito de las meta tags es muy variado, desde proporcionar información al navegador del cliente que nos visite (como por ejemplo el idioma), hasta indicar a los buscadores cómo queremos que nos muestren en sus listados.
Indica las palabras clave relacionadas con la página.
Entre 30 y 40 palabras son las que los buscadores tendrán en cuenta. No deben repetirse, pues penaliza.
Por ejemplo poner:
“libros cocina, libros comida, etc.”
puede ser aceptable, pero no lo sería:
“libros, libros, etc.”
Se dice que lo mejor es 4 a 6 grupos de palabras separados por comas, pensando en que las palabras se heredan, es decir, que las que se pongan en la página principal no hay que ponerlas en páginas interiores, así que hay que elegirlas de muy genérico a muy concreto.
Cuando empezamos con Eclipse, tenemos delante un completísimo y muy complejo entorno de programación que de primeras puede echarnos para atrás si no estamos convencidos de que realmente nos hará la vida más fácil.
Escribo este tutorial para tenerlo como referencia cuando tenga que crear un proyecto web. El objetivo es tener un proyecto web listo para empezar a programar tanto Java como JSP y poder verlo en un servidor que también montaremos desde el mismo Eclipse.
Los pasos que seguiremos son los siguientes:
Configurar Eclipse
Añadir el servidor
Crear el proyecto
Añadir el proyecto al servidor
Prueba de que todo está preparado
1 Configurar Eclipse
Vamos a utilizar Java 1.5, así que haremos que sea la JVM por defecto.
Vamos al menú Window -> Preferences, y en el diálogo vamos a Java -> Installed JREs
Si no aparece la jre o jdk 1.5, entonces la añadimos con el botón add… Una vez añadida la dejamos marcada como se ve en la imagen anterior para que sea la versión de Java por defecto de ahora en adelante.
2 Añadir el servidor
Si no tenemos la pestaña Servers, la añadimos desde el menú Window -> Show View -> Other, y en el diálogo buscamos Servers
Con esto debería aparecer la pestaña Servers en la parte inferior de la pantalla.
Hacemos clic derecho en el espacio de la pestaña y elegimos New -> Server, y en el diálogo seleccionamos Tomcat v6.0 y damos a Next. En este paso veremos que podemos elegir la carpeta donde está instalado o bien, y esta opción es la más recomendable, así estará todo limpio, descargarlo de Internet.
Si lo descargamos nos pide el directorio de instalación y en un momento lo tendremos listo.
3 Crear el proyecto
Vamos a crear un proyecto web, así que seleccionamos el menú File -> New -> Project. Y en el diálogo que aparezca buscamos Web -> Dynamic Web Project
4 Añadir el proyecto al servidor
Por último hay que incluir el proyecto que acabamos de crear en el servidor para que este lo cargue al arrancarse.
Vamos a la pestaña de Servers, y sobre nuestro servidor hacemos clic derecho eligiendo Add and remove projects…, y después en el diálogo pasamos de la parte izquierda a la parte derecha nuestro proyecto.
5 Prueba de que todo está preparado
Para ver que nuestro servidor y nuestro proyecto están listos, crearemos una jsp, arrancaremos el servidor y veremos en el navegador que funciona.
1º Creamos una pagina de inicio
Para crear una jsp vamos a la carpeta del proyecto y hacemos clic derecho, eligiendo New -> Other y después en el diálogo buscando Web -> JSP
En el diálogo siguiente elegimos como nombre index.jsp
2º Editamos la jsp
Entre las etiquetas body lo siguiente:
<h1>Servidor arrancado con aplicación de prueba</h1>
3º Arrancamos el servidor
Desde la pestaña Servers arrancamos el servidor pulsando el botón verde Run ()
El servidor quedará arrancado en el puerto 8080 por defecto.
4º Vemos en el navegador el resultado
Abrimos el navegador y escribimos en la barra de direcciones:
http://localhost:8080/mi_proyecto/ (*)
Veremos la siguiente pantalla:
(*) el nombre del proyecto exacto para poner en la barra de direcciones, se encuentra configurado en eclipse, en la parte de ficheros del servidor que aparece en la izquierda.
Debemos mirar el fichero server.xml al final del mismo. Esta línea define el nombre de la ruta para ver el resultado del proyecto en el explorador:
Pues bien, hasta aquí ya tenemos preparado nuestro entorno para empezar nuestro proyecto web.
Tal y como está la configuración, podemos ir creando páginas JSP en la carpeta Web Content para verlas en el explorador, crear clases Java, y añadir librerías etc para dar más funcionalidad al proyecto. En futuros artículos veremos como ir dando forma a proyectos concretos partiendo siempre de esta base.
Nota: Para ejecutar el flujo se llama a la siguiente URL http://localhost:8080/<Despligue del proyecto>/<Controlador de web-flow>?_flowId=uploadFichero . (Dependiendo de la configuración de nuestro entorno)
Creación del JSP donde vamos a meter la pantalla.
Los cambios o diferencias con un JSP normal son:
-La definición del form hay que poner un enctype para indicar que es multipart:
enctype=“multipart/form-data”>
Nota: Con esto le indicamos que vamos a mandar un multipart.
-Definimos un input para que el usario le pase el fichero:
<inputtype=“file”name=“file”>
A continuación vemos un ejemplo de JSP de descarga, con los cambios que hemos indicado.
En file, podemos sacar el fichero, con los byte, pero tiene un método para transferir el fichero a una ubicaciónfísica (Fichero es una variable de tipo file que indica la ruta donde vamos).
En esta página podemos encontrar APIs de los lenguajes, frameworks y entornos más utilizados (html, css, java, javascript, mysql, hibernate, ant, etc) y otros que no tanto (openGL, Python …).
Además toma la información de fuera, por tanto está asegurada la validez de lo que podemos encontrar.
Es muy fácil de utilizar, y para los que nos dedicamos al desarrollo web es perfecta por la cantidad de tecnologías que reúne.
Para eliminar un elemento de un array hay que tener en cuenta que es diferente según el tipo de array, y según queramos eliminar un elemento por su clave o por su valor.
Otra opción es utilizar array_splice directamente con cada elemento a eliminar, que provoca la eliminación inmediata de la posición del array y su normalización. Para eliminar los mismos elementos en este caso, hacemos:
$miArrayNoAsociativo[0]="A";
$miArrayNoAsociativo[1]="B";
$miArrayNoAsociativo[2]="C";
//Indicamos el array de dónde eliminar, la posición,
// y el 1 es para que sólo elimine esa posición
array_splice($miArrayNoAsociativo, 0, 1);
//resultado (0=>"B",1=>"C");
array_splice($miArrayNoAsociativo, 1, 1);
//resultado (0=>"B");