Dos Ideas. - Contribuciones del usuario [es]

Página Principal

2017-05-03T23:31:58Z

Admin:

__NOTOC__
Bienvenido a la Wiki de Dos Ideas, un lugar para compartir experiencias concretas del mundo profesional de Sistemas. Aquí podremos volcar conocimientos y ejemplos de diversas tecnologías, aplicadas a cuestiones prácticas.

La wiki de Dos Ideas contiene información sobre el proceso completo del desarrollo de sistemas.

{| width="85%" align="center" border="0"
|-
| <imagemap>
Image:Desarrollo-de-software-azul.png|center|Desarrollo de software
default [[Desarrollo De Software]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Desarrollo De Software]]'''</p>

|| <imagemap>
Image:Metodologias-de-desarrollo-azul.png|center|Metodologias de desarrollo
default [[Metodologias De Desarrollo]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Metodologias De Desarrollo]]'''</p>

|| <imagemap>
Image:Personas-azul.png|center|Conformación de equipos
default [[Conformación de equipos]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Conformación de equipos]]'''</p>
|}

<tagcloud>
increase_factor=300
</tagcloud>

Página Principal

2017-05-03T23:31:32Z

Admin:

__NOTOC__
Bienvenido a la Wiki de Dos Ideas, un lugar para compartir experiencias concretas del mundo profesional de Sistemas. Aquí podremos volcar conocimientos y ejemplos de diversas tecnologías, aplicadas a cuestiones prácticas.

La wiki de Dos Ideas contiene información sobre el proceso completo del desarrollo de sistemas.

{| width="85%" align="center" border="0"
|-
| [[Archivo:Desarrollo-de-software-azul.png]]

<imagemap>
Image:Desarrollo-de-software-azul.png|center|Desarrollo de software
default [[Desarrollo De Software]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Desarrollo De Software]]'''</p>

|| <imagemap>
Image:Metodologias-de-desarrollo-azul.png|center|Metodologias de desarrollo
default [[Metodologias De Desarrollo]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Metodologias De Desarrollo]]'''</p>

|| <imagemap>
Image:Personas-azul.png|center|Conformación de equipos
default [[Conformación de equipos]]
desc none
</imagemap>
<p align="center" style="font-size:large">'''[[Conformación de equipos]]'''</p>
|}

<tagcloud>
increase_factor=300
</tagcloud>

MediaWiki:Mainpage

2017-05-02T22:56:18Z

Admin: Página creada con «Página Principal»

Página Principal

Liferay Portal

2013-07-17T17:44:13Z

Admin: /* Componentes */

[[Category:Portlet]]
Liferay Portal es un [[Administrador De Contenidos]] de [[Software Libre]] basado en Java, que cumple con la [[Portlet Specification Api]].

Entre las características principales se destacan:
* Administrador de contenidos (CMS) y una Suite de colaboración
* Varios porlets integrados listos para usar
* Herramientas de desarrollo
* Traducción a 22 idiomas
* Funciona con los principales [[Servidor de Aplicaciones]], bases de datos y sistemas operativos.

== Conceptos de estilos y disposición ==
=== Tema (Theme) ===
Vamos a ver los conceptos de Tema (Theme), Disposición (Layout).

Un '''Tema (o Theme)''' es el encargado de renderizar la página en su totalidad, e incluye los aspectos visuales generales del sitio. Un Tema incluye los JavaScript generales, los CSS, y seguramente también el logo del sitio, el menú general, el pie de página, etc. El Tema define un área donde se ubicará el contenido.

Al crear un Tema en realidad se suele "heredar" de algún tema ya existente. Liferay trae 2 temas ya preparados para heredar: "_styled" (del que suele heredarse) y "_unstyled" (que es aún más básico). Se puede consultar el código de estos temas en <LIFERAY_WEBAPP>/html/themes

=== Disposición (layout) ===
Un Tema declara un área donde se ubicará el contenido. Este área de contenido puede tener distintas disposiciones (2 columnas, 3 columnas, etc.); esta disposición se conoce como Layout. Cada página en Liferay puede tener un Layout asociado.

Liferay ya trae varios Layouts comunes declarados, y pueden crearse nuevos. Se puede consultar el código de estos temas en <LIFERAY_WEBAPP>/layouttpl

== Conceptos de gestión de contenidos ==
Liferay permite manejar dos grandes conceptos para gestionar el contenido de una página:
* Estructuras
* Listas dinámicas

=== Estructuras ===
Se pueden crear estructuras de datos para que el usuario complete y pueda cambiar facilmente contenido de la página sin tocar HTML. Una estructura tiene asociado una Plantilla (Template) que indica cómo se renderiza el contenido de una Estructura.

Por ejemplo, puede crearse una estructura Promocion, que contenga un título y una imagen. Luego, se puede crear una Plantilla para la estructura Promoción que renderiza dicha estructura mostrando la imagen y el título debajo.

Al usuario final le quedan entonces 2 pasos para completar:
1. Instanciar la estructura para agregarle datos.
2. Ubicar la estructura instanciada en alguna posición de la página.

Las estructuras, plantillas y instancias de estructras se gestionan desde el Control Panel > Site > Web Content.

=== Listas dinámicas ===
Se pueden crear listas de contenido variable, para que el usuario agregue como si de una lista se tratara. Las listas son de un tipo de dato en particular (el cual se configura al igual que una estructura), y se les asocia una plantilla para renderizar la lista (y opcionalmente, una plantilla para renderizar el formulario de ingreso de un dato de la lista).

Las listas dinámicas se gestionan desde el Control Panel > Site > Dynamic Data Lists

Leer más sobre [http://www.liferay.com/es/documentation/liferay-portal/6.1/user-guide/-/ai/make-it-pretty-creating-custom-displays Crear y estilar listas dinámicas en Liferay].

== Ver también ==
* [http://www.liferay.com Web oficial de Liferay Portal]
* [http://wiki.liferay.com/index.php/Main_Page Wiki oficial de Liferay ]

== Componentes ==
* [[Carrusel con limite en Liferay]]

Carrusel con limite

2013-07-17T17:43:32Z

Admin: Carrusel con limite trasladada a Carrusel con limite en Liferay: Agregada la palabra "Liferay" al título.

#REDIRECCIÓN [[Carrusel con limite en Liferay]]

Carrusel con limite en Liferay

2013-07-17T17:43:32Z

Admin: Carrusel con limite trasladada a Carrusel con limite en Liferay: Agregada la palabra "Liferay" al título.

Un carrusel de imagenes personalizable para [[Liferay Portal]] con soporte para IE7+/Firefox/Chrome.
Los aspectos personalizables son:

* La cantidad maxima de imagenes a mostrar.
* El intervalo de tiempo de transicion entre imagenes.
* La carga de imagenes con o sin link.

== Implementación ==

Utilizamos una estructura y template de Liferay. La estructura es un archivo XML y el template es un archivo velocity.
La estructura es la que define los campos que necesita el web content para crearse. Luego el template de velocity renderiza la estructura mencionada anteriormente.
Para implementarlo utilizamos como base el carrusel que provee Bootstrap. Dicho carrusel se caracteriza por ser responsive.
Para que además sea compatible con IE7+, utilizamos la libreria "respond.js" y algunos meta-tags html. El head debe tener lo siguiente:

<head>
<link rel="stylesheet" type="text/css" href="css/bootstrap/bootstrap.css" media="screen" />
<link rel="stylesheet" type="text/css" href="css/bootstrap/bootstrap-responsive.css" media="screen" />
<meta http-equiv="X-UA-Compatible" content="IE=8"/>
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE8" >
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7">
<script src='js/lib/jquery-1.10.1.min.js' type='text/javascript'> </script>
<script src='js/lib/bootstrap.min.js' type='text/javascript' > </script>
<script src='js/lib/respond.min.js' type='text/javascript' > </script>
</head>

Hay que tener en cuenta que respond.js debe cargarse luego de la libreria de jquery y bootstrap.

Además, para que el estilo "Opacity" sea soportado por IE7+, utilizamos el estilo: Alpha(Opacity=100).
Por ejemplo, si necesitamos que nuestro div tenga una opacidad del 50%:

div{
filter: Alpha(Opacity=50);
opacity: 0.5;
}

Para que se puedan cargar varios carruseles en la misma página, el id identificador de cada instancia esta representado por el id de la estructura(ej: "carrusel"), y
por el titulo del web-content (ej:"web-content-1"), siendo el id resultante "carrusel-web-content-1". Esto convierte a cada instancia del carrusel en única siempre y cuando
los titulos de los web-content sean diferentes.

== Conclusión ==
En nuestra busqueda de implementaciones para carruseles encontramos que mucho de ellos no eran soportados por IE7+ y/o no eran responsives
(ej: rcarousel, FlexSlider ). Otros, en cambio,si cumplian las características anteriores pero eran demasiado complejos de personalizar.
Al encontrar la libreria respond.js, tomamos la alternativa del carrusel de bootstrap ya que puede ser soportado por IE7+, responsive y es facilmente personalizable.

Carrusel con limite en Liferay

2013-07-17T17:41:12Z

Admin: /* Descripción */

Liferay Portal

2013-07-01T18:13:59Z

Admin:

Desarrollo De Software

2013-02-18T12:58:32Z

Admin: /* Ver también */

El desarrollo de software involucra no sólo el uso de [[Metodologias De Desarrollo]], sino la aplicación de tecnologías de desarrollo y testing para asegurar la calidad del producto.

== Libros ==
* [[Libros]]

== Ver también ==
* [[HTML]]
* [[JavaScript]]
* [[Java]]
* [[Diseño De Software]]
* [[Patrones]]
* [[Testing De Aplicaciones]]
* [[Base De Datos]]
* [[Herramientas Para Gestion De Calidad]]
* [[Performance De Aplicaciones]]
* [[Spring Data]]

JavaScript

2013-02-18T12:57:51Z

Admin:

[[Category:JavaScript]]
[[JavaScript]] es un lenguaje de programación interpretado, es decir, que no requiere compilación, utilizado principalmente en páginas web, con una sintaxis semejante a la del lenguaje Java y el lenguaje C.

Al igual que [[Java]], [[JavaScript]] es un lenguaje orientado a objetos propiamente dicho, ya que dispone de Herencia, si bien esta se realiza siguiendo el paradigma de programación basada en prototipos, ya que las nuevas clases se generan clonando las clases base (prototipos) y extendiendo su funcionalidad.

Todos los navegadores modernos interpretan el código [[JavaScript]] integrado dentro de las páginas web. Para interactuar con una página web se provee al lenguaje [[JavaScript]] de una implementación del DOM.

==Frameworks==
[[JavaScript]] cuenta con infinidad de frameworks y librerias que otorgan diversa funcionalidad. Entre los más conocidos:
* [[JQuery]], un framework de aplicación base, sumamente extensible.
* [[Prototype]], un framework de aplicación base que permite definir clases, muy usado.
* [[Rico]], un framework de componentes de presentación [AJAX].
* [[Concurrent Thread Javascript]], librería para manejo de hilos.

==Compatibilidad entre navegadores==
===Problemas con IE===
====Json is undefined====
La version de IE7 e IE8 no tiene importado de forma nativa las librerias de Json, por lo tanto hay que importarlas.

< !--[if lt IE 8]>
<script type="text/javascript" src="/js/json2.js"></script>
<![endif]-->

Bajar la libreria de json desde [[https://github.com/douglascrockford/JSON-js aca]].

====Change event listener====
El comportamiento del listener del evento "change" cuando se lo bindeamos a un radio button es el siguiente:

* en IE 7 el evento se dispara cuando el focus abandona el radio button.

* en Firefox (3.x), Safari (3.x) y opera (96) el evento se dispara al momento de que el radio button es seleccionado, sin esperar a que el focus abandone el radio.

Un workaround para que IE se comporte igual que el resto de los navegadores es el siguiente:

if ($.browser.msie) {
$('input[name=radioXXX]').bind('click', function(){
this.blur();
this.focus();
});
}

$('input[name=radioXXX]').bind('change', function(){
........;
});

==Ver también==
* [http://es.wikipedia.org/wiki/JavaScript JavaScript en la Wikipedia]
* [http://www.theserverside.com/tt/articles/article.tss?l=OOJavaScriptDemonstrated Conceptos y operaciones básicas]
* [[Test de javascript con QUnit]]
* [[Node.js]]

Página Principal

2013-02-16T23:24:25Z

Admin:

Spring Data

2013-01-18T15:53:00Z

Admin: /* Proyecto de ejemplo */

==Introducción==
La herramienta que encontramos útil para dejar de hacer manualmente las implementaciones de los DAO que suelen ser siempre de la misma manera, fué a través de Spring Data JPA. [http://www.springsource.org/spring-data/jpa|http://www.springsource.org/spring-data/jpa]

Este framework nos permite, siguiendo una serie de normas que nos establece, crear interfaces de DAOs definiendo métodos y NO realizar ninguna implementación. Es decir, dejamos la responsabilidad de la implementación al framework, el cuál hará la implementación en tiempo de corrida.
Para ello, el framework básicamente lo que hace es buscar, dado un paquete que le indicamos por configuración, todas las interfaces que hereden de org.springframework.data.repository.Repository<T, ID extends Serializable> ya sea directa o indirectamente.

[[Archivo:Spring-Data-JPA-Herencia repository.PNG]]

==Configuración==

===Dependencias (Utilizando Maven)===
Para trabajar con Spring Data JPA, solo debemos agregar la dependencia:
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.0.3.RELEASE</version>
</dependency>

Siempre y cuando contemos con una configuración de persistencia que utilice:
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="defaultDataSource" />
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="false" />
</bean>
</property>
</bean>

===Configurando el paquete a escanear===

En el applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
.
.
.

<jpa:repositories base-package="com.th.ctc.dao" />
.
.
.
</beans>

==Implementación==
===El ejemplo fácil===
====Definiendo la interfaz del DAO====
Para este ejemplo sencillo, la interfaz del DAO va a quedar sin métodos definidos explicitamente, pero con todos aquellos que estamos heredando.

import org.springframework.data.repository.CrudRepository;
import com.th.ctc.domain.Cliente;
/**
* Interfaz del DAO para la entidad {@link Cliente}. Esta interfaz NO tiene una
* implementacion concreta dado que al extender de Repository la implementacion
* la hace en runtime Spring Data JPA.
*
* @author Alguien.
*/
public interface ClienteDao extends CrudRepository<Cliente, Long> {
}

====Usando el DAO desde el Service====
Hasta acá llegamos. A partir de ahora no hay mas código vinculado con el DAO más que el uso de los métodos que estamos exponiendo en la interfaz que nosotros mismos creamos. Por lo tanto nuestro Service sería algo como:

/**
* DAO de clientes.
*/
@Autowired
private ClienteDao clienteDao;
@Override
public List<Cliente> buscarTodos() {
return (List<Cliente>) clienteDao.findAll(); //El método findAll() proviene de CrudRepository
}

====Test====
Como no hay una implementación concreta, y de haber, no la hacemos nosotros sino que estamos delegando la responsabilidad al framework, no hacemos tests de la capa DAO, pero si del Service donde probamos que estamos utilizando correctamente lo que nos provee Spring DATA JPA además claro de la lógica propia del Service.

===El ejemplo habitual===

====Definiendo la interfaz del DAO====
Para este ejemplo sencillo, la interfaz del DAO va a quedar sin métodos definidos explicitamente, pero con todos aquellos que estamos heredando.

import org.springframework.data.repository.PagingAndSortingRepository;
import com.th.ctc.domain.Usuario;
/**
* Interfaz del DAO para la entidad {@link Usuario}. Esta interfaz NO tiene una
* implementacion concreta dado que al extender de Repository la implementación
* la hace en runtime Spring Data JPA.
*
* @author Alguien.
*/
public interface UsuarioDao extends PagingAndSortingRepository<Usuario, Long> {
}

====Usando el DAO desde el Service====
Hasta acá llegamos. A partir de ahora no hay mas código vinculado con el DAO más que el uso de los métodos que estamos exponiendo en la interfaz que nosotros mismos creamos. Por lo tanto nuestro Service sería algo como:

/**
* DAO de usuarios.
*/
@Autowired
private UsuarioDao usuarioDao;
@Override
public List<Usuario> buscarTodos() {
// El método findAll(Sort) proviene de PagingAndSortingRepository y con el String "apellido" (es el nombre del
// atributo de clase de la entidad Usuario) estamos indicando que se ordenaran los resultados por ese campo
return (List<Usuario>) usuarioDao.findAll(new Sort("apellido"));
}

====Test====
Como no hay una implementación concreta, y de haber, no la hacemos nosotros sino que estamos delegando la responsabilidad al framework, no hacemos tests de la capa DAO, pero si del Service donde probamos que estamos utilizando correctamente lo que nos provee Spring DATA JPA además claro de la lógica propia del Service.

===El ejemplo dificil===
Supongamos que ahora necesitamos 2 cosas:
Por un lado, recuperar todos los elementos de una entidad, recuperar uno solo en base al ID y etc., y por otro, generar un archivo Excel con información recuperada de una consulta a una base de datos muy específica.
Para lograr esto, aprovechando esta herramienta, necesitamos 2 interfaces del DAO. Una para definir estos métodos tan complejos que necesitamos, y otra para utilizar de la misma manera que en el ejemplo fácil.

¿Pero entonces el Service tiene que utilizar 2 DAOs distintos sobre la misma entidad?

No. Antes que nada, veamos un diagrama de clases para que veamos por qué este es el ejemplo dificil:
[[Media:Ejemplo complejo Spring Data JPA.PNG|Diagrama de clases]]

Es decir, tenemos un Service (TareaServiceImpl) que utiliza un DAO (TareaDao). Nada nuevo hasta acá. Sin embargo, este TareaDao no solo hereda de Repository al heredar de org.springframework.data.repository.PagingAndSortingRepository, sino que también está heredando de una interfaz definida por nosotros (CustomTareaDao).

¿Por qué necesitamos esto?

Bueno, por que si bien podemos definir métodos en la interfaz que hereda de Repository, estos métodos tienen que seguir una nomenclatura específica para que el framework pueda hacer la implementación y, además, porque no podemos definir métodos que no queremos que los implemente Spring Data JPA para implementarlos nosotros.

====Definiendo la interfaz del DAO====

import java.util.Date;
import java.util.List;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.PagingAndSortingRepository;
import com.th.ctc.domain.Tarea;
/**
* Interfaz el DAO de las {@link Tarea} implementado por Spring Data JPA.
*
* @author Alguien.
*/
public interface TareaDao extends PagingAndSortingRepository<Tarea, Long>, CustomTareaDao {
/**
* Recupera todas las tareas del usuario que le pasamos, para la fecha dada.
*
* @author Alguien.
* @param idUsuario
* {@link Long} con el ID del usuario duenio de la tarea.
* @param fechaDesde
* {@link Date} la fecha desde la cual se buscara.
* @param fechaHasta
* {@link Date} la fecha hasta la cual se buscara.
* @param sort
* {@link Sort} de Spring Data JPA utilizado para ordenar los
* resultados segun cierto criterio.
* @return {@link List<Tarea>} Las tareas encontradas.
*/
List<Tarea> findByUsuarioIdAndFechaBetween(Long idUsuario, Date fechaDesde, Date fechaHasta, Sort sort);
}

Como vemos, estamos definiendo un método '''findByUsuarioIdAndFechaBetween''' que sigue la nomenclatura del framework para recuperar un listado de tareas en base al Id del Usuario que le pasamos, entre un rango de fechas dado, y que al definir con esta nomenclatura hacemos que la implementación quede a cargo del framework.

====Usando el DAO desde el Service====
Ahora, nuestro Service cuenta con un DAO que tiene:
* Métodos definidos en él;
* Métodos provistos por PagingAndSortingRepository;
* Métodos provistos por CustomTareaDao.

¿Y las implementaciones?

Las implementaciones de los métodos definidos en TareaDao y los heredados de PagingAndSortingRepository, nos las va a proveer el framework. Y para la interfaz CustomTareaDao nosotros debemos definir nuestro DaoImpl común y corriente.

====Test====
A la hora de testear, debemos tener un test (en nuestro caso es TareaDaoComponenteTest) que testee de la interfaz DAO que exponemos (es decír, TareaDao):
* Los métodos definidos manualmente en el DAO siguiendo la nomenclatura específica del framework. Ej: List<Tarea> findByUsuarioIdAndFechaBetween(Long idUsuario, Date fechaDesde, Date fechaHasta, Sort sort);
* Los métodos definidos en la interfaz creada para los métodos específicos (CustomTareaDao). Ej: ScrollableResults buscarResumenHoras(FiltroResumenHorasDto filtro);

===Test===
Como estamos delegando la responsabilidad de la implementación del DAO en un framework, y como ni siquiera sabemos como es la implementación dado que se produce en runtime, decidimos no testear aquellos métodos ya tenemos definidos al heredar de alguna de las interfaces que nos provee la herramienta.
Sin embargo, sí decidimos testear la capa del Service donde probamos que estamos utilizando correctamente lo que nos provee Spring DATA JPA, además claro de la lógica propia del Service.

==Mas==

===SELECT DISTINCT===

====Situación a resolver====
Necesitamos recuperar todos los clientes, tal que alguno de los servicios de los clientes cumpla con una condición determinada.

====Primera solución====
Creamos un método:
List<Cliente> findByServiciosEstado(EstadosServicios estado);

====Problema====
El método traía repetidos los clientes por cada uno de sus servicios que cumplían con la condición.

=====Contexto=====
* Spring Data JPA, version 1.0.3.RELEASE.

=====Solución=====
Al método le agregamos la keyword Distinct delante del By:
List<Cliente> findDistinctByServiciosEstado(EstadosServicios estado);

=====Comentario adicional=====
El problema de esto es que la keyword no está en la [http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html/#repository-query-keywords| documentación oficial de Spring Data JPA].
Sin embargo, encontramos una [https://jira.springsource.org/browse/DATAJPA-174?page=com.atlassian.streams.streams-jira-plugin:activity-stream-issue-tab| issue en el Jira de Spring Data JPA] sobre el tema.

Por último, [http://static.springsource.org/spring-data/data-jpa/docs/1.0.0.RELEASE/changelog.txt | en el changelog de la versión] se indica que está soportado.

===Proyecto de ejemplo===
Pueden descargarse un proyecto de ejemplo haciendo un checkout mediante un cliente de SVN de:
http://dosideas-aplicaciones-modelo.googlecode.com/svn/spring-data/trunk

Hibernate

2012-08-07T17:22:42Z

Admin: /* Ver también */

[[Category:Hibernate]]
Hibernate es un framework de persistencia de objetos para Java. Su función principal es la de [[Mapeo Objeto-Relacional]], es decir, mapear objetos a tablas de una base de datos relacional.

Actualmente Hibernate cuanta con varios subproyectos que resuelven distintos aspectos del acceso y manipulación de datos.

== Log de querys ==
Es posible decirle a Hibernate que realice un log de los comandos SQL que ejecuta. Esto resulta muy útil en tiempo de desarrollo.

Para esto es necesario definir la propiedad ''show_sql'' en la configuración de Hibernate (generalmente, el archivo ''hibernate.cfg.xml''):

<code xml>
<property name="show_sql">true</property>
</code>

Al ejecutar veremos algo como lo siguiente:

<code sql>
select emails0_.PERSON_ID as PERSON1_0_, emails0_.EMAIL_ADDR as EMAIL2_0_
from PERSONA emails0_
where emails0_.PERSON_ID=?
</code>

Si además queremos que el log aparezca mejor formateado, agregamos la variable ''format_sql'':

<code xml>
<property name="format_sql">true</property>
</code>

Y veremos:
<code sql>
select
emails0_.PERSON_ID as PERSON1_0_,
emails0_.EMAIL_ADDR as EMAIL2_0_
from
PERSONA emails0_
where
emails0_.PERSON_ID=?
</code>

Si ademas desean saber los valores de las bind variables, y variables de resultado que se utilizan en el query, deben configurar lo siguiente en el archivo ''log4j.properties'':

<code>
log4j.logger.org.hibernate.type=debug
</code>

Y veremos:
<code>
12:30:56,551 DEBUG LongType:133 - binding '1' to parameter: 1
12:30:56,551 DEBUG LongType:172 - returning '1' as column: PERSON1_0_
12:30:56,567 DEBUG StringType:172 - returning 'demo@dosideas.com' as column: EMAIL2_0_
</code>

Otra opción bastante interesante es ver el manejo de recursos por parte de Jdbc. Se debe agregar la propiedad:

<code>
log4j.logger.org.hibernate.jdbc=debug
</code>

Y veremos:

<code>
12:30:56,551 - opening JDBC connection
12:30:56,553 - preparing statement
12:30:56,554 - about to open ResultSet (open ResultSets: 0, globally: 0)
12:30:57,551 - about to close ResultSet (open ResultSets: 1, globally: 1)
12:30:58,551 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
12:30:58,552 - closing statement
12:30:56,553 - aggressively releasing JDBC connection
12:30:56,554 - releasing JDBC connection [ (open PreparedStatements: 0, globally: 0)
(open ResultSets: 0, globally: 0)]
</code>

== Ver también ==
* [[Cache De Hibernate]]
* [[Hibernate Con Spring]]
* [[Hibernate Annotations con Spring]]
* [[Actualizacion Dinamica Con Hibernate]]
* [[Eficiencia Ejecutando Querys Con Hibernate]]
* [[Stored Procedures con Hibernate]]
* [[Practicas con Hibernate]]
* [http://www.hibernate.org/ Web oficial de Hibernate]
* [http://docs.jboss.org/hibernate/orm/4.1/quickstart/en-US/html/files/hibernate-tutorials.zip Hibernate 4 Tutorials (proyectos con código de ejemplo)]
* [http://www.hibernate.org/hib_docs/v3/reference/en/html/tutorial.html#tutorial-firstapp Tutorial de Hibernate]
* [http://www.javaworld.com/javaworld/jw-07-2008/jw-07-orm-comparison.html Comparación entre Hibernate, iBatis y JPA]
* [http://www.dosideas.com/java/180-testeando-rapido-todos-los-mapeos-de-hibernate.html Testear todos los mapeos de Hibernate]

Sun Code Conventions

2012-07-30T15:23:22Z

Admin: /* Ver también */

[[Category:Diseño De Software]]
[[Category:Java]]
Las convenciones de codificación en [[Java]] de Sun (Sun Code Conventions) es un documento que contiene convenciones estandard que Sun recomienda seguir. Las reglas cubren nombres de archivos, organizacion de directorios, identación, comentarios, declaraciones, sentencias, espacios en blanco, nomenclaturas, prácticas de programación e incluye un ejemplo de código.

== ¿Por qué tener una convención de codificación? ==
Las convenciones de codificación son importantes para los programadores por varias razones:
* el 80% del costo del software ocurre en el mantenimiento.
* prácticamente ningún software es mantenido toda su vida por el autor original.
* las convenciones mejoran la lectura del software, permitiendo a los ingenieros comprender el código nuevo de manera más rápida y completa.

==Clase de ejemplo==
La siguiente clase de ejemplo trata de resumir en modo concreto el uso de la reglas. No abarca todas las situaciones ni reemplaza la lectura de las convenciones, sino que sirve como un recordatorio rápido de las situaciones más comunes

<code java>
package java.blah;

import java.blah.blahdy.BlahBlah;

/**
* La descripcion de la clase va aqui.
*
* @version 1.82 18 Mar 1999
* @author Nombre Apellido
*/
public class Blah extends SomeClass {
/* Un comentario sobre la implementacion de esta clase podria ir aqui. */

/** Documentacion de la variable classVar1 */
public static int classVar1;

/**
* La documentacion de classVar2 es mas larga y compleja, y puede
* abarcar mas de una linea de esta manera
*/
private static Object classVar2;

/** Documentacion de instanceVar1 */
public Object instanceVar1;

/** Documentacion de instanceVar2 */
protected int instanceVar2;

/** Documentacion de instanceVar3 */
private Object[] instanceVar3;

/**
* ...documentacion del constructor Blah...
*/
public Blah() {
// ...la implementacion va aca...
}

/**
* ...documentacion del metodo doSomething...
*/
public void doSomething() {
// ...implementation goes here...
}

/**
* ...documentacion del metodo doSomethingElse...
* @param unParam descripcion
*/
public void doSomethingElse(Object unParam) {
// ...implementacion aca...
}

/**
* ...un metodo con ejemplos de sentencias...
*/
public void mostrarEjemplosDeSentencias() {
int maxloops = 10;
int a = 0;
int b = 0;
int c = 0;
int d = 0;

a += c + d;
a = (a + b) / (c * d);
System.out.println("el valor de a es " + a + "\n");

unMetodo((byte) a, (Object) x);

if (condition) {
statements;
} else if (condition) {
statements;
} else {
statements;
}

for (int i = 0; i < maxLoops; i++) {
statements;
}

switch (condition) {
case ABC:
statements;
/* falls through */

case DEF:
statements;
break;

case XYZ:
statements;
break;

default:
statements;
break;
}

try {
statements;
} catch (ExceptionClass e) {
statements;
} catch (OtraExceptionClass e) {
statements;
} finally {
statements;
}
}
}
</code>

==Ver también==
* [http://www.oracle.com/technetwork/java/javase/documentation/codeconvtoc-136057.html Code Conventions for the Java Programming Language]
* [http://www.programacion.net/java/tutorial/convenciones/ Sun Code Conventions (traducido al castellano)]

Sun Code Conventions

2012-07-30T15:22:43Z

Admin: Revertidos los cambios de 209.202.9.10 (disc.) a la última edición de Admin

[[Category:Diseño De Software]]
[[Category:Java]]
Las convenciones de codificación en [[Java]] de Sun (Sun Code Conventions) es un documento que contiene convenciones estandard que Sun recomienda seguir. Las reglas cubren nombres de archivos, organizacion de directorios, identación, comentarios, declaraciones, sentencias, espacios en blanco, nomenclaturas, prácticas de programación e incluye un ejemplo de código.

== ¿Por qué tener una convención de codificación? ==
Las convenciones de codificación son importantes para los programadores por varias razones:
* el 80% del costo del software ocurre en el mantenimiento.
* prácticamente ningún software es mantenido toda su vida por el autor original.
* las convenciones mejoran la lectura del software, permitiendo a los ingenieros comprender el código nuevo de manera más rápida y completa.

==Clase de ejemplo==
La siguiente clase de ejemplo trata de resumir en modo concreto el uso de la reglas. No abarca todas las situaciones ni reemplaza la lectura de las convenciones, sino que sirve como un recordatorio rápido de las situaciones más comunes

<code java>
package java.blah;

import java.blah.blahdy.BlahBlah;

/**
* La descripcion de la clase va aqui.
*
* @version 1.82 18 Mar 1999
* @author Nombre Apellido
*/
public class Blah extends SomeClass {
/* Un comentario sobre la implementacion de esta clase podria ir aqui. */

/** Documentacion de la variable classVar1 */
public static int classVar1;

/**
* La documentacion de classVar2 es mas larga y compleja, y puede
* abarcar mas de una linea de esta manera
*/
private static Object classVar2;

/** Documentacion de instanceVar1 */
public Object instanceVar1;

/** Documentacion de instanceVar2 */
protected int instanceVar2;

/** Documentacion de instanceVar3 */
private Object[] instanceVar3;

/**
* ...documentacion del constructor Blah...
*/
public Blah() {
// ...la implementacion va aca...
}

/**
* ...documentacion del metodo doSomething...
*/
public void doSomething() {
// ...implementation goes here...
}

/**
* ...documentacion del metodo doSomethingElse...
* @param unParam descripcion
*/
public void doSomethingElse(Object unParam) {
// ...implementacion aca...
}

/**
* ...un metodo con ejemplos de sentencias...
*/
public void mostrarEjemplosDeSentencias() {
int maxloops = 10;
int a = 0;
int b = 0;
int c = 0;
int d = 0;

a += c + d;
a = (a + b) / (c * d);
System.out.println("el valor de a es " + a + "\n");

unMetodo((byte) a, (Object) x);

if (condition) {
statements;
} else if (condition) {
statements;
} else {
statements;
}

for (int i = 0; i < maxLoops; i++) {
statements;
}

switch (condition) {
case ABC:
statements;
/* falls through */

case DEF:
statements;
break;

case XYZ:
statements;
break;

default:
statements;
break;
}

try {
statements;
} catch (ExceptionClass e) {
statements;
} catch (OtraExceptionClass e) {
statements;
} finally {
statements;
}
}
}
</code>

==Ver también==
* [http://java.sun.com/docs/codeconv/ Sun Code Conventions]
* [http://www.programacion.net/java/tutorial/convenciones/ Sun Code Conventions (traducido al castellano)]

SLF4J

2012-07-02T21:02:24Z

Admin: /* Parametrización de mensajes */

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

=== Parametrización de mensajes ===
En [[SLF4J]] es muy facil parametrizar mensajes de log sin realizar concatenaciones:
<code java5>
logger.debug("Mensaje: {}, {}", unObjectoGrande, otroObjetoGrande);
</code>
La serialización a String de los objetos sólo se realizará si el nivel de log es el indicado, y se ubicarán en orden como reemplazo de las llaves. Este mecanismo de log es elegante y muy eficiente, porque [[SLF4J]] demora la construcción del mensaje final de log hasta que realmente sea necesario.

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4J]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

==== Clase Level de Log4J ====
Log4J expone una clase Level (una enumeración que contiene los niveles de log) que se utiliza en el API para, programáticamente, establecer el nivel de log. Eso se realiza con el API de Log4J logger.log(Level level, Object mensaje).

No existe un equivalente directo en SLF4J para este caso. En StackOverflow hay una interesante discusión con [http://stackoverflow.com/questions/2621701/setting-log-level-of-message-at-runtime-in-slf4j alternativas para establecer el nivel de log en tiempo de ejecución con SLF4J]. La alternativa final a usar estará determinada por la necesidad del sistema.

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T21:02:00Z

Admin: /* Parametrización de mensajes */

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

=== Parametrización de mensajes ===
En [[SLF4J]] es muy facil parametrizar mensajes de log sin realizar concatenaciones:
<code java5>
logger.debug("Mensaje: {}, {}", unObjectoGrande, otroObjetoGrande);
</code>
La serialización a String de los objetos sólo se realizará si el nivel de log es el indicado, y se ubicarán en orden como reemplazo de las llaves. Este mecanismo de log es elegante y muy eficiente, porque [[SLF4]] demora la construcción del mensaje final de log hasta que realmente sea necesario.

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4J]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

==== Clase Level de Log4J ====
Log4J expone una clase Level (una enumeración que contiene los niveles de log) que se utiliza en el API para, programáticamente, establecer el nivel de log. Eso se realiza con el API de Log4J logger.log(Level level, Object mensaje).

No existe un equivalente directo en SLF4J para este caso. En StackOverflow hay una interesante discusión con [http://stackoverflow.com/questions/2621701/setting-log-level-of-message-at-runtime-in-slf4j alternativas para establecer el nivel de log en tiempo de ejecución con SLF4J]. La alternativa final a usar estará determinada por la necesidad del sistema.

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T21:01:41Z

Admin: /* Uso clásico */

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

=== Parametrización de mensajes ===
En [[SLF4J]] es muy facil parametrizar mensajes de log sin realizar concatenaciones:

logger.debug("Mensaje: {}, {}", unObjectoGrande, otroObjetoGrande);

La serialización a String de los objetos sólo se realizará si el nivel de log es el indicado, y se ubicarán en orden como reemplazo de las llaves. Este mecanismo de log es elegante y muy eficiente, porque [[SLF4]] demora la construcción del mensaje final de log hasta que realmente sea necesario.

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4J]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

==== Clase Level de Log4J ====
Log4J expone una clase Level (una enumeración que contiene los niveles de log) que se utiliza en el API para, programáticamente, establecer el nivel de log. Eso se realiza con el API de Log4J logger.log(Level level, Object mensaje).

No existe un equivalente directo en SLF4J para este caso. En StackOverflow hay una interesante discusión con [http://stackoverflow.com/questions/2621701/setting-log-level-of-message-at-runtime-in-slf4j alternativas para establecer el nivel de log en tiempo de ejecución con SLF4J]. La alternativa final a usar estará determinada por la necesidad del sistema.

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T20:54:45Z

Admin:

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4J]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

==== Clase Level de Log4J ====
Log4J expone una clase Level (una enumeración que contiene los niveles de log) que se utiliza en el API para, programáticamente, establecer el nivel de log. Eso se realiza con el API de Log4J logger.log(Level level, Object mensaje).

No existe un equivalente directo en SLF4J para este caso. En StackOverflow hay una interesante discusión con [http://stackoverflow.com/questions/2621701/setting-log-level-of-message-at-runtime-in-slf4j alternativas para establecer el nivel de log en tiempo de ejecución con SLF4J]. La alternativa final a usar estará determinada por la necesidad del sistema.

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T20:48:15Z

Admin: /* Uso de MDC */

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4J]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T20:39:48Z

Admin: /* Migración de Log4J a SLF4J */

Simple Logging Facade for Java (SLF4J) es una librería [[Java]] que funciona como una abstracción simple para varios frameworks de logging (como [[Log4J]], java.util.logging o [[Logback]]). Le permite al usuario final agregar el framework de log deseado al momento de deploy.

Agregar SLF4J a un proyecto implica agregar un único jar, llamado slf4j-api.jar. Si no se agrega ninguna extensión para integrar con un framework de log, SLF4J usará una implementación dummy (que no loguea).

== Uso clásico ==
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MiClase {

private static Logger logger = LoggerFactory.getLogger(MiClase.class);

public void unMetodo() {
log.info("Hola, mundo");
}
}
</code>

== Migración de Log4J a SLF4J ==
Es relativamente sencillo quitar todas las referencias de [[Log4J]] de una aplicación para utilizar el API de [[SLF4J]]. Una vez hecho esto, la aplicación seguirá usando [[Log4J]] para loguear, pero las clases no harán referencia a este framework (y nos permitirá, a futuro, cambiar el framework de log sin realizar cambios en el código).

Los pasos para agregar SLF4J a un proyecto con Log4J son:
# Agregar los JAR de SLF4J.
# Reemplazar las referencias a Log4J en el código por las equivalentes en SLF4J.

=== Agregar los JAR de SLF4J ===
Necesitamos al menos 2 JAR:
* slf4j-api
* slf4j-log4j12

Además, es muy probable que algunas librerías del proyecto utilicen Jakarta Commons Logging (JCL). Para integrar también estas librerías, necesitamos agregar un JAR extra:
* jcl-over-slf4j

Usando [[Maven]], el POM queda:
<code xml>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.6</version>
</dependency>
</code>

=== Reemplazar referencias a Log4J por equivalentes en SLF4J ===
Existen equivalente en SLF4J para llamadas a Log4J.

==== Obtención del Logger ====
En [[Log4J]] el logger se obtiene:
<code java5>
import org.apache.log4j.Logger;
...
private static Logger log = Logger.getLogger(MiClase.class);
</code>

En [[SLF4J]] el logger se obtiene:
<code java5>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
..
private static Logger log = LoggerFactory.getLogger(MiClase.class);
</code>

==== Uso de MDC ====
[[Log4J#Log4JMDC]] permite asociar información de contexto para ser usada por el framework de log. En [[Log4J]] el MDC se establece:
<code java5>
import org.apache.log4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

En [[SLF4]] la sintaxis es igual, sólo cambia el import del MDC:
<code java5>
import org.slf4j.MDC;
...
try {
MDC.put("unValor", valor);
//hacer algo
} finally {
MDC.remove("unValor");
}
</code>

== Ver también ==
* [http://www.slf4j.org/ Web oficial de SLF4J]
* [[Log4J]]

SLF4J

2012-07-02T20:32:37Z

Admin:

SLF4J

2012-07-02T20:27:18Z

Admin: Página creada con 'Simple Logging Facade for Java (SLF4J) es una librería Java que funciona como una abstracción simple para varios frameworks de logging (como Log4J, java.util.logging o…'

Java

2012-07-02T20:09:11Z

Admin: /* Cuestiones generales de Java */

[[Category:Java]]
Java es un lenguaje de programación, aunque también se suele hacer referencia con este nombre a toda una plataforma para el desarrollo de aplicaciones. Hay un buen [http://es.wikipedia.org/wiki/Java_%28Sun%29 resumen de Java en la wikipedia].

Al desarrollar un sistema se suele basar en una [[Arquitectura De Software]] para crear los componentes.

Java se caracteriza por una enorme cantidad de proyectos libres.

== Algunas tecnologías Java ==
=== Frameworks de base===
* [[Spring Framework]]
* [[Terracotta]]
* [[EJB]]
* [[Restlet]]

===Acceso a datos===
* [[Hibernate]]
* [[Apache Lucene]]

===Frameworks de presentación===
* [[Apache Tiles]]
* [[Struts]]
* [[JSF]]
* [[JSTL]]
* [[GWT]]

===Librerías===
* [[Google Guava]]
* [[Jawr]]

===Mensajeria===
* [[JMS]]

===Web Services===
* [[Web Service]]
* [[Web Service Con Spring]]

===Ejecuciones batch y programadas===
* [[Quartz]]
* [[Spring Batch]]

===Cuestiones generales de Java===
* [[Fechas En Java]]
* [[Numeros En Java]]
* [[Encoding En Java]]
* [[Serializacion De Objetos En Java]]
* [[Log4J]]
* [[SLF4J]]
* [[Cache De Objetos Java]]
* [[Exportacion Hacia Archivos]]

Log4J

2012-07-02T20:08:44Z

Admin: /* Ver también */

[[Category:Java]]
Log4J es una librería para resolver el log de aplicaciones [[Java]].

==Los Appender==
Log4J utiliza "appenders" para guardar el log generado por las aplicaciones. Un appender es el encargado de procesar un mensaje de log enviado por la aplicación. Usualmente se encarga de almacenarlo en algún medio persistente, como ser un archivo.

Existen distintos appenders para guardar logs en archivos, base de datos o colas de mensajeria.

===JMSAppnder===

Log4J cuenta con un Appender especial que redirecciona los eventos de log a un Topic [[JMS]].

El appender a utilizar es ''org.apache.log4j.net.JMSAppender'', el cual se encarga de enviar los eventos de log a un Topic asociado. Un topic es parecido a una cola, pero con la diferencia que los mensajes se distribuyen a todos los suscriptores de la misma. Si no hay suscriptores, el mensaje se pierde.

El JMSAppnder es muy útil en un ambiente en cluster, para centralizar la información de los log en un único lugar.

==== Ejemplo de uso ====

En la práctica, utilizar log4j con este appender es igual que en cualquier otro caso. En el archivo de configuración ''log4j.properties'' es necesario agregar el appender en cuestión.

log4j.logger.com.zim=DEBUG, jms
log4j.appender.jms=org.apache.log4j.net.JMSAppender
log4j.appender.jms.InitialContextFactoryName=weblogic.jndi.WLInitialContextFactory
log4j.appender.jms.ProviderURL=t3://miApplicationServer:7001
log4j.appender.jms.TopicConnectionFactoryBindingName=JmsZimCF
log4j.appender.jms.TopicBindingName=ZimTopic
log4j.appender.jms.locationInfo=true

En el ejemplo, utilizamos el Connection Factory ''JmsZmiCF'' para conectarnos al topic ''ZimTopic'' (ambos teniendo que estar configurados en algún [[Servidor de Aplicaciones]]).

Con esta configuración todos los logs de las clases que pertenezcan al paquete "com.zim" se enviaran como mensajes al topic. Al Topic se envian objetos de tipo ''LoggingEvent'', clase que contiene la información de un evento de log.

Luego, podrá haber distintos suscriptores que tomen las acciones necesarias sobre el mensaje. Por ejemplo, podriamos tener suscriptores que guarden el log en una base de datos, u otros que envien un mail o sms.

====Sobre el locationInfo====

Por default, el atributo locationInfo está en "false". Esto hace que NO se envien los datos para el objeto ''LocationInfo'' de ''LoggingEvent''. Al setearlo en true, el objeto ''LocationInfo'' contendrá la información sobre la clase, método y número de línea en donde ocurrió el error.

====Procesando el mensaje====

Luego, queda tan solo decidir qué hacer con el mensaje. Usualmente, será un [[Message Driven Bean]] que procese de alguna manera el mensaje que envia Log4J.

¿Y qué envia exactamente? Log4J enviará un ''ObjectMessage'' de JMS, que contiene una instancia de ''LoggingEvent'', la cual contiene la información relativa al log que generó la aplicación.

===SMTPAppender===

Es un Appender muy útil para la generación de alarmas vía mail.

NOTA 1: Por estar pensado para casos de error (o tal vez por bug) sólo se envía el mail cuando el nivel de log es ERROR o superior.

NOTA 2: Utilizar la versión de log4j 1.2.16 o superior (en las anteriores hay algún inconveniente sobre todo si se utiliza smtp.gmail.com).

==== Ejemplo de uso ====

Configuración en ''log4j.properties'':

<code>
# Acordate!!! Nivel ERROR o superior

log4j.logger.com.demo.smtpAppender.MyService=ERROR, mailAppender

# SMTP appender para alarmas via mail

log4j.appender.mailAppender=org.apache.log4j.net.SMTPAppender
log4j.appender.mailAppender.Threshold=WARN
log4j.appender.mailAppender.BufferSize=10
log4j.appender.mailAppender.To=<mails_destino_separados_por_coma>
log4j.appender.mailAppender.From=<mail_from>
log4j.appender.mailAppender.SMTPHost=<smtp_host>
log4j.appender.mailAppender.SMTPPort=<puerto>
log4j.appender.mailAppender.SMTPUsername=<username>
log4j.appender.mailAppender.SMTPPassword=<password>
log4j.appender.mailAppender.SMTPProtocol=smtps
log4j.appender.mailAppender.Subject=Alarma generada con Log4J
log4j.appender.mailAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.mailAppender.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n
</code>

Con esta configuración los logs de nivel error o superior de la clase MyService enviarán un mail con la información que se loguee.

==Log4j en J2EE, en servidores WebLogic==

Si queres compartir los mismos componentes log4j en un módulo EJB y Web, y el EJB se usa localmente, en el ear tienen que estar el EJB y el Web. El log4-*.jar en /APP-INF/lib, y log4.properties en /APP-INF/classes. /APP-INF/ en la raíz del ear.

Y dentro del build-impl.xml del ear, los sgtes. pasos para la tarea que crea el META-INF:

<code>
<copy todir="${build.dir}/APP-INF/lib">
<fileset file="${log4j.jar}"/>
</copy>
<copy todir="${build.dir}/APP-INF/classes">
<fileset file="${log4j.properties}"/>
</copy>
</code>

==Log4J en Debug==

Se puede usar el argumento '''-Dlog4j.debug''' como parametro para la JVM y muestra algunas cosas de log4J por consola, como por ejemplo, el archivo desde donde está levantando las propiedades.

==Obtención del Logger==
Existe una serie de variantes para definir y obtener el logger de una clase:

===Los modificadores===
====private====
Por lo general queremos que el logger se reporte como la clase que se está ejecutando. Utilizando private nos aseguramos que una clase que herede tenga que declarar su propio Logger y no usará accidentalmente el de la superclase. Contrariamente, si queremos por granularidad que utilice el de la superclase, habrá que declararlo como protected.

====final====
La referencia al logger es la misma durante todo el ciclo de vida de una clase (si se declara static) o de un objeto (si es atributo de instancia). Por lo tanto, declarándola final se expresa esto, se protege a una asignación errónea y se mejora la performance.

====static====
La creación del Logger está administrada por una fábrica a la que le pedimos las instancias. Es responsabilidad de la fábrica darnos la instancia correcta. En este caso, la motivación de utilizar static no es la de tener una sola copia. La motivación es que los logger no deben serializarse, deberían ser transient. Siendo static es una variable de la clase y no un atributo de la instancia, por lo que no será serializado. La razón de no marcarlo como transient (que sería conceptualmente más acertado) es que se debería implementar un mecanismo para que cuando la instancia es des-serializada, vuelva a obtener una copia del logger.

====transient====
Los logger no deben ser serializados, por eso deberían ser marcados como transient. Es más fácil marcarlos como static ya que de esta forma no es necesario volver a obtenerlos cuando la clase es des-serializada. Si la clase no es serializable, no es necesario.

===Clave para la obtención del logger===
El logger se le pide a la fábrica a través de una clave. Esta clave es de tipo String. El método está sobrecargado para recibir también un objeto de tipo class que luego la fábrica convertirá a String.

====String====
private static final Logger log = Logger.getLogger("com.foo.bar.Blah");
Utilizando un String se obtiene un logger independientemente de la clase donde se esté. Si lo que se busca el logger para la clase, esta es la forma más riesgosa ya que no está verificada por el compilador.

====Objeto class====
private static final Logger log = Logger.getLogger(Blah.class);
Utilizando un objeto de tipo Class permite que el compilador verifique el nombre de la clase. También se actualiza si se utiliza alguna herramienta o IDE para cambiar el nomre de la clase.

====método getClass()====
private transient Logger log = Logger.getLogger(getClass());
En este caso la clave se genera en tiempo de ejecución pidiendo al objeto su clase a través del método getClass(). Esto tiene la ventaja de que siempre tendrá el nombre apropiado de la clase. Tiene la restricción de que sólo se podrá utilizar si el logger es un atributo de instancia (no static).

Otra particularidad es que el método getClass() invocado en una clase padre responderá desde la clase hija.

En caso de que el objeto sea serializable habrá que agregar el modificador transient para que no se serialice el logger.

===Conclusión===
La forma práctica de no cometer errores es la de utilizar la combinación más restrictiva y cambiarla sólo si se tiene alguna razón claramente justificada e implementando los mecanismos necesarios.

Forma típica:

<code>
public class Blah {
private static final Logger log = Logger.getLogger(Blah.class);
}
</code>

== Log4JMDC ==
MDC es una característica de [[Log4J]] que permite agregar información adicional (de forma "clave=valor"), que luego puede ser referenciada en el patrón de log. Aquí entonces podemos almacenar datos generales (como ser, el nombre de usuario) y mostrarlos en todos los logs que se generen.

En el patrón de log, se pueden hacer referencia a las variables del MDC usando:
%X{clave}

Los datos del MDC se guardan en el thread en ejecución. Un uso común es crear un Filter web, y allí guardar el nombre de usuario logueado en el entorno MDC, para que luego pueda loguearse.

=== Filter web con MDC ===
El siguiente es un filter web común que guarda la variable "username" en el MDC, para luego referenciarla en patrón de log4j.xml

<code java5>
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.dosideas.mdc.filter;

import java.io.IOException;
import javax.servlet.*;
import org.apache.log4j.MDC;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

/**
* Adds MDC information for Log4j. In particular, it adds the username (if
* available) to MDC.
*/
public class Log4jMDCFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

String username = obtenerNombreDeUsuarioLogueado();

try {
MDC.put("username", username);
chain.doFilter(request, response);
} finally {
MDC.remove("username");
}
}

@Override
public void init(FilterConfig filterConfig) throws ServletException { }

@Override
public void destroy() { }

private String obtenerNombreDeUsuarioLogueado() { .... }
}
</code>

Luego, en el archivo log4j.xml podemos hacer uso de la variable username (noten el valor del atributo "ConversionPattern"):
<code xml>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="console" class="org.apache.log4j.ConsoleAppender">
<param name="Target" value="System.out"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{ISO8601} [%X{username}] %c - %m%n"/>
</layout>
</appender>

<root>
<priority value ="debug" />
<appender-ref ref="console" />
</root>

</log4j:configuration>
</code>

== Modificar log4j en ejecución ==
Utilizando un listener de spring se puede configurar la ruta del archivo log4j.properties (fuera del empaquetado) y el tiempo en que se vuelve a leer el mismo, lo cual nos permite modificar sus valores en ejecucion sin necesidad de redeployar la aplicacion.

Para esto se configura dentro del web.xml

<code xml>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>file:/path/log4j.properties</param-value>
</context-param>
<context-param>
<param-name>log4jRefreshInterval</param-name>
<param-value>5000</param-value>
</context-param>
</code>

Un error con el que nos podemos topar al momento de agregar esta configuración e intentar desplegar en Weblogic es el siguiente:

<code xml>Cannot set web app root system property when WAR file is not expanded</code>

Ante este error, la solución es agregar en el weblogic.xml dentro del tag <weblogic-web-app> el siguiente código:

<code xml>
<container-descriptor>
<show-archived-real-path-enabled>true</show-archived-real-path-enabled>
</container-descriptor>
</code>

== Configurar Log4j con Spring ==
Para configurar Log4j con Spring se debe agregar el siguiente bean a la aplicación:

<code xml>
<bean id="log4jInitializer" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="staticMethod" value="org.springframework.util.Log4jConfigurer.initLogging" />
<property name="arguments">
<list>
<value>file:/path/log4j.properties</value>
<value>1000</value>
</list>
</property>
</bean>
</code>

En el bean se esta indicando la ruta desde la cual se va a tomar el log4j.properties y el intervalo de refresco, el cual nos permite modificar sus valores en ejecucion sin necesidad de redeployar la aplicacion.

==Ver también==
* [http://logging.apache.org/log4j Web oficial de Log4J]
* [http://logging.apache.org/log4j/docs/api/org/apache/log4j/spi/LoggingEvent.html Javadoc del LogginEvent]
* [http://www.slideshare.net/Emmerson_Miranda/log4j-1215-short-manual Introducción a Log4j]
* [http://books.google.com.ar/books?id=vHvY008Zq-YC&pg=PA158&lpg=PA158&dq=weblogic+same+class+loader+log4j&source=bl&ots=yh8Z3e1X7C&sig=x81fCioIEn5nGAZNRg8kLNcOk0Y&hl=es&ei=x267Sum5HprKtgfD1NXEDQ&sa=X&oi=book_result&ct=result&resnum=7#v=onepage&q=weblogic%20same%20class%20loader%20log4j&f=false Pro Apache Log4j]
* [[SLF4J]]

Log4J

2012-07-02T20:07:52Z

Admin: /* Ver también */

Java

2012-07-02T20:07:32Z

Admin: /* Cuestiones generales de Java */

[[Category:Java]]
Java es un lenguaje de programación, aunque también se suele hacer referencia con este nombre a toda una plataforma para el desarrollo de aplicaciones. Hay un buen [http://es.wikipedia.org/wiki/Java_%28Sun%29 resumen de Java en la wikipedia].

Al desarrollar un sistema se suele basar en una [[Arquitectura De Software]] para crear los componentes.

Java se caracteriza por una enorme cantidad de proyectos libres.

== Algunas tecnologías Java ==
=== Frameworks de base===
* [[Spring Framework]]
* [[Terracotta]]
* [[EJB]]
* [[Restlet]]

===Acceso a datos===
* [[Hibernate]]
* [[Apache Lucene]]

===Frameworks de presentación===
* [[Apache Tiles]]
* [[Struts]]
* [[JSF]]
* [[JSTL]]
* [[GWT]]

===Librerías===
* [[Google Guava]]
* [[Jawr]]

===Mensajeria===
* [[JMS]]

===Web Services===
* [[Web Service]]
* [[Web Service Con Spring]]

===Ejecuciones batch y programadas===
* [[Quartz]]
* [[Spring Batch]]

===Cuestiones generales de Java===
* [[Fechas En Java]]
* [[Numeros En Java]]
* [[Encoding En Java]]
* [[Serializacion De Objetos En Java]]
* [[Log4J]]
* [[Slf4J]]
* [[Cache De Objetos Java]]
* [[Exportacion Hacia Archivos]]

Apache Tiles

2012-06-11T14:32:33Z

Admin: /* 2. Actualizar la configuración del web.xml */

[[Apache Tiles]] es un framework de template para simplificar el desarrollo de interfaces de usuario. Tiles permite definir ''fragmentos'' y crear páginas que se ensamblan en tiempo de ejecución con estos fragmentos.

== Configuración rápida de Apache Tiles 3.0 ==
Configurar Apache Tiles 3.0 para un sitio web consiste de estos pasos básicos:
# Agregar las librerias de Tiles al proyecto.
# Crear el archivo de configuración ''tiles.xml''' con las definiciones de las páginas.
# Configurar el listener de Tiles en el archivo web.xml para que levante la configuración del punto 2.
# Configurar un Servlet que atienda peticiones y cree las páginas a partir de las definiciones del punto 2.

=== 1. Configurar las librerias de Tiles ===
Usando Maven, incluir 3 dependencias:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Configurar tiles.xml ===
Crear un archivo '''WEB-INF/tiles.xml''' en la aplicación web. El siguiente archivo tiene una definición de ejemplo agregada.

<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.1//EN"
"http://tiles.apache.org/dtds/tiles-config_2_1.dtd">
<tiles-definitions>

<definition name="prueba/holamundo" template="/WEB-INF/layouts/default.jsp">
<put-attribute name="titulo" value="Un hola mundo con Tiles" />
<put-attribute name="menu" value="/WEB-INF/jsp/menu.jsp" />
<put-attribute name="body" value="/WEB-INF/jsp/holamundo.jsp" />
</definition>
</tiles-definitions>
</code>

==== La definición del template ====
El ejemplo anterior hace referencia a un template, que contiene la estructura de la página. El template tiene lugares (placeholders) donde se ubican los fragmentos. Un template de ejemplo podría ser:

<code xml>
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<html>
<head>
<title><tiles:getAsString name="title"/></title>
</head>
<body>
<div class="lateral"><tiles:insertAttribute name="menu"/></div>
<div class="principal"><tiles:insertAttribute name="body"/></div>
</body>
</html>
</code>

=== 3. Configurar el listener de Tiles ===
En el archivo '''web.xml''' configurar el listener de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 4. Configurar un servlet que atienda peticiones ===
Tiles brinda integración con varios frameworks de presentación (como Struts, Spring, Shale, Velocity y otros). También provee de un Servlet muy sencillo que atiende las peticiones y renderiza directo la definición asociada.

La configuración de este Servlet se hace en el archivo ''web.xml'':
<code xml>
<servlet>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<servlet-class>org.apache.tiles.web.util.TilesDispatchServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<url-pattern>*.tiles</url-pattern>
</servlet-mapping>
</code>

Con esta configuración puede desplegarse la aplicación. La petición "prueba/holamundo.tiles" será atendida por este servlet, y aplicada la definición en ''tiles.xml''.

== Migrar de Tiles 2.2 a Tiles 3.0 ==
La migración de Tiles 2.2 a Tiles 3.0 es sencilla e involucra los siguienets pasos:

# Actualizar los JAR
# Actualizar la configuración del web.xml
# Actualizar los tags en los templates
# Actualizar el DTD de tiles.xml (opcional)

=== 1. Actualizar los JAR ===
Tiles 3.0 necesita de 3 JAR para funcionar. Usando [[Maven]]:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Actualizar la configuración del web.xml ===
Tiles 2.2 usaba un listener simple para levantar la configuración de Tiles, llamado ''org.apache.tiles.web.startup.simple.SimpleTilesListener''. Esta clase sigue existendo en Tiles 3, pero no parece funcionar correctamente ([https://issues.apache.org/jira/browse/TILES-553 confirmado como bug]). La solución es reemplazar el listener por el nuevo de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 3. Actualizar los tags en los templates ===
Los templates usan los taglib de Tiles para insertar definiciones. En particular, en Tiles 3 dejó de existir el tag '''tiles:useAttribute''' el cual es reemplazado por el tag '''tiles:importAttribute'''.

=== 4. Actualizar el DTD de tiles.xml (opcional) ===
Por último, el archivo '''tiles.xml''' tiene un nuevo DTD, el cual se puede actualizar. Este paso es opcional, ya que Tiles 3 funciona con la configuración de Tiles 2.

El nuevo encabezado para los archivos de definición de tiles (tiles.xml y demás) es:
<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
"http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
</code>

== Ver también ==
* [http://tiles.apache.org Página oficial de Apache Tiles]

Apache Tiles

2012-06-11T14:32:01Z

Admin: /* 2. Actualizar la configuración del web.xml */

[[Apache Tiles]] es un framework de template para simplificar el desarrollo de interfaces de usuario. Tiles permite definir ''fragmentos'' y crear páginas que se ensamblan en tiempo de ejecución con estos fragmentos.

== Configuración rápida de Apache Tiles 3.0 ==
Configurar Apache Tiles 3.0 para un sitio web consiste de estos pasos básicos:
# Agregar las librerias de Tiles al proyecto.
# Crear el archivo de configuración ''tiles.xml''' con las definiciones de las páginas.
# Configurar el listener de Tiles en el archivo web.xml para que levante la configuración del punto 2.
# Configurar un Servlet que atienda peticiones y cree las páginas a partir de las definiciones del punto 2.

=== 1. Configurar las librerias de Tiles ===
Usando Maven, incluir 3 dependencias:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Configurar tiles.xml ===
Crear un archivo '''WEB-INF/tiles.xml''' en la aplicación web. El siguiente archivo tiene una definición de ejemplo agregada.

<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.1//EN"
"http://tiles.apache.org/dtds/tiles-config_2_1.dtd">
<tiles-definitions>

<definition name="prueba/holamundo" template="/WEB-INF/layouts/default.jsp">
<put-attribute name="titulo" value="Un hola mundo con Tiles" />
<put-attribute name="menu" value="/WEB-INF/jsp/menu.jsp" />
<put-attribute name="body" value="/WEB-INF/jsp/holamundo.jsp" />
</definition>
</tiles-definitions>
</code>

==== La definición del template ====
El ejemplo anterior hace referencia a un template, que contiene la estructura de la página. El template tiene lugares (placeholders) donde se ubican los fragmentos. Un template de ejemplo podría ser:

<code xml>
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<html>
<head>
<title><tiles:getAsString name="title"/></title>
</head>
<body>
<div class="lateral"><tiles:insertAttribute name="menu"/></div>
<div class="principal"><tiles:insertAttribute name="body"/></div>
</body>
</html>
</code>

=== 3. Configurar el listener de Tiles ===
En el archivo '''web.xml''' configurar el listener de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 4. Configurar un servlet que atienda peticiones ===
Tiles brinda integración con varios frameworks de presentación (como Struts, Spring, Shale, Velocity y otros). También provee de un Servlet muy sencillo que atiende las peticiones y renderiza directo la definición asociada.

La configuración de este Servlet se hace en el archivo ''web.xml'':
<code xml>
<servlet>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<servlet-class>org.apache.tiles.web.util.TilesDispatchServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<url-pattern>*.tiles</url-pattern>
</servlet-mapping>
</code>

Con esta configuración puede desplegarse la aplicación. La petición "prueba/holamundo.tiles" será atendida por este servlet, y aplicada la definición en ''tiles.xml''.

== Migrar de Tiles 2.2 a Tiles 3.0 ==
La migración de Tiles 2.2 a Tiles 3.0 es sencilla e involucra los siguienets pasos:

# Actualizar los JAR
# Actualizar la configuración del web.xml
# Actualizar los tags en los templates
# Actualizar el DTD de tiles.xml (opcional)

=== 1. Actualizar los JAR ===
Tiles 3.0 necesita de 3 JAR para funcionar. Usando [[Maven]]:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Actualizar la configuración del web.xml ===
Tiles 2.2 usaba un listener simple para levantar la configuración de Tiles, llamado ''org.apache.tiles.web.startup.simple.SimpleTilesListener''. Esta clase sigue existendo en Tiles 3, pero no parece funcionar correctamente ([https://issues.apache.org/jira/browse/TILES-553 confirmado como bug]. La solución es reemplazar el listener por el nuevo de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 3. Actualizar los tags en los templates ===
Los templates usan los taglib de Tiles para insertar definiciones. En particular, en Tiles 3 dejó de existir el tag '''tiles:useAttribute''' el cual es reemplazado por el tag '''tiles:importAttribute'''.

=== 4. Actualizar el DTD de tiles.xml (opcional) ===
Por último, el archivo '''tiles.xml''' tiene un nuevo DTD, el cual se puede actualizar. Este paso es opcional, ya que Tiles 3 funciona con la configuración de Tiles 2.

El nuevo encabezado para los archivos de definición de tiles (tiles.xml y demás) es:
<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
"http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
</code>

== Ver también ==
* [http://tiles.apache.org Página oficial de Apache Tiles]

Apache Tiles

2012-06-08T13:18:19Z

Admin: /* Ver también */

[[Apache Tiles]] es un framework de template para simplificar el desarrollo de interfaces de usuario. Tiles permite definir ''fragmentos'' y crear páginas que se ensamblan en tiempo de ejecución con estos fragmentos.

== Configuración rápida de Apache Tiles 3.0 ==
Configurar Apache Tiles 3.0 para un sitio web consiste de estos pasos básicos:
# Agregar las librerias de Tiles al proyecto.
# Crear el archivo de configuración ''tiles.xml''' con las definiciones de las páginas.
# Configurar el listener de Tiles en el archivo web.xml para que levante la configuración del punto 2.
# Configurar un Servlet que atienda peticiones y cree las páginas a partir de las definiciones del punto 2.

=== 1. Configurar las librerias de Tiles ===
Usando Maven, incluir 3 dependencias:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Configurar tiles.xml ===
Crear un archivo '''WEB-INF/tiles.xml''' en la aplicación web. El siguiente archivo tiene una definición de ejemplo agregada.

<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 2.1//EN"
"http://tiles.apache.org/dtds/tiles-config_2_1.dtd">
<tiles-definitions>

<definition name="prueba/holamundo" template="/WEB-INF/layouts/default.jsp">
<put-attribute name="titulo" value="Un hola mundo con Tiles" />
<put-attribute name="menu" value="/WEB-INF/jsp/menu.jsp" />
<put-attribute name="body" value="/WEB-INF/jsp/holamundo.jsp" />
</definition>
</tiles-definitions>
</code>

==== La definición del template ====
El ejemplo anterior hace referencia a un template, que contiene la estructura de la página. El template tiene lugares (placeholders) donde se ubican los fragmentos. Un template de ejemplo podría ser:

<code xml>
<%@ taglib uri="http://tiles.apache.org/tags-tiles" prefix="tiles" %>
<html>
<head>
<title><tiles:getAsString name="title"/></title>
</head>
<body>
<div class="lateral"><tiles:insertAttribute name="menu"/></div>
<div class="principal"><tiles:insertAttribute name="body"/></div>
</body>
</html>
</code>

=== 3. Configurar el listener de Tiles ===
En el archivo '''web.xml''' configurar el listener de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 4. Configurar un servlet que atienda peticiones ===
Tiles brinda integración con varios frameworks de presentación (como Struts, Spring, Shale, Velocity y otros). También provee de un Servlet muy sencillo que atiende las peticiones y renderiza directo la definición asociada.

La configuración de este Servlet se hace en el archivo ''web.xml'':
<code xml>
<servlet>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<servlet-class>org.apache.tiles.web.util.TilesDispatchServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Tiles Dispatcher Servlet</servlet-name>
<url-pattern>*.tiles</url-pattern>
</servlet-mapping>
</code>

Con esta configuración puede desplegarse la aplicación. La petición "prueba/holamundo.tiles" será atendida por este servlet, y aplicada la definición en ''tiles.xml''.

== Migrar de Tiles 2.2 a Tiles 3.0 ==
La migración de Tiles 2.2 a Tiles 3.0 es sencilla e involucra los siguienets pasos:

# Actualizar los JAR
# Actualizar la configuración del web.xml
# Actualizar los tags en los templates
# Actualizar el DTD de tiles.xml (opcional)

=== 1. Actualizar los JAR ===
Tiles 3.0 necesita de 3 JAR para funcionar. Usando [[Maven]]:
<code xml>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-servlet</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-jsp</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-extras</artifactId>
<version>3.0.0</version>
</dependency>
</code>

=== 2. Actualizar la configuración del web.xml ===
Tiles 2.2 usaba un listener simple para levantar la configuración de Tiles, llamado ''org.apache.tiles.web.startup.simple.SimpleTilesListener''. Esta clase sigue existendo en Tiles 3, pero no parece funcionar correctamente. La solución es reemplazar el listener por el nuevo de Tiles 3:
<code xml>
<listener>
<listener-class>org.apache.tiles.extras.complete.CompleteAutoloadTilesListener</listener-class>
</listener>
</code>

=== 3. Actualizar los tags en los templates ===
Los templates usan los taglib de Tiles para insertar definiciones. En particular, en Tiles 3 dejó de existir el tag '''tiles:useAttribute''' el cual es reemplazado por el tag '''tiles:importAttribute'''.

=== 4. Actualizar el DTD de tiles.xml (opcional) ===
Por último, el archivo '''tiles.xml''' tiene un nuevo DTD, el cual se puede actualizar. Este paso es opcional, ya que Tiles 3 funciona con la configuración de Tiles 2.

El nuevo encabezado para los archivos de definición de tiles (tiles.xml y demás) es:
<code xml>
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
"http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
</code>

== Ver también ==
* [http://tiles.apache.org Página oficial de Apache Tiles]

Apache Tiles

2012-06-08T13:11:16Z

Admin: /* La definición del template */

Apache Tiles

2012-06-08T13:10:48Z

Admin: /* La definición del template */

Apache Tiles

2012-06-08T13:05:40Z

Admin: Página creada con 'Apache Tiles es un framework de template para simplificar el desarrollo de interfaces de usuario. Tiles permite definir ''fragmentos'' y crear páginas que se ensamblan en t…'

Java

2012-06-08T12:05:32Z

Admin: /* Frameworks de presentación */

[[Category:Java]]
Java es un lenguaje de programación, aunque también se suele hacer referencia con este nombre a toda una plataforma para el desarrollo de aplicaciones. Hay un buen [http://es.wikipedia.org/wiki/Java_%28Sun%29 resumen de Java en la wikipedia].

Al desarrollar un sistema se suele basar en una [[Arquitectura De Software]] para crear los componentes.

Java se caracteriza por una enorme cantidad de proyectos libres.

== Algunas tecnologías Java ==
=== Frameworks de base===
* [[Spring Framework]]
* [[Terracotta]]
* [[EJB]]
* [[Restlet]]

===Acceso a datos===
* [[Hibernate]]
* [[Apache Lucene]]

===Frameworks de presentación===
* [[Apache Tiles]]
* [[Struts]]
* [[JSF]]
* [[JSTL]]
* [[GWT]]

===Librerías===
* [[Google Guava]]
* [[Jawr]]

===Mensajeria===
* [[JMS]]

===Web Services===
* [[Web Service]]
* [[Web Service Con Spring]]

===Ejecuciones batch y programadas===
* [[Quartz]]
* [[Spring Batch]]

===Cuestiones generales de Java===
* [[Fechas En Java]]
* [[Numeros En Java]]
* [[Encoding En Java]]
* [[Serializacion De Objetos En Java]]
* [[Log4J]]
* [[Cache De Objetos Java]]
* [[Exportacion Hacia Archivos]]

Información del build con Maven

2012-03-30T13:37:56Z

Admin: /* Ver también */

Usando [[Maven]] es posible obtener información del build para ser usada en tiempo de ejecución. La idea general es guardar esta información (hora del build, versión del repositorio de código, etc.) en un archivo de texto, que luego la aplicación puede usar en tiempo de ejecución.

Durante el build, Maven permite filtrar los archivos de recursos y reemplazar placeholders con valores de variables de Maven. De esta manera, la estrategia será crear un archivo .properties con placeholders, que luego Maven se encargará de reemplazar al momento de hacer el build.

== Ejemplo de uso ==
Vamos a usar un archivo projectInfo.properties que tendrá información general del build e información sobre los fuentes en el SVN.

=== El archivo projectInfo.properties ===
Este archivo de propiedades está ubicado junto al resto de los recursos del proyecto, para que sea accesible en tiempo de ejecución por la aplicación.

<code ini>
project.version=${pom.version}
project.build.date=${project.build.timestamp}

project.svn.repository=${project.svn.repository}
project.svn.path=${project.svn.path}
project.svn.revision=${project.svn.revision}
project.svn.mixedRevisions=${project.svn.mixedRevisions}
project.svn.committedRevision=${project.svn.committedRevision}
project.svn.committedDate=${project.svn.committedDate}
project.svn.status=${project.svn.status}
project.svn.specialStatus=${project.svn.specialStatus}
</code>

=== Configuración de Maven ===
Es necesario configurar Maven, con los siguientes pasos:
# Activar el filtrado de recursos, para que cambie los placeholders.
# Activar el módulo de información de SVN.
# Crear una variable explícita con la hora del build, por un bug en Maven.

El archivo pom.xml queda:
<code xml>
<project>

...

<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>

...

<plugin>
<groupId>com.google.code.maven-svn-revision-number-plugin</groupId>
<artifactId>maven-svn-revision-number-plugin</artifactId>
<version>1.7</version>
<executions>
<execution>
<goals>
<goal>revision</goal>
</goals>
</execution>
</executions>
<configuration>
<entries>
<entry>
<prefix>project.svn</prefix>
</entry>
</entries>
</configuration>
</plugin>
</plugins>
</build>

<properties>
<project.build.timestamp>${maven.build.timestamp}</project.build.timestamp>
<maven.build.timestamp.format>yyyy-MM-dd HH:mm</maven.build.timestamp.format>
</properties>
</project>
</code>

=== Ejecución y resultado final ===
Al ejecutar el build se filtrará el archivo projectInfo.properties y se llenarán los valores. Este archivo quedará empaquetado en el resultado final de la siguiente manera. Por ejemplo:
<code ini>
project.version=1.0
project.build.date=2012-03-28 04:07

project.svn.repository=https://100.200.0.100/svn/dosideas
project.svn.path=trunk/dosideas
project.svn.revision=598
project.svn.mixedRevisions=false
project.svn.committedRevision=598
project.svn.committedDate=2012-03-27 13:07:14 +1200 (Tue, 27 Mar 2012)
project.svn.status=M
project.svn.specialStatus=M
</code>

=== Uso en un JSP ===
Teniendo este archivo, es muy facil usar esta información en un JSP:
<code java>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<fmt:setBundle basename="projectInfo"/>

<h1>Informacion del build</h1>
<p>Fecha del build: <fmt:message key="project.build.date"/></p>
<p>Revision: <fmt:message key="project.svn.revision"/></p>
<p>Fecha de la Revision: <fmt:message key="project.svn.committedDate"/></p>
</code>

== Ver también ==
* [[Maven]]
* [http://java.dzone.com/tips/stamping-version-number-and Stamping version number with Maven]
* [http://maven-svn-revision-number-plugin.googlecode.com/svn/site/examples/resource_filtering.html Maven SVN Revision plugin]
* [http://www.innovationontherun.com/creating-a-build-number-with-ant-and-subversion/ Creating a Build Number With Ant and Subversion]
* [http://obscuredclarity.blogspot.com.ar/2010/08/java-ant-build-war-file-with-auto.html Java Ant - Build .War file with Auto-Incrementing Build Number]

Información del build con Maven

2012-03-29T18:40:40Z

Admin: /* Configuración de Maven */

Información del build con Maven

2012-03-29T18:31:21Z

Admin:

Información del build con Maven

2012-03-29T18:22:16Z

Admin: Página creada con 'Usando Maven es posible obtener información del build para ser usada en tiempo de ejecución. La idea general es guardar esta información (hora del build, versión del rep…'

Maven

2012-03-29T18:02:05Z

Admin: /* Ver también */

[[Category:Java]]
Maven es una herramienta software para la gestión y comprensión de proyectos [[Java]].

La versión 2 usa un archivo de configuración en XML llamado '''pom.xml'''. Su funcionalidad es parecida a Apache [[Ant]] de manera que permite compilar, ejecutar test o realizar distribuciones pero con la diferencia que trata de forma automática las dependencias del proyecto. Una de las más importantes características es su actualización en línea mediante servidores repositorios. Maven es capaz de descargar nuevas actualizaciones de las bibliotecas de las que depende el proyecto y de igual manera subir una nueva distribución a un repositorio de versiones, dejandola al acceso de todos los usuarios.

==Diferencias con Ant==
===Declarativo vs. Procedural===
En Ant las acciones a realizar se definen en forma procedural paso por paso, mientras que con Maven se declara que plugins se van a utilizar, con que configuración y con que dependencias y Maven se encarga del orden en el que se utilizan las cosas para lograr el objetivo declarado.

==Conceptos de Maven==
===Dependencias Transitivas (Transitive Dependencies)===
Esto es que las dependencias que declara una dependencia son utilizadas como dependencias propias del POM que se está utilizando.
Ejemplo: si A declara dependencias sobre B y B declara dependencias sobre X e Y, cuando se ejecuten las fases del ciclo de vida de Maven se van a utilizar como dependencias B, X e Y.

===POM ('''P'''roject '''O'''bject '''M'''odel)===
Es un archivo xml llamado pom.xml y ubicado en la raiz de un proyecto (o un módulo) que declara datos sobre el mismo, dependencias y plugins a utilizar durante el ciclo de vida de la administración del proyecto.
[http://maven.apache.org/pom.html]

===Herencia y POM Real (Effective POM)===
Los POMs pueden heredar de otro POM que se defina como parent. La raiz implícita desde donde heredan todos los POMs es el Super POM definido por Maven.
El POM resultante luego de incorporar todos los ancestros se llama Effective POM. Se puede inspeccionar corriendo el goal effective-pom del plugin help parados sobre el directorio donde se encuentra el pom en cuestión.
<code>mvn help:effective-pom</code>

===Goal===
Los Goals de Maven son las unidades mínimas de ejecución de las que disponemos durante su uso. Los goals pueden programarse en diferentes lenguajes pero en la práctica están la mayoría programados en Java. No es común que como usuario se piense en programar un goal. Un grupo de goals conforman un plugin. La ejecución de un goal se dispara desde línea de comandos invocando Maven con el nombre del plugin que lo contiene: <code>mvn plugin:goal</code>.
Otra forma de invocar un goal es indirectamente declarando por ejemplo el uso de un plugin en un POM. Maven lo invocará dependiendo de la fase del ciclo de vida cuando por ejemplo se ejecute <code>mvn compile</code>

===Dependencia (Dependency)===
Maven maneja todas las necesidades de conseguir artefactos (libs, jars, ears, zips, etc.) mediante las dependencias ubicando cada dependencia mediante las coordenadas.

===Grupo (Group)===
El grupo es simplemente una forma de agrupar artefactos bajo una denominación común. La identificación del grupo es groupId. El nombre suele ser el nombre de la organización, el projecto o el equipo de trabajo o bien la raiz del package de java que contendrá las clases del artefacto, ej: com.xyz.foo. Lo importante es recordar que el groupId forma parte de las coordenadas de Maven con la que se identifican en forma única los artefactos en las dependencias y los repositorios.

===Artefacto (Artifact)===
Maven utilza el término artifact para denominar a la unidad mínima que maneja en su repositorio. Puede ser por ejemplo un jar, un ear, un zip, etc. Cuando Maven compila y empaqueta código, produce también artifacts que instala en el repositorio.
Los artifacts están agrupados bajo el id de grupo (groupId) y tienen un id propio (artifactId), una versión, un clasificador y una extensión.
Para administrar los artefactos en el repositrio Maven los acompaña con un respectivo pom.xml conteniendo los datos anteriores.

===Repositorio (Repository)===
El_ funcionamiento de Maven se basa en el uso de un repositorio a donde ir a buscar las dependencias. La identificación de los artefactos que necesita se hace a través del sistema de coordenadas ''groupId:artifactId:version'' que asegura que cada dependencia sea única y proveer una ruta para conseguirla.

El repositorio por default es el repositorio central de Maven. A este repositorio se suman otros repositorios, un respositorio local y la posiblidad de utilizar un repositorio/proxy.

Cuando Maven sale a buscar y consigue una dependencia la guarda en el repositorio local que es un directorio en la máquina del usuario (~/.m2/repository). Las siguientes veces que necesite esta dependencia irá la conseguirá en el directorio local haciéndolo mucho más rápido que la primera vez.

El directorio central y los directorios de terceros en lo único que se diferencian es en que se va a encontrar en cada uno. En el repositorio central de Maven podemos esperar encontrar la mayoría de las dependencias que necesitemos como JUnit, Maven mismo, Java, Spring, Hibernate, etc.

El repositorio/proxy es un servicio que podemos instalar en la LAN para cumplir una función similar a la del repositorio local pero compartido por un grupo de usuarios. Esto, además de mejorar la performance, permite tener un mayor control de las versiones de dependencias que se utilizarán.

===Coordenadas (Coordinates)===
Las coordenadas de Maven es la forma de identificar a un projecto, dependencia, plugin o artefacto en forma única en un pom y en un repositorio. Una coordenada se compone de los siguientes identificadores: ''groupId:artefactId:version''.

A veces es necesario generar dos empaquetados distintos de una misma versión por cuestiones técnicas, por ejemplo un mimso artefacto para correr sobre dos entornos diferentes. En esta situación se puede utilizar un identificador más: ''groupId:artefactId:version:classifier''.

Al momento de producir artefactos, estos cuatro identificadores funcionan en conjunto con uno más, pero que no forma parte de la coordenada: ''packaging'' y que se refiere al tipo de empaquetado del artefacto (ejs: zip, jar, ear). De hecho no es posible tener en el repositorio dos artefactos de la misma versión pero con diferente empaquetado.

* '''groupId''' nombre bajo el que se agrupan una serie de artefactos (ej: junit, spring, org.xyx, com.tm.projectox').

* '''artifactId''' identificacion de la unidad mínima administrada por el repositorio (ej: junit, moduloEjb, ejb-api, servlet-api).

* '''version''' la versión del artefacto con la siguiente nomenclatura ''<major version>.<minor version>.<incremental version>-<qualifier>''.

* '''classifier''' clasificador que permite diferenciar iguales versiones pero preparadas o compiladas para diferentes entornos.

* '''packaging''' no forma parte de la coordenada y sólo se utiliza al momento de generar un artefacto. Define el formato del empaquetado (ejs: jar, war, zip, pom).

===MOJO ('''M'''aven Plain '''O'''ld '''J'''ava '''O'''bject)===
MOJO es el término que utiliza Maven para referirse a un artefacto que representa un Goal. El término parte de un juego de palabras entre POJO (Plain Old Java Object, clases simples sin imposiciones de un framework) y Mojo (un hechizo mágico que se hace típicamente envolviendo ciertos elementos en un paño rojo). Maven hacen al término MOJO extensivo también a goals programados en otros lenguajes.

Para programar un Goal utilizando Java como lenguaje, basta con escribir una clase que haga lo que se necesita hacer con la única imposición de implementar una interfase. El resto de la configuración va en un descriptor en xml. Luego solo resta empaquetarlo con la ayuda del propio Maven y publicarlo en algún repositorio.

===Plugin===
Un Plugin es un conjunto de Mojos (Goals) junto con una descripción y configuración en un xml. Los plugins pueden instalarse y distribuirse mediante los repositorios. Los goals de los plugins pueden utilizarse desde línea de comando: '''mvn plugin:goal''' o declarándolo en el pom en la sección ''<plugins/>'' con el tag ''<plugin//>''.

===Ciclo de Vida (Lifecycle)===
Maven utiliza el concepto de cilcos de vida para ejecutar una secuencia ordenada de pasos denominados fases. El ciclo de vida más común y el usado por defecto por Maven es el de ''build''.

Este ciclo de vida define la secuencia de fases que va desde validar la integridad hasta el despliegue en su instalación final de un proyecto. Cuando se solicita la ejecución de una fase Maven ejecuta primero todas las fases anteriores siguiendo la secuencia y termina en la fase solicitada.

Cuando la ejecución llega a una determinada fase, Maven busca los plugins que estén adjuntados a la misma y ejecuta los goals correspondientes. Pueden existir ninguno o más plugins asociados a una fase.

Las fases en sí sólo definen un concepto en forma vaga y no ejecutan código sino que son anclajes para adjuntar los goals de los plugins para que se ejecuten en el momento apropiado.

Para pedirle a Maven que ejecute los goals asociados hasta un determinado punto en el ciclo de vida se ejecuta ''mvn phase'' donde phase es alguna de las fases del ciclo de vida en cuestión, por ejemplo ''mvn package'' ejecutará la secuencia de phases desde testing, pasando por compilación y terminando en el empaquetado de los artefactos. En esta secuencia pasa por una veintena de fases.

===Arquetipo (Archetype)===
La descripción y administración de un proyecto con Maven requiere que el proyecto tenga una estructura determinada y que tenga los pom.xml correspondientes. Existe un plugin en Maven que permite generar la estructura y configuración inicial de un proyecto a partir de una plantilla. Estas plantillas con llamadas archetypes (arquetipos) y el plugin que permite la generación a partir de los arquitipos se llama también archetype.

Un arquetipo consta de un directorio resources que contiene todos los archivos y directorios que contendrá el proyecto generado y un descriptor en xml.

Los arquetipos pueden publicarse en un repositorio al igual que cualquier otro artefacto.

===Perfiles (Profiles)===
Maven está diseñado para maximizar la portabilidad de los artefactos.
Es posible redefinir prácticamente cualquier parte de un POM definiendo un perfil. Pueden definirse varios perfiles. La activación de un perfil puede dispararse por uno o una combinación de las siguientes evaluaciones:
* Existencia o inexistencia de un archivo
* Sistema operativo
* Variables de entorno del sistema operativo
* Inexistencia de variables de entorno del sistema operativo

Para más información, ver [[Perfiles en Maven]]

===Propiedades (Properties)===
Las propiedades son valores que pueden ser accedidos en cualquier lugar del pom donde se espera un valor envolviendo la propiedad en ${}, ej: ${project.groupId}.
Existen algunas propiedades preestablecidas:
* ${project.*} para acceder a cualquier valor definido en el POM
* ${parent.*} para acceder a los valores de un POM ancestro
* ${settings.*} para acceder a valores definidos en ~/.m2/settings.xml
* ${env.*} variables de entorno
* ${x.y.z} para acceder a valores que desde Java se acceden con System.getProperty("x.y.z")
* ${x.y.z} para acceder a propiedades declaradas en el POM por el usuario en forma <properties><x.y.z>value</x.y.z></properties>

Properties en Maven2[[http://docs.codehaus.org/display/MAVENUSER/MavenPropertiesGuide]]

===Documentación===

Maven puede generar un sitio con toda la documentación del proyecto, en la que se incluyen la información básica del proyecto y las dependencias del proyecto, además permite la integración con herramientas de Integración Continua, Gestión de problemas, listas de correo asi como la utilización de reportes personalizados mediante la configuración de plugins. Entre esos reportes personalizados se puede incluir:
* Resultado de pruebas unitarias
* Reportes de Checkstyle
* Reportes de PMD
* Reportes de Cobertura
* Reportes de Macker

Para crear dicho site hay que utilizar la siguiente sentencia

mvn site

Nota: para los proyectos multimódulo hay un bug conocido que por no genera correctamente los hipervinculos a la documentación de los submodulos.
Sin embargo, existe el siguiente workaround

mvn site:stage -DstagingDirectory=<directorio destino>

==Snippets==
===POM Mínimo===
Este es el mínimo posible POM. Verifica, testea, compila y empaqueta un proyecto Java.
<code xml>
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>com.blah.foo</groupId>
<artifactId>foobar</artifactId>
<version>1</version>
</project>
</code>

===JUnit===
Para que se utilice JUnit durante los tests:
<code xml>
<dependencies>
...
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.4</version>
<scope>test</scope>
</dependency>
...
</dependencies>
</code>

===Módulos===
Para crear un proyecto con varios módulos es necesario crear un módulo a modo de raíz de los otros módulos que se quieren agrupar. Cada módulo, incluyendo el raíz, deben tener su propio POM.

Módulo raíz:
<code xml>
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>fooBar</groupId>
<version>1.0</version>
<artifactId>fooBar</artifactId>
<packaging>pom</packaging>
<name>project</name>

<modules>
<module>fooModule</module>
</modules>

...

</project>
</code>

Cualquier otro módulo agrupado por el módulo raíz:
<code xml>
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>fooBar</groupId>
<artifactId>fooModule</artifactId>
<packaging>war</packaging>
<name>Foo Module</name>

<parent>
<groupId>fooBar</groupId>
<artifactId>fooBar</artifactId>
<version>1.0</version>
</parent>

...

</project>

</code>

La estructura de los directorios debe ser la siguiente

<code>
+ fooBar
|
|-- pom.xml
|
'-- + fooModule
|
'-- pom.xml
</code>

===Cambiando la versión del compilador===
Para especificar la versión de código fuente y la versión del bytecode generado:
<code xml>
<project>
...
<build>
...
<plugins>
...
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
...
</plugins>
...
</build>
...
</project>
</code>

===EJB===
===servlets===

==Plugins útiles==
===help===
help [http://maven.apache.org/plugins/maven-help-plugin/] es un plugin con 8 goals que asisten durante el uso de Maven:
* active-profiles
* all-profiles
* describe
* effective-pom
* effective-settings
* evaluate
* expressions
* system

====help:active-profiles====
Lista los perfiles que se incluirán evaluando cuáles están activos de la misma manera que se evaluarán al momento de ejecutar alguno de los comandos de ciclo de vida.
<code xml>
mvn help:active-profiles
</code>

====help:all-profiles====
Lista los perfiles disponibles en el proyecto.
<code xml>
mvn help:all-profiles
</code>

====help:describe====
Describe un plugin o un MOJO.
<code xml>
mvn help:describe
</code>

====help:effective-pom====
Muestra el POM que se va a usar después de combinarlo con los defaults de Maven, unificar en el caso de múltiples POMs y seleccionando los perfiles que van a utilizarse.
<code xml>
mvn help:effective-pom
</code>

====help:effective-settings====
Muestra los settings que realmente van a utilizarse
<code xml>
mvn help:effective-settings
</code>

===archetype===
===install===

==Plugins==
* Jar
* War
* Ear
* JUnit
* Distribution: permite meter en un fichero zip todos los archivos del proyecto
* PDF: genera la documentación del proyecto en PDF
* Checkstyle: control de convenciones de codificación Java
* PMD: verificación de reglas de codificación

==Ver también==
* [[Información del build con Maven]]
* [[Automatizacion De Build]]
* [[Spring Roo]]
* [[Instalación de Maven]]
* [[Integración de Maven con IDEs]]
* [[Apache Archiva]]
* [[Plugins de Maven]]
* [[Plugin Maven para Weblogic]]
* [[Plugin Maven para Selenium]]
* [[Como organizar el uso de Maven según la cantidad de personas involucradas]]
* [[Creacion de Arquetipos Personalizados]]
* [http://maven.apache.org/ Web oficial de Maven]
* [http://www.sonatype.com/community/definitive_guide.html Libro en PDF sobre Maven]
* [http://maven.apache.org/guides/MavenQuickReferenceCard.pdf Maven Quick Card Reference]
* [http://maven.apache.org/ref/2.0.9/maven-model/maven.html Modelo de Maven]
* [http://abaddon-gtz.blogspot.com/2010/04/de-maven-ant.html Como hacer buid de Ant desde Maven]
* listado del repositorio central
* listado de plugins oficiales
* proyecto mojo
* plugin para eclipse
* plugin para netbeans
* mailing list de maven

Mock de un WS mediante Spring WS

2012-03-29T17:50:48Z

Admin:

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un Web Service mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:UserProfileCreateRequest xmlns:ns2='http://shekhar.com/usermanagement/schemas'> Shekhar Gulati 27 ";

// Creamos el response que nos responderá el WS
private String response = "<ns2:UserProfileCreateResponse xmlns:ns2='http://shekhar.com/usermanagement/schemas'> user created successfully ";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]

Mock de un WS mediante Spring WS

2012-03-29T17:50:12Z

Admin: /* Introducción */

===Introducción===

En esta página explicaremos de qué forma podemos simular el entorno de un Web Service en memoria, de modo tal de poder realizar un test de componentes contra dicho entorno.

===Requerimientos===

Para mockear un WS mediante Spring WS, necesitaremos agregar a nuestro proyecto los siguientes jars:
* jaxb-api-2.0.jar
* jaxb-impl-2.0.3.jar
* xalan-2.7.1.jar (importante que sea esta versión o superior)
* xmlunit-1.1.jar

===Ejemplo===

Básicamente, el código para crear un test contra dicho entorno será como el siguiente:

<code java>
@RunWith(SpringJUnit4ClassRunner.class)

// indicamos a Spring que levante los archivos de configuración que veremos más adelante
@ContextConfiguration("spring-configuration.xml")
public class ClienteIntegracionTest {

// Creamos el request a enviarle al WS
private String request = "<ns2:UserProfileCreateRequest xmlns:ns2='http://shekhar.com/usermanagement/schemas'> Shekhar Gulati 27 ";

// Creamos el response que nos responderá el WS
private String response = "<ns2:UserProfileCreateResponse xmlns:ns2='http://shekhar.com/usermanagement/schemas'> user created successfully ";

//Inyectamos el WebServiceTemplate
@Autowired
private WebServiceTemplate webServiceTemplate;

// Mockeamos el WebServiceServer
private MockWebServiceServer server;

// Clase nuestra que lo consumirá
@Autowired
private Cliente cliente;

// En el Before levantamos el server pasandole como parámetro al constructor
// el webServiceTemplate
@Before
public void setup() {
server = MockWebServiceServer.createServer(webServiceTemplate);
}

@Test
public void testInvocacionWs() {

// Le damos comportamiento a nuestro WS con el request y el response
// antes configurado
server.expect(RequestMatchers.payload(new StringSource(request))).andRespond(ResponseCreators.withPayload(new StringSource(response)));

cliente.invocarMetodoQueLlamaAlWs();

// Nos aseguramos que el servicio fue invocado
server.verify();
}

}
</code>

Dentro de los archivos de configuración que levante Spring, tendremos que configurarle los siguientes beans:

<code xml>
<bean id="wsTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">

<property name="defaultUri" value="http://localhost:8080/" />
<property name="marshaller" ref="marshaller" />
<property name="unmarshaller" ref="marshaller" />
</bean>

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>

<value>com.dosideas.ejemplo.schemas.ClienteRequest</value>
<value>com.dosideas.ejemplo.schemas.ClienteResponse</value>
</list>
</property>
</bean>
</code>

Finalmente, el método de nuestra clase cliente, deberá contener

<code java>
public void invocarMetodoQueLlamaAlWs() {
...
ClienteRequest clienteRequest = new ClienteRequest();
...
ClienteResponse clienteResponse = (clienteResponse) webServiceTemplate
.marshalSendAndReceive(clienteRequest);
...
}
</code>

====Fuente====
*[http://static.springsource.org/spring-ws/site/reference/html/client.html Spring MVC Test ]

The Core

2012-03-14T19:19:58Z

Admin: Revertidos los cambios de 84.235.45.242 (disc.) a la última edición de 186.18.30.145

[[The Core]] es un conjunto de protocolos y prácticas para la [[Conformación de equipos]] efectivos.

Los protocolos de The Core son "mejores prácticas" para las personas, equipos de personas y organizaciones que quieren obtener grandes resultados - todo el tiempo. Son "Core" (núcleo) porque son fundacionales - pueden ser usados por todos los equipos, en todo lugar, incluso si ya tienen patrones organizaciones y mejores prácticas propias. Son "protocolos" porque nombran y prescriben formas de interacción entre las personas (comportamiento), que resultan predecibles, como los "protocolos" que se usan en la diplomacia.

Entonces, los protocolos de The Core:
* son tácticas que las personas pueden usar para obtener mejores resultados
* los pueden usar individuos, equipos y organizaciones
* son de "[[Software Libre]]" y "versionados" (se mejoran con el tiempo), al igual que el software

Suena interesante, ¿no?

A continuación dejamos una traducción de [http://www.mccarthyshow.com/LearnForFree/BestPracticesTheCoreProtocols/tabid/65/Default.aspx The Core Protocolos v 3.02].
Pueden leer más sobre [[The Core]] en el libro '''Software for your head''', de Jim y Michele McCarthy (ISBN 0-201-60456-6).

== Los protocolos de The Core v 3.02 ==

<small>'''(The Core está distribuido bajo la [http://www.gnu.org/licenses/gpl.txt licencia GNU -PL]. The Core se considera como el código fuente bajo esa licencia. Son libres de usar, distribuir este trabajo o cualquier derivado que hagan, siempre y cuando también distribuyan este documento fuente en forma completa, incluyendo este párrafo).'''</small>

=== Los compromisos de The Core ===
# Me comprometo a estar involucrado cuando estoy presente.
#* A conocer e informar
#** lo que quiero,
#** lo que pienso, y
#** lo que siento.
#* A siempre buscar ayuda efectiva.
#* A no ofrecer y negarme a aceptar transmisiones emocionales incoherentes.
#* Cuando tengo o escucho una mejor idea que la actual, inmediantamente voy a
#** proponerla para una aceptación decisiva o rechazo, y/o
#** explícitamente voy a buscar que se mejore
#* Personalmente voy a apoyar la mejor idea
#** sin importar de quien venga,
#** sin importar cuánto desee que aparezca otra mejor idea más tarde, y
#** cuando no tengo una idea alternativa superior.
# Voy a buscar percibir más de lo que busco ser percibido.
# Voy a usar los equipos, en especial cuando llevo adelante tareas difíciles.
# Voy a hablar siempre y sólo cuando creo que voy a mejorar el ratio general resultado/esfuerzo.
# Voy a ofrecer y aceptar sólo comportamiento y comunicación racional y orientada a resultados.
# Me voy a desinvolucrar de situaciones menos productivas
#* cuando no pueda mantener este compromiso
#* cuando es más importante que me involucre en otro lugar.
# Voy a hacer ahora lo que debe hacerse eventualmente y puede hacerse efectivamente ahora.
# Voy a buscar avanzar hacia un objetivo en particular, llevando mi comportamiento hacia la acción.
# Voy a usar los Protocolos de The Core (o mejores) cuando sea aplicable.
#* Voy a ofrecer y aceptar a tiempo y usar adecuadamente el Protocolo de [[Check-In]]
# No voy a lastimar -ni tolerar que lastimen- a nadie por su fidelidad a estos compromisos.
# No voy a hacer nada tonto a propósito.

=== Pasar (Despasar) ===
El protocolo [[Pasar]] es para declinar la participación en algo. Usalo cada vez que no quieras participar en una actividad.

==== Pasos ====
# Cuando decidís no participar, decí "Paso".
# Podés despasar en cualquier momento que quieras. Despasá ni bien sepas que querés participar otra vez, diciendo "Despaso".

==== Compromisos ====
* Mantener privados los motivos de pasar.
* Pasar en algo ni bien somos conscientes de que vamos a pasar.
* Respetar el decho de los demás a pasar sin explicación.
* No juzgar, avergonazar, molestar, interrogar ni castigar a alguien que pasa.

==== Notas ====
* En general, no vas a estar bien parado frente a los Compromisos de The Core si pasás la mayor parte del tiempo.
* Podés pasar de cualquier actividad; sin embargo, si adoptás los Compromisos de The Core, no podés pasar en un voto de [[Decisión]] y tenés que decir "Estoy presente" al hacer el [[Check-In]].
* Podés pasar aunque ya hayas empezado algo.

=== Check-In ===
Usá el [[Check-In]] para empezar reuniones o en cualquier momento que un Check-In individual o grupal agregue valor a las interacciones del equipo.

==== Pasos ====
# La persona dice "Me siento [uno o más de ENOJADO, TRISTE, CONTENTO, ASUSTADO]". La persona puede dar una breve explicación. O si otros ya hacieron su check-in, la persona puede decir "Paso". (ver el protocolo [[Pasar]]).
# La persona dice "Estoy presente". Esto significa que la persona se comportará de acuerdo a los Compromisos de The Core.
# El resto de las personas responden "Bienvenido".

==== Compromisos ====
* Decir los sentimientos sin adjetivos.
* Decir los sentimientos sólo sin nos pertenecen.
* Estar callados durante el Check-In de otra persona.
* No referirse al Check-In de otra persona sin su permiso explícito para hacerlo.

==== Notas ====
* En el contexto de los Protocolos de The Core, todas las emociones se expresan a través de una combinación de ENOJADO, TRISTE, CONTENTO o ASUSTADO. Por ejemplo, "ansioso" puede ser una combinación de CONTENTO y ASUSTADO.
* Hacer el Check-In lo más profundo posible. Lo normal es hacer el check-in con dos o más emociones. La profundidad del Check-In del grupo se traduce directamente en la calidad de los resultados del grupo.
* No hacer nada por disminuir el estado emocional. No describirnos como "un poquito" enojado, triste, contento o asustado, ni tampoco decir "Estoy enojado, PERO igual estoy contento".
* Excepto en los grupos muy grandes, si más de una persona hace el check-in, es recomendable que todos lo hagan.
* FELIZ puede ser un sustito de CONTENTO, y CON MIEDO puede ser un sustitio de ASUSTADO.

=== Check-Out ===
El [[Check-Out]] requiere que nuestra presencia física siempre signifique nuestro involucramiento. Debemos hacer un Check-Out cuando somos conscientes que no podemos mantener los Compromisos de The Core o cuando es mejor para nosotros estar en otro lugar.

==== Pasos ====
# Decir "Hago un Check-Out".
# Físicamente dejar al grupo hasta que estemos listos para hacer un nuevo Check-In.
# Opcionalmente, si lo sabemos y es relevante, podemos decir cuándo pensamos volver.
# Quienes están presentes al momento del Check-Out no deben seguir a la persona, preguntar o hablar sobre el Check-Out de la persona.

==== Compromisos ====
* Retornar ni bien podamos seguir los Compromisos de The Core.
* Retonar y hacer un Check-In sin llamar la atención por nuestro retorno.
* No juzgar, avergonzar, molestar, interrogar o castigar a nadie que hace un Check-out.

==== Notas ====
* Cuando hacemos un Check-Out hacerlo de la forma más calmada que sea posible, de manera de causar la menor interrupción posible a los demás.
* Hacer un Check-Out si nuestra estado emocional nos impide colaborar, si tenemos una recepción baja a nueva información, o si no sabemos lo que queremos.
* El Check-Out es admitir que no podemos contribuir en ese momento.

=== Pedir ayuda ===
El protocolo de [[Pedir ayuda]] nos permite hacer un uso eficiente de las habilidades y conocimientos de otros. Pedir ayuda es el acto que cataliza la [[Conexión]] y uan [[Visión compartida]]. Debemos usarlo continuamente, antes y durante la búsqueda de cualquier resultado.

==== Pasos ====
# Quien pide le pregunta a otro; "[Nombre de quien ayuda], ¿harías X?".
# Quien pide expresa todas las cosas específicas o restricciones de la petición.
# Quien ayuda responde diciendo "Si" o "No", u ofreciendo una forma alternativa de ayuda.

==== Compromisos ====
* Siempre empezar el Protocolo de Pedir ayuda con la frase "¿harías....?".
* Tener una comprensión clara de lo que queremos que haga quien nos ayuda, o si no tenemos en claro la ayuda que queremos, dejarlo en claro diciendo "No estoy seguro con qué necesito ayuda, ¿me ayudarías?".
* Asumir que todos quienes ayudan están siempre disponibles, y confiar que cada uno de quienes ayudan aceptan la responsabilidad de decir "No".
* Decir "No" cada vez que no querramos ayudar.
* Aceptar la respuesta "No" sin hacer preguntas ni un drama emocional.
* Ser receptivos de la ayuda ofrecida.
* Ofrecer nuestra mejor ayuda incluso aunque no sea lo que está esperando quien pide.
* Postponer el pedido de ayuda si no podemos estar completamente involucrados.
* Pedir más información si no tenemos en claro en qué consiste la ayuda que nos piden.
* No disculparse por pedir ayuda.

==== Notas ====
* Es "barato" pedir ayuda. El peor resultado es un "No", lo que nos deja ni más adelante ni más atrás de antes de pedir. En el mejor escenario, reducimos el tiempo para hacer una tarea y/o aprender.
* Quienes ayudan deben decir "No" si no están seguros de querer ayudar. No deben decir nada más después de negarse.
* No podemos "pedir demasiada ayuda" a una persona, a menos que explícitamente esa persona haya pedido que se respete un límite en particular.
* Si no comprendemos el valor de lo que se ofrece, o sentimos que no sería útil, o creemos que ya consideramos y rechazamos la idea anteriormente, usemos una postura curiosa en vez de rechazar automáticamente con un "pero..." (ver el protocolo [[Investigar]])
* Pedir cuando hay problemas quienes decir que esperamos demasiado tiempo para pedir ayuda. Debemos pedir ayuda cuando nos está yendo bien.
* El simple hecho de conectarnos con alguien, incluso cuando esta persona no sepa nada del tema, pueden ayudarnos a encontrar respuestas dentro de nosotros mismos, especialmente si le pedimos a esa persona que nos Investigue.

=== Comprobación de protocolo ===
Usar la Comprobación de protocolo cuando creemos que se está usando un protocolo de forma incorrecta, o cuando se está rompiendo uno de los Compromisos de The Core.

==== Pasos ====
# Decir "Comprobación de protocolo".
# Si sabemos el uso correcto del protocolo, decirlo. Sino, [[Pedir ayuda]].

==== Compromisos ====
* Decir "Comprobación de protocolo" ni bien seamos conscientes del uso incorrecto de un protocolo, o si se viola alguno de los Compromisos de The Core. Hacerlo sin importar la actividad que se esté llevando a cabo.
* Apoyar a cualquiera que use la Comprobación de protocolo.
* No avergonzar ni castigar a nadie que use la Comprobación de protocolo.
* [[Pedir ayuda]] ni bien nos demos cuenta que no sabemos el uso correcto de un protocolo.

=== Comprobación de intención ===
Usar la [[Comprobación de intención]] para clarificar el propósito de nuestro comportamiento, o el de otros. Usarlo cuando no estamos esperando un resultado positvo del comportamiento actual. La [[Comprobación de intención]] verifica la integridad de la intención propia y de otros en un caso dado.

==== Pasos ====
# Preguntar "¿Cuál es mi/tu intención con X?", donde X es algún tipo de comportamiento actual o pendiente de la persona cuya intención queremos conocer.
# Si resulta útil, preguntar "¿Qué respuesta o comportamiento querés de alguien como consecuencia de X?".

==== Compromisos ====
* Ser consciente de nuestra propia intención antes de comprobar la intención de otros.
* Investigar lo suficiente para descubrir la intención de la persona o de sus acciones.
* Asegurarse de tener la intención de resolver cualquier conflicto de manera pacífica antes de comprobar la intención de otra persona. Si no tenemos una intención pacífica, hacer un [[Check-Out]].
* No ser defensivos cuando alguien nos pregunta cuál es nuestra intención. Si no podemos, hacer un [[Check-Out]].

==== Notas ====
* Si aparece un conflicto que parece irresoluble, hacer un [[Check-Out]] o [[Pedir ayuda]].

=== Decisión ===
Usar [[Decisión]] cada vez que querramos avanzar al equipo de forna inmediata y unánime hacia resultados.

==== Pasos ====
# El proponente dice "Propongo [comportamiento consiso y accionable]".
# El proponente dice "1-2-3".
# Los votantes votan simultáneamente, usando un "Si" (pulgar arriba), "No" (pulgar abajo) o "Lo apoyo" (mano plana).
# Los votantes que no pueden aceptar la propuesta bajo ningún punto de vista deben expresarlo abiertamente diciendo "Mi voto es un no absoluto. No voy a apoyarlo". Si esto ocurre, se retira la propuesta.
# El proponente cuenta los votos.
# El proponente retira la propuesta si la combinación de votos "No" y votos "Lo apoyo" es demasiado grande, o si el proponente no espera concluir con éxito la [[Resolución]] (ver a continuación). Podemos aproximar este "demasiado grande" usando la siguiente heurística:
#* aproximadamente el 50% (o más) de los votos son "Lo apoyo", o
#* la ganancia esperada de la propuesta si fuera aprobada es menor que el costo por el esfuerzo de la [[Resolución]].
# El proponente usa el Protocolo de [[Resolución]] con cada votante "No" para acercarlo a la propuesta, preguntándole "¿Qué sería necesario para que aceptes?".
# El proponente declara aceptada a la propuesta si todos los votos "No" cambian a "Si" o "Lo apoyo".
# El equipo ahora está comprometido a la acción.

==== Compromisos ====
* Proponer no más de un elemento por propuesta.
* Mantenerse presente hasta que esté terminado el protocolo de [[Decisión]]; siempre estar conscientes de cómo nuestro comportamiento afecta al equipo, haciendolo avanzar o poniendo obstáculos.
* Dar nuestra máxima atención a la propuesta por sobre cualquier otra actividad.
* Hablar sólo cuando se es el proponente, o cuando el proponente nos pide hablar.
* Durante el protocolo, no expresar los motivos por los cuales votamos como lo hicimos.
* Revelar inmediatamente cuando somos un votante "No absoluto", y estar listos a proponer una mejor idea.
* Ser personalmente responsable por lograr los resultados del compromiso de la Decisión, incluso aunque haya sido hecha en nuestra ausencia.
* Mantenerse informados sobre los compromisos de una Decisión hechos en nuestra ausencia.
* No discutir con un votante "No absoluto". Siempre pedirle una idea mejor.
* Apoyar activamente las decisiones tomadas.
* Usar la capacidad de "parar el carro" al decir "no me van a convencer sin importar qué pase" con mucha discresión y lo más infrecuentemente posible.
* Insitir todo el tiempo que se sigan los protocolos de [[Decisión]] y [[Resolución]] tal cual están prescriptos, sin importar cuántas veces nos encontremos insistiendo en esto.
* No [[Pasar]] durante una [[Decisión]].
* Trabajar incesantemente para avanzar; estar enfocados a la acción.
* No mirar cómo votan los demás para elegir nuestro voto.
* Evitar usar el protocolo de [[Decisión]] en grupos grandes. Dividir al grupo grande en pequeños subgrupos para tomar decisiones, y usar el grupo grande para informar el estado.

==== Notas ====
* Votar "No" sólo cuando realmente creemos que nuestra contribución para hacer avanzar al equipo después de detenerlo con nuestro voto supera ampliamente el (en general alto) costo que agregamos por votar "No".
* Si no estamos seguros o confusos por la propuesta, apoyarla y buscar clarificación luego de que la propuesta esté resuelta. Si tenemos una propuesta alternativa después de recibir más información, podemos estar seguros que nuestro equipo apoyará la mejor idea (recordar los Compromisos de The Core).
* Votar "No" para hacer cambios menores a lo que de otra manera es una propuesta aceptable sólo detiene el avance del equipo y debería evitarse. En cambio, ofrecer una propuesta adicional después de aprobar la actual o, mejor aún, involucrarse en la implementación para asegurarnos que nuestra idea se lleva adelante.
* Retirar las propuestas débiles. Si una propuesta recibe menos del 70% (aproximado) de votos "Si", es una propuesta débiles y el proponente debería retirarla. Sin embargo, esta decisión queda a criterio del proponente.
* Cada vez que votemos "No" pensar como si fueramos el único votante no.
* Votar "No absoluto" sólo cuando estemos convencidos de tener una contribución importante para hacer a la dirección o liderazgo del equipo, o cuando la integridad lo requiere absolutamente.

=== Resolución ===
Cuando un voto por [[Decisión]] resulta en una pequeña minoria de disidentes, el proponente lleva rápidamente al equipo, de manera estructurada, a negociar con los disientes. El protocolo de [[Resolución]] promueve que el equipo avance al enfcarse en traer a los disidentes al menor costo.

==== Pasos ====
# El proponente pregunta al disidente "¿Qué sería necesario para que aceptes?"
# El disidente dice la modificación que él requiere, usando una oración única, corta y declarativa.
# El proponente ofrece adoptar los cambios del disidente o descarta la propuesta.

==== Notas ====
* Si los cambios del disidente son simples, basta con realizar un chequeo visual para determinar si todos siguen aceptando la propuesta.
* Si los cambios del disidente son complejos, el proponente debe retirar la propuesta actual y luego crear una nueva propuesta que incluya los cambios del disidente.
* Si el disidente comienza a explicar porqué votó "No" o a explicar cualquier otra cosa que no sea lo necesaria para que acepte, el proponente lo debe interrumpir con "¿Qué sería necesario para que aceptes?".

=== Juego de perfección ===
El protocolo del [[Juego de perfección]] nos apoyará en nuestro deseo de agregar las mejores ideas. Usarlo cada vez que deseamos mejorar algo que creamos.

==== Pasos ====
# El Perfeccionista realiza un acto o presenta un objeto para perfeccionar, opcionalmente diciendo "Empiezo" y "Terminó" para notificar al Perfeccionador el final de la actuación.
# El Perfeccionador califica el valor de la actuación o del objeto en un escala de 1 al 10, basándose en cuánto valor el Perfeccionador cree poder agregar.
# El Perfeccionador dice "Lo que me gusta de la actuación o del objeto X es..." y procede a listar las cualidades del objeto que el Perfeccionador cree que son de alto valor y que deberían amplificarse.
# El Perfeccionador ofrece las mejoras a las actuación o al objeto para obtener la calificación "10" diciendo "Para obtener un diez, deberías hacer X".

==== Compromisos ====
* Aceptar la perfección sin cuestionar.
* Dar sólo comentarios positivos: lo que nos gusta y lo que debería hacerse para "lograr el 10".
* Abstenerse de mencionar lo que no nos gusta, o ser negativo en cualquier otra forma.
* Quitar puntos sólo si podemos pensar en alguna mejora.
* Usar calificaciones que reflejen la escala de mejora en vez de una escala de cuánto nos gustó el objeto.
* Si no podés decir algo de lo que te gustó del objeto o no podés especificar cómo hacer mejor al objeto, tenés que calificar con un "10".

==== Notas ====
* La calificación de "10" significa que no podemos agregar valor, y una calificación de "5" significa que vamos a describir cómo hacer que el objeto sea el doble de bueno.
* La información importante para transmitir en el protocolo del [[Juego de perfección]] mejora a la actuación o al objeto. Por ejemplo, "El sonido idea de un chasquido de dedos para mi es claro, tiene suficiente volumen, y me sorprende. Para obtener un 10, deberías mejorar la claridad".
* Como Perfeccionista, sólo podemos hacer preguntas para clarificar o recolectar más información para mejorar. Si no estás de acuerdo con las ideas que te ofrecen, simplemente no las incluyas.

=== Alineamiento personal ===
El protocolo de [[Alineamiento personal]] ayuda a entrar con profunidad en los deseos y encontrar lo que nos bloquea en obtener lo que queremos. Usarlo para descubrir, articular, y lograr lo que queremos. La calidad del alineamiento será igual a la calidad de nuestros resultados.

==== Pasos ====
# Deseo. Responder a la pregunta: "¿Qué quiero específicamente?".
# Bloqueo. Preguntarnos, "¿Qué me está bloqueando en obtener lo que quiero?".
# Virtud. Averiguar qué podría quitar este bloqueo respondiendo la pregunta "¿Qué virtud -si la tuviera- podría destruir este bloqueo mio?".
# Cambio. Fingir que la virtud que identificamos es en realidad lo que queremos.
# Otra vez. Repetir los pasos 2-4 hasta que este proceso descubra una virtud que sea lo suficientemente poderosa como para destruir los bloqueos y nos obtenga lo que originalmente creíamos querer.
# Listo. Ahora escribí una oración de alineamiento personal de la forma "Quiero [virtud]". Por ejemplo, "Quiero coraje".
# Señal / Respuesta / Asignación. Crear una señal para que otros sepan que estás practicando tu alineamiento, y brindá una respuesta que los demás puedan darte para demostrar su apoyo. Por ejemplo, "Cuando digo/hago X, ¿ustedes podrían decir/hacer Y?". Opcionalmente, convertilo en una asignación al decir que haremos X una cierta cantidad de veces al día, donde X es una actividad que requiere que vivamos nuestro alineamiento.
# Evidencia. Escribí, en términos específicos y medibles, la evidencia a largo plazo de practicar este alineamiento.
# Ayuda. Pedile ayuda a cada miembro del equipo. Ellos ayudan al dar la respuesta que te gustaría cuando des la señal de estar practicando tu alineamiento.

==== Compromisos ====
* Identificar un alineamiento que resultarán en un cambio personal y que no requiere ningún cambio en otra personal.
* Identificar bloqueos y deseos que son específicos y personales.
* Identificar bloqueos que, si se resuelven, radicalmente van a incrementar tu efectividad en la vida, el trabajo y el ocio.
* Elegir una virtud que trata sobre vos y que sea, preferentemente, de una sola palabra. Por ejemplo: integridad, pasión, cuidado personal, paz, diversión.
* Pedir ayuda a las personas que te conozcan y/o conozcan tu alineamiento.
* Identificar evidencia que es medible por una tercera persona, objetiva.

==== Notas ====
* Los alineamientos personales más comunes son "Quiero (integridad, coraje, pasión, paz, cuidado personal, conocimiento personal).
* Si te cuesta averiguar lo que querés, adoptá el alineamiento "conocimiento personal". No hay ningún caso en el que aumentar el conocimiento personal no sea benéfico.
* Un bloqueo personal es algo que encontramos dentro nuestro. No se refiere a circunstancias ni a otras personas. Asumir que ya podríamos haber tenido lo que queremos, que nuestro bloqueo es un mito que de alguna manera nos está privando de nuestro potencial máximo.
* Idealmente, identificá evidencia inmediata y a largo plazo para tu alineamiento. Escribí los resultados que empiezan ahora (o muy pronto) y también los resultados que veremos en cinco o más años en el futuro.
* Como señal predeterminada, decile a tus compañeros u otras personas cercanas que estás trabajando en tu alineamiento cuando lo estás practicando. Si no conocen el protocolo, simplemente contales en qué virtud estás trabajando y pediles ayuda.
* Cuando los miembros del equipo están completando su alineamiento juntos (se piden ayuda entre ellos), el paso final del proceso es más poderoso si se hace como una ceremonia.

=== Investigar ===
[[Investigar]] permite aprender sobre cierto fenónemo que ocurre en alguien. Usalo cuando la idea o comportamiento que alguien presenta parece ser pobre, confuso o simplemente interesante.

==== Pasos ====
# Actuá como si fueras un investigador independiente, pero fascinado, haciendo preguntas hasta que tu curiosidad este satisfecha o hasta que no quieras hacer más preguntas.

==== Compromisos ====
* Realizar preguntas bien formadas.
* Realizar únicamente preguntas que aumentarán tu comprensión.
* Realizar preguntas sólo si el interrogado está comprometido y parece estar listo para responder más.
* Abstenerse de emitir opiniones.
* No realizar preguntas donde crees saber qué es lo que responderá.
* Si no puedes mantenerte como un investigador curioso e independiente, no siguas utilizando el protocolo hasta que puedas volver y mantener estos compromisos.

==== Notas ====
* No sacar teorias sobre el investigado ni dar diagnóstico alguno.
* Considerá utilizar los siguientes tipos de preguntas:
** ¿Que aspecto de X te generan Y Z?
** ¿Puedes darme un ejemplo específico?
** ¿Qué es lo que mas quieres de resolver X?
** ¿Cuál es el problema más grande que ves de X ahora?
** ¿Cuál es la cosa más importante que podés hacer ahora para ayudar con X?
* Las preguntas ineficientes incluyen las siguientes:
** Preguntas que lleven a una agenda de preguntas.
** Preguntas que intenten esconder una respuesta que tu crees verdadera.
** Preguntas que inviten a contar historias.
** Preguntas que comiencen con "Por qué".
* Mantenerse en la intención de obtener mas información.
* Si sientes que vas a explotar si no podés decir lo que tenés en mente, no deberías hablar. Considerá utilizar [[Comprobación de intención]] o [[Check-Out]].

==Ver también==
* [[Conformación de equipos]]
* [http://www.mccarthyshow.com/LearnForFree/BestPracticesTheCoreProtocols/tabid/65/Default.aspx Descargar The Core Protocols en PDF (inglés)]
* [http://ebookee.org/Software-for-Your-Head-Core-Protocols-for-Creating-and-Maintaining-Shared-Vision_768975.html Descargar Software for your head: Core Protocols for Creating and Maintaining Shared Vision]

[[Category: The Core]]

JUnit con bases de datos

2012-02-24T12:34:04Z

Admin: /* La regla de JUnit */

Es muy común tener que integrar [[JUnit]] para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee [[JUnit]] y [[Spring Framework]] para hacer más facil la ejecución de tests contra datos siempre limpios.

== embedded-database de Spring ==
[[Spring Framework]] contiene una utilidad para levantar bases de datos en memoria al momento que se inicializa el factory. De esta forma, podemos inicializar una base y a la vez decirle que ejecute varios scripts, para dejarla preparada y lista para usar.

Un archivo de configuración de ejemplo:
<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd">

<jdbc:embedded-database id="dataSource" type="HSQL" />

<jdbc:initialize-database data-source="dataSource" ignore-failures="NONE">
<jdbc:script location="classpath:tablas.sql" />
<jdbc:script location="classpath:datos.sql "/>
</jdbc:initialize-database>

</beans>
</code>

Esta configuración crea un bean llamada "dataSource" que es un DataSource común, listo para inyectar en nuestra aplicación (y reemplazar así un DataSource real). Este DataSource apunta a una base en memoria HSQLDB, y ejecutarán 2 scripts al momento de inicialización: tablas.sql y datos.sql

== Limpieza del contexto de Spring en los tests ==
Es posible que algún método de test "ensucie" (cambie) el valor de algún bean del factory, lo cual ocasione problemas en tests posteriores. Podemos usar la anotación @DirtiesContext para indicarle a Spring que vuelva a crear un nuevo factory luego de la ejecución del método anotado con esta anotación.

Por ejemplo:

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Test
public void fooTest() { ... }

@Test
@DirtiesContext
public void barTest() { ... }
}
</code>

En este ejemplo, al terminar la ejecución del método barTest() se volverá a crear el factory de Spring (y por lo tanto, se creará una nueva base en memoria). De esta manera el resto de los métodos contarán con un entorno limpio.

== Limpieza de la base de datos con Rules de JUnit ==

En la mayoría de las ocasiones, los métodos @Test no ensucian el contexto de beans de Spring, sino que ensucian los datos de la base de datos (realizando inserts, updates, deletes sobre los mismos). Los métodos posteriores de tests podrían verse afectados por no contar con los datos tal cual se los esperaba.

Una solución es anotar a estos tests que ensucian la base de datos con @DirtiesContext. Esto forzará la creación de un nuevo contexto de Spring, y se recreará la correspondiente base de datos en memoria. Sin embargo, esta solución es relativamente costosa por la continua destrucción/construcción del factory de Spring.

Una solución alternativa será usar un @DirtiesDatabase que sólo recree la base de datos en memoria... sin embargo, Spring no tiene esta utilidad. Por suerte, es muy simple agregarla.

=== @DirtiesDatabase ===
Crearemos una anotación de método que nos permita indicar que un método de @Test ensucia la base de datos, y luego usaremos una Regla de [[JUnit]] para leer esta anotación y hacer la limpiaza necesaria.

==== La anotación ====
La anotación es común:
<code java5>
@Retention(RetentionPolicy.RUNTIME)
public @interface DirtiesDatabase { }
</code>

==== DatabaseRebuilder para reconstruir la base de datos ====
Primero vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
<code java5>
public interface DatabaseRebuilder {
void rebuildDatabase();
}
</code>

Una posible implementación de esta interfaz podría ser invocar a los scripts de inicialización de la base en memoria.

==== La regla de JUnit ====
Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, reconstruye la base de datos. Esta regla usa una instancia de DatabaseRebuilder para hacer la reconstrucción de la base de datos:
<code java5>
public class DirtiesDatabaseRule implements TestRule {

private DatabaseRebuilder rebuilder;

public DirtiesDatabaseRule(DatabaseRebuilder rebuilder) {
this.rebuilder = rebuilder;
}

@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
base.evaluate();
} finally {
DirtiesDatabase dirtiesDatabase = description.getAnnotation(DirtiesDatabase.class);
if (dirtiesDatabase != null) {
rebuilder.rebuildDatabase();
}
}
}
};
}
}
</code>

==== Usando @DirtiesDatabase ====
Listo! Nos queda agregar la regla a la clase de test, y la anotación correspondiente.

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Rule
public DirtiesDatabaseRule dirtiesDatabaseRule = new DirtiesDatabaseRule(new DatabaseRebuilderImpl());

@Test
public void fooTest() { ... }

@Test
@DirtiesDatabase
public void barTest() { ... }
}
</code>

JUnit con bases de datos

2012-02-23T20:50:14Z

Admin: /* La regla de JUnit */

Es muy común tener que integrar [[JUnit]] para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee [[JUnit]] y [[Spring Framework]] para hacer más facil la ejecución de tests contra datos siempre limpios.

== embedded-database de Spring ==
[[Spring Framework]] contiene una utilidad para levantar bases de datos en memoria al momento que se inicializa el factory. De esta forma, podemos inicializar una base y a la vez decirle que ejecute varios scripts, para dejarla preparada y lista para usar.

Un archivo de configuración de ejemplo:
<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd">

<jdbc:embedded-database id="dataSource" type="HSQL" />

<jdbc:initialize-database data-source="dataSource" ignore-failures="NONE">
<jdbc:script location="classpath:tablas.sql" />
<jdbc:script location="classpath:datos.sql "/>
</jdbc:initialize-database>

</beans>
</code>

Esta configuración crea un bean llamada "dataSource" que es un DataSource común, listo para inyectar en nuestra aplicación (y reemplazar así un DataSource real). Este DataSource apunta a una base en memoria HSQLDB, y ejecutarán 2 scripts al momento de inicialización: tablas.sql y datos.sql

== Limpieza del contexto de Spring en los tests ==
Es posible que algún método de test "ensucie" (cambie) el valor de algún bean del factory, lo cual ocasione problemas en tests posteriores. Podemos usar la anotación @DirtiesContext para indicarle a Spring que vuelva a crear un nuevo factory luego de la ejecución del método anotado con esta anotación.

Por ejemplo:

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Test
public void fooTest() { ... }

@Test
@DirtiesContext
public void barTest() { ... }
}
</code>

En este ejemplo, al terminar la ejecución del método barTest() se volverá a crear el factory de Spring (y por lo tanto, se creará una nueva base en memoria). De esta manera el resto de los métodos contarán con un entorno limpio.

== Limpieza de la base de datos con Rules de JUnit ==

En la mayoría de las ocasiones, los métodos @Test no ensucian el contexto de beans de Spring, sino que ensucian los datos de la base de datos (realizando inserts, updates, deletes sobre los mismos). Los métodos posteriores de tests podrían verse afectados por no contar con los datos tal cual se los esperaba.

Una solución es anotar a estos tests que ensucian la base de datos con @DirtiesContext. Esto forzará la creación de un nuevo contexto de Spring, y se recreará la correspondiente base de datos en memoria. Sin embargo, esta solución es relativamente costosa por la continua destrucción/construcción del factory de Spring.

Una solución alternativa será usar un @DirtiesDatabase que sólo recree la base de datos en memoria... sin embargo, Spring no tiene esta utilidad. Por suerte, es muy simple agregarla.

=== @DirtiesDatabase ===
Crearemos una anotación de método que nos permita indicar que un método de @Test ensucia la base de datos, y luego usaremos una Regla de [[JUnit]] para leer esta anotación y hacer la limpiaza necesaria.

==== La anotación ====
La anotación es común:
<code java5>
@Retention(RetentionPolicy.RUNTIME)
public @interface DirtiesDatabase { }
</code>

==== DatabaseRebuilder para reconstruir la base de datos ====
Primero vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
<code java5>
public interface DatabaseRebuilder {
void rebuildDatabase();
}
</code>

Una posible implementación de esta interfaz podría ser invocar a los scripts de inicialización de la base en memoria.

==== La regla de JUnit ====
Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, limpiará la base de datos:
<code java5>
public class DirtiesDatabaseRule implements TestRule {

private DatabaseRebuilder rebuilder;

public DirtiesDatabaseRule(DatabaseRebuilder rebuilder) {
this.rebuilder = rebuilder;
}

@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
base.evaluate();
} finally {
DirtiesDatabase dirtiesDatabase = description.getAnnotation(DirtiesDatabase.class);
if (dirtiesDatabase != null) {
rebuilder.rebuildDatabase();
}
}
}
};
}
}
</code>

==== Usando @DirtiesDatabase ====
Listo! Nos queda agregar la regla a la clase de test, y la anotación correspondiente.

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Rule
public DirtiesDatabaseRule dirtiesDatabaseRule = new DirtiesDatabaseRule(new DatabaseRebuilderImpl());

@Test
public void fooTest() { ... }

@Test
@DirtiesDatabase
public void barTest() { ... }
}
</code>

JUnit con bases de datos

2012-02-23T20:16:04Z

Admin: Página creada con 'Es muy común tener que integrar JUnit para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee JUnit y Spring Framework para hac…'

Es muy común tener que integrar [[JUnit]] para ejecutar tests contra una base de datos. Vamos a ver algunas facilidades que nos provee [[JUnit]] y [[Spring Framework]] para hacer más facil la ejecución de tests contra datos siempre limpios.

== embedded-database de Spring ==
[[Spring Framework]] contiene una utilidad para levantar bases de datos en memoria al momento que se inicializa el factory. De esta forma, podemos inicializar una base y a la vez decirle que ejecute varios scripts, para dejarla preparada y lista para usar.

Un archivo de configuración de ejemplo:
<code xml>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd">

<jdbc:embedded-database id="dataSource" type="HSQL" />

<jdbc:initialize-database data-source="dataSource" ignore-failures="NONE">
<jdbc:script location="classpath:tablas.sql" />
<jdbc:script location="classpath:datos.sql "/>
</jdbc:initialize-database>

</beans>
</code>

Esta configuración crea un bean llamada "dataSource" que es un DataSource común, listo para inyectar en nuestra aplicación (y reemplazar así un DataSource real). Este DataSource apunta a una base en memoria HSQLDB, y ejecutarán 2 scripts al momento de inicialización: tablas.sql y datos.sql

== Limpieza del contexto de Spring en los tests ==
Es posible que algún método de test "ensucie" (cambie) el valor de algún bean del factory, lo cual ocasione problemas en tests posteriores. Podemos usar la anotación @DirtiesContext para indicarle a Spring que vuelva a crear un nuevo factory luego de la ejecución del método anotado con esta anotación.

Por ejemplo:

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Test
public void fooTest() { ... }

@Test
@DirtiesContext
public void barTest() { ... }
}
</code>

En este ejemplo, al terminar la ejecución del método barTest() se volverá a crear el factory de Spring (y por lo tanto, se creará una nueva base en memoria). De esta manera el resto de los métodos contarán con un entorno limpio.

== Limpieza de la base de datos con Rules de JUnit ==

En la mayoría de las ocasiones, los métodos @Test no ensucian el contexto de beans de Spring, sino que ensucian los datos de la base de datos (realizando inserts, updates, deletes sobre los mismos). Los métodos posteriores de tests podrían verse afectados por no contar con los datos tal cual se los esperaba.

Una solución es anotar a estos tests que ensucian la base de datos con @DirtiesContext. Esto forzará la creación de un nuevo contexto de Spring, y se recreará la correspondiente base de datos en memoria. Sin embargo, esta solución es relativamente costosa por la continua destrucción/construcción del factory de Spring.

Una solución alternativa será usar un @DirtiesDatabase que sólo recree la base de datos en memoria... sin embargo, Spring no tiene esta utilidad. Por suerte, es muy simple agregarla.

=== @DirtiesDatabase ===
Crearemos una anotación de método que nos permita indicar que un método de @Test ensucia la base de datos, y luego usaremos una Regla de [[JUnit]] para leer esta anotación y hacer la limpiaza necesaria.

==== La anotación ====
La anotación es común:
<code java5>
@Retention(RetentionPolicy.RUNTIME)
public @interface DirtiesDatabase { }
</code>

==== La regla de JUnit ====
Primera vamos a crear una interfaz para una clase que se encargue de reconstruir la base de datos:
<code java5>
public interface DatabaseRebuilder {
void rebuildDatabase();
}
</code>

Luego, crearemos una regla de [[JUnit]] que buscará esta anotación, y si la encuentra, limpiará la base de datos:
<code java5>
public class DirtiesDatabaseRule implements TestRule {

private DatabaseRebuilder rebuilder;

public DirtiesDatabaseRule(DatabaseRebuilder rebuilder) {
this.rebuilder = rebuilder;
}

@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
base.evaluate();
} finally {
DirtiesDatabase dirtiesDatabase = description.getAnnotation(DirtiesDatabase.class);
if (dirtiesDatabase != null) {
rebuilder.rebuildDatabase();
}
}
}
};
}
}
</code>

==== Usando @DirtiesDatabase ====
Listo! Nos queda agregar la regla a la clase de test, y la anotación correspondiente.

<code java5>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
"classpath:datasource-test.xml",
"classpath:applicationContext.xml"
})
public class MiTest {

@Rule
public DirtiesDatabaseRule dirtiesDatabaseRule = new DirtiesDatabaseRule(new DatabaseRebuilderImpl());

@Test
public void fooTest() { ... }

@Test
@DirtiesDatabase
public void barTest() { ... }
}
</code>

JUnit

2012-02-23T19:56:02Z

Admin: /* Ver también */

[[JUnit]] es un framework de código abierto desarrollado especialmente para crear, ejecutar y hacer reportes de estado de conjuntos de [[Prueba Unitaria]] automatizadas hechos en lenguaje Java.

[[JUnit]] es uno de los frameworks más populares en Java para realizar pruebas unitarias y llevar un desarrollo utilizando la práctica de [[Test Driven Development]].

===Ciclo de vida===
Al momento de ejecutar los tests, [[JUnit]] ejecuta los siguientes métodos propios de cada clase de test:

* Método '''@BeforeClass''' (método estático, antes de la construcción de la clase)
* Por cada método anotado con @Test
** Constructor de la clase de test
** Método anotado con '''@Before'''
** Método anotado con '''@Test'''
** Método anotado con '''@After'''
* Al finalizar todos los @Test, se ejecuta '''@AfterClass'''

===Ejemplo===
La siguiente clase contiene 2 tests, y sirve para ver el ciclo de vida de [[JUnit]]

<code java>
public class HolaMundoTest {

public HolaMundoTest() {
System.out.println(" Constructor de HolaMundoTest");
}

@BeforeClass
public static void setUpClass() throws Exception {
System.out.println("@BeforeClass");
}

@AfterClass
public static void tearDownClass() throws Exception {
System.out.println("@AfterClass");
}

@Before
public void setUp() {
System.out.println(" @Before");
}

@After
public void tearDown() {
System.out.println(" @After");
}

@Test
public void decirHola() {
System.out.println(" TEST decirHola");
}

@Test
public void decirChau() {
System.out.println(" TEST decirChau");
}
}
</code>

La salida por consola de esta ejecución es:
@BeforeClass
Constructor de HolaMundoTest
@Before
TEST decirHola
@After
Constructor de HolaMundoTest
@Before
TEST decirChau
@After
@AfterClass

==Ver también==
* [[Prueba Unitaria]]
* [[Spring Test]]
* [[Tests De JUnit Parametrizados]]
* [[Tests De JUnit Multihilo]]
* [[Test de Metodos y Atributos Privados]]
* [http://www.junit.org Web oficial de JUnit]
* [http://javaboutique.internet.com/tutorials/UnitTesting/ Unit testing Java programs]
* [[Configuración de ejecución selectiva de tests]]
* [[Junit con SoapUI]]
* [[JUnit con bases de datos]]

[[Category:JUnit]]

JUnit

2012-02-23T19:51:16Z

Admin: Revertidos los cambios de 94.23.249.158 (disc.) a la última edición de Parivero

Jawr

2012-02-23T12:18:45Z

Admin:

[[Jawr]] es una solución de empaquetado para Javascript y CSS, que permite un rápido desarrollo de los recursos en módulos separados.

Mediante el uso de una biblioteca de etiquetas, Jawr permite el uso de las mismas páginas, sin cambios para el desarrollo y la producción. Jawr también minimiza y comprime los archivos, lo que resulta en una reducción de los tiempos de carga.
Jawr se configura mediante un archivo de properties.

== Características ==
Entre otras cosas, [[Jawr]] permite:
* crear "bundles" de varios archivos [[JavaScript]] o [[CSS]]. Es decir, agrupar muchos archivos en uno único.
* minificar archivos [[JavaScript]] o [[CSS]], quitando espacios, comentarios y otras técnicas para minimizar el tamaño.
* comprimir los archivos usando gzip y enviar el resultado comprimido al navegador.
* leer automáticamente los archivos de un directorio (y subdirectorios), sin necesidad de especificar manualmente cada archivo.
* crear sprites de múltiples imágenes y compactarlas en una única imágen.

== Ejemplo ==

A continuación se muestra la esencia de jawr
[[Archivo:jawr.png]]

ejemplo de jawr.properties
# Common properties
jawr.debug.on=false
jawr.gzip.on=false
jawr.gzip.ie6.on=false
jawr.charset.name=UTF-8

# Javascript properties and mappings
jawr.js.bundle.basedir=/js

# All files within /js/lib will be together in a bundle.
# The remaining scripts will be served sepparately.
jawr.js.bundle.jquery.id=/jquery.js
jawr.js.bundle.jquery.mappings=/js/jquery/**

jawr.js.bundle.jquery-json.id=/jquery-json.js
jawr.js.bundle.jquery-json.mappings=/js/jquery-json/**

# The /bundles/lib.js bundle is global
# (always imported before other scripts to pages using the taglib)
jawr.js.bundle.lib.global=true

# CSS properties and mappings
jawr.css.bundle.basedir=/css

# CSS files will be all bundled together automatically
jawr.css.factory.use.singlebundle=true
jawr.css.factory.singlebundle.bundlename=/default.css

web.xml
<servlet>
<servlet-name>JavascriptServlet</servlet-name>
<servlet-class>net.jawr.web.servlet.JawrServlet</servlet-class>


<init-param>
<param-name>configLocation</param-name>
<param-value>/jawr.properties</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet>
<servlet-name>CSSServlet</servlet-name>
<servlet-class>net.jawr.web.servlet.JawrServlet</servlet-class>


<init-param>
<param-name>configLocation</param-name>
<param-value>/jawr.properties</param-value>
</init-param>
<init-param>
<param-name>type</param-name>
<param-value>css</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>JavascriptServlet</servlet-name>
<url-pattern>*.js</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>CSSServlet</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>

ejemplo de un jsp
<%@ taglib uri="http://jawr.net/tags" prefix="jwr"%>
<%@ page contentType="text/html;charset=UTF-8"%>
<html>
<head>
<jwr:script src="/jquery.js" />
<jwr:script src="/jquery-json.js" />
<jwr:style src="/default.css" />
</head>
<body>

<h 2>Hello World!</h 2>
</body>
</html>

== Ver también ==
* [http://jawr.java.net/ Web oficial de Jawr]

Node.js

2012-02-10T14:26:15Z

Admin: /* Configuración de NPM detrás de un proxy */

[[Node.js]] es una plataforma para crear aplicaciones de internet, especialmente servidores web. Los programas se escriben en [[JavaScript]], usan I/O asincrónico por eventos para minizar el overhead y maximizar la escalabildiad. [[Node.js]] utiliza el motor JavaScript V8 de Google, y varias librerías propias.

== Configuración de NPM detrás de un proxy ==
NPM (el gestor de paquetes de Node) puede funcionar detrás de un proxy. Para esto es necesario configurar los datos del proxy. Toda la configuración de NPM se guarda en el archivo '''.npmrc''' en la raíz del directorio del usuario. Este archivo puede editarse manualmente, o ejecutando ''npm config set key value''.

Por ejemplo, para utilizar el proxy "proxy.dominio.com" en el puerto 8080, con el usuario "user" y el password "pass":
npm config set proxy http://user:pass@proxy.dominio.com:8080/

En Windows es común que el usuario esté asociado a un dominio. En ese caso, anteponemos el dominio antes del nombre de usuario separando con la contrabarra (\). Por ejemplo, si el usuario "user" está en el dominio "MIDOMINIO":
npm config set proxy http://MIDOMINIO\user:pass@proxy.dominio.com:8080/

Si el proxy tiene problemas con HTTPS, es posible decirle a NPM que utilice sólo el protocolo HTTP para conectarse:
npm config set registry http://registry.npmjs.org/

Node.js

2012-02-10T14:21:56Z

Admin: Página creada con 'Node.js es una plataforma para crear aplicaciones de internet, especialmente servidores web. Los programas se escriben en JavaScript, usan I/O asincrónico por eventos p…'

[[Node.js]] es una plataforma para crear aplicaciones de internet, especialmente servidores web. Los programas se escriben en [[JavaScript]], usan I/O asincrónico por eventos para minizar el overhead y maximizar la escalabildiad. [[Node.js]] utiliza el motor JavaScript V8 de Google, y varias librerías propias.

== Configuración de NPM detrás de un proxy ==
NPM (el gestor de paquetes de Node) puede funcionar detrás de un proxy. Para esto es necesario configurar los datos del proxy. Toda la configuración de NPM se guarda en el archivo '''.npmrc''' en la raíz del directorio del usuario.

Por ejemplo, para utilizar el proxy "proxy.dominio.com" en el puerto 8080, con el usuario "user" y el password "pass":

Ejemplo:
proxy = http://user:pass@proxy.dominio.com:8080/

En Windows es común que el usuario esté asociado a un dominio. En ese caso, anteponemos el dominio antes del nombre de usuario separando con la contrabarra (\). Por ejemplo, si el usuario "user" está en el dominio "MIDOMINIO":
proxy = http://MIDOMINIO\user:pass@proxy.dominio.com:8080/

Si el proxy tiene problemas con HTTPS, es posible decirle a NPM que utilice sólo el protocolo HTTP para conectarse:
registry = http://registry.npmjs.org/