Me he encontrado mas de alguna vez con los estos archivos y aquí les dejo el cómo extraerlos para su mejor uso, dado que muchas veces viene un solo archivo FLAC con un pequeño archivo CUE.

¿Qué son estos archivos?

FLAC es la abreviación de “Free Lossless Audio Codec” y es codec que permite guardar música en alta resolución o dicho de otra forma, audio de baja compresión o sin pérdidas. Por otro lado CUE es un descriptor de archivos, es decir, describe (en el caso de audio) los tracks del disco (cuando comienzan y cuando terminan).

Como tenemos estos dos archivos,ahora… como podemos usarlos para extraer los tracks que contiene el album, manos a la obra.

Primero debemos tener las herramientas para hacerlo (en este caso para ubuntu):

$ sudo apt-get install cuetools shntool flac

Luego nos posicionamos en el directorio donde se encuentran los dos archivos (FLAC/CUE) y procedemos a separar los archivos segun el descriptor (CUE):

$ cuebreakpoints archivo.cue | shnsplit -o flac archivo.flac

Si todo sale bien y si los archivos están sin problemas, aparecerá algo como esto:

Splitting [Album.flac] (47:27.20) --> [split-track01.flac] (4:45.17) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track02.flac] (6:37.45) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track03.flac] (5:11.33) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track04.flac] (6:53.02) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track05.flac] (4:04.28) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track06.flac] (4:24.10) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track07.flac] (6:36.52) : 100% OK
Splitting [Album.flac] (47:27.20) --> [split-track08.flac] (8:54.58) : 100% OK

Lo último que queda por hacer, es extraer las descripciones de los tracks que están dentro del archivo CUE, esto hará que la metadata sea almacenada en cada uno de los archivos extraidos.

$ cuetag archivo.cue split-track*.flac

Simple o no?

Mas información en wikipedia:

• Cue sheet (computing)

• Flac
• Lossless data compression

Estas son nuestras primeras vacaciones con mi hija Javiera, hasta el momento de vacaciones tienen bien poco. Nos despertamos temprano, nos acostamos tarde y hay que estar constantemente jugando, mirando, vigilando y enseñando a la @javicollaov. Y esto es todos los días.

Antes… vacaciones para mi era desconectarme del trabajo y comenzar a pensar en mis proyectos personales, como por ejemplo, avanzar en mis códigos, estudiar o simplemente sacar un buen tema en la guitarra (de esos que te dejan pegado por mas de 1 semana). Muchos me decían, esas no son vacaciones (por lo de seguir programando o estudiar) y es que existe un vínculo/paradigma de que vacaciones es necesariamente playa, sol o viajes alrededor del mundo, disculpen pero yo no estoy de acuerdo con eso!

Ahora bien, con familia todo cambia, hay que pensar en que salir de vacaciones fuera de Santiago se deben adaptar para @javicollaov (que tiene 1 año 5 meses), pues bien hay que pensar en sus comidas, en los pañales y se deben cubrir todas sus necesidades a la perfección, de lo contrario podrías pasar unas pésimas vacaciones. Por suerte su mamá la @guzyy, siempre se preocupa de hasta el mas mínimo detalle y hay que decirlo, se preocupa de cosas que yo ni pensaría.

A pesar de todo, no hay nada mas lindo que la sonrisa de mi hija, cuando se come el yogurt a cucharadas, cuando te dice “papapapaaaaa” o simplemente cuando le preguntas la hora (si la ven no duden en preguntarle la hora), todo lo cansado, somnoliento o enojado simplemente desaparece.

Javiera Comiendo Yogurt

Y es que espero que estas vacaciones (aunque no muy descansadas) lo vamos a pasar la raja, increíble, de pelos, maravilloso y todo eso porque llevamos a la @javicollaov, esa personita que nos mueve todos los días y nos hace la vida mas feliz.

Y para ti? qué son las vacaciones?

Hoy llegue al número que tanto se ha hablado durante mucho rato, el 33. Donde han salido innumerables personajes tratando de hacer que todo sume 33, a eso hay que agregar la coincidencia de los 33 mineros, los 33 caracteres (incluyendo los espacios) del mensaje de los mineros, fueron encontrados en la semana 33 del año 2010, 33 la edad de Cristo y así un sin fin de otras posibles combinaciones que den 33.

Para mi no es mas que un número que llevare durante todo año y lo mas lindo que lo llevaré junto a mi hermosa familia, con el amor de mi hija @javicollaov y mi @guzyy.

Muchas gracias a todos y todas por sus saludos y que siga la música

Este artículo puede ser útil para todos aquellos que alguna vez tuvieron que hacer cientos o miles de líneas de código usando reflexión para poder acceder a atributos, navegar mapas y recorrer listas en Java. Ahora bien si le agregamos que esas listas o mapas pueden tener más de lo mismo o más complejo aún, objetos que contienen listas o mapas.

Aquí Apache Jexl hace bien su trabajo utilizando un lenguaje cómodo para poder acceder a esos recónditos lugares.

Apache Jexl (Java EXpresion Language) fue inspirado por Apache Velocity y por la definición de Expresion Language para JSTL y JSP 2.0. Ademas en la versión 2.0 se agregaron funcionalidades de Unified EL.

Un pequeño ejemplo para que lo véan en acción:

public class TestDTO {
 
	private String _name;
 
	private Map<String, Object> _dataBag;
 
	/** Se omiten los setter y getter **/
}

Esta es la definición de un DTO que tiene dos atributos, uno de ellos es un String y otro un Map cuya clave siempre será String y su valor puede ser un Object.

La problemática es obtener un valor desde ese DTO mediante reflexión, es decir, el ente que ejecuta la extracción del parámetro no conoce la definición a priori de esa clase. Es aquí donde entra Jexl y mediante un simple lenguaje le podemos indicar hasta donde acceder. A ese cómo y qué le llamaremos Expresión.

public class JexlEvaluator {
 
	private static final JexlEngine jexl = new JexlEngine();
 
	static {
		jexl.setCache(512);
		jexl.setLenient(false);
		jexl.setSilent(false);
	}
 
	public Object getValue(String expresion, Object object) {
		Expression e = jexl.createExpression(expresion);
		JexlContext context = new MapContext();
		context.set("fua", object);
		return e.evaluate(context);
	}
}

Esta simple clase en su bloque estático configura Apache Jexl para luego ser utilizado en el método getValue.

El método getValue recibe como parámetros, la expresión y el objeto a evaluar. Dentro del método se crea el contexto de Apache Jexl (muy similar a un HashMap) al cual se le pasa el Objeto a inspecionar y luego evalúa la expresión.

Aquí les dejo el test unitario y la salida:

public class JexlEvaluatorTest {
 
	private static Log logger = LogFactory.getLog(JexlEvaluatorTest.class);
 
	@Test
	public void testJexl() {
		JexlEvaluator je = new JexlEvaluator();
 
		/* Expresión a evaluar */
		String expresion = "fua.dataBag.hola2";
 
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("hola", "Hola 1 del MAP");
 
		Map<String, Object> map2 = new HashMap<String, Object>();
		map2.put("hola2", "Hola 2 del MAP");
 
		map.put("hola2", map2);
 
		TestDTO testDTO = new TestDTO();
		testDTO.setDataBag(map2);
		testDTO.setName("DTO Interesante");
 
		Object result = je.getValue(expresion, testDTO);
 
		logger.info(result.toString());
	}
}

La ejecución de ese test debería retornar lo siguiente:

[29/08/11 09:08:16:016 CLT] [ INFO] [JexlEvaluatorTest:44] - Hola 2 del MAP

Más adelante espero poder escribir sobre Spring EL, otra solución para evaluación de expresiones para Java.

Se me generó el siguiente problema al hacer un test unitario sobre una clase que implementa la interfaz de Spring Framework ServletContextAware.

public interface ServletContextAware {
 
	void setServletContext(ServletContext servletContext);
 
}

Mediante esta interfaz puedes inyectar el servletContext a la configuración de tu Bean, siempre y cuando tengas un contexto web funcionando.

He aquí el segundo problema, ¿ Cómo puedo tener el un contexto web dentro de un Junit ?. Puede que exista una mejor forma de hacerlo pero lo logré de la siguiente manera.

<?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:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
	<bean class="org.springframework.mock.web.MockServletContext" />
 
</beans>

Con esto y usando la anotación Autowired funciona de pelos la inyección del ServletContext.

public class ReadFileFromWebinf {
 
	@Autowired
	private ServletContext _servletContext;
 
	/*Se omite el resto de los métodos*/
}

Pero!!! cuando quise utilizar la interfaz ServletContextAware no funcionó y me quede con una propiedad en null.

public class ReadFileFromWebinf implement ServletContextAware {
 
	private ServletContext _servletContext;
 
	public void setServletContext(ServletContext servletContext){
		_servletContext=servletContext;
	};
 
	/*Se omite el resto de los métodos*/
}

Buscando por todos lados encontré que a mi test unitario le faltaba un par de configuraciones para la lectura del contexto Spring.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/test/test-context.xml" }
@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class })
public class ReadFileFromWebinfTest {
 
	@Autowired
	private ReadFileFromWebinf _readFileFromWebinf;
 
 
	public void testReadFile(){
		String fileContent = _readFileFromWebinf.load("archivo.xml");
		System.out.println(fileContent);
	}
}

Las dos primeras anotaciones son para decirle a Spring que se va a utilizar Junit para ejecutar la clase y cual o cuales son los contextos a cargar.

Luego viene la anotación que me arregló el día, TestExecutionListeners y el listener asociado para la completar las inyecciones de dependencia de todos los beans. (Antes con Autowired solo hacía algunos).

Espero les sirva, cualquier duda bienvenida sea.

InitializingBean

Esta interfaz de Spring Framework te permite una vez configurado el contexto, ejecutar el método afterPropertiesSet(), y como su nombre lo dice, lo ejecuta luego de ejecutar los métodos setter del bean (post configurar el bean).

public interface InitializingBean {
 
	void afterPropertiesSet() throws Exception;
 
}

Algunas aplicaciones de esta interfaz:

• Validar que los atributos de un Bean estén correctamente inicializados.
• A partir de los atributos ya setteados, generar otra propiedad en tiempo de configuración. Por ejemplo, se configura el bean con dos atributos de tipo int y en tiempo de configuración quiero calcular la suma de ambos y dejarlo en otra propiedad. ¿ Qué gano con esto ? que esa propiedad no se calcula cada vez que hago el getter sino que ya esta previamente calculada.

Para el primer caso, recomiendo utilizar la clase Assert ya que provee métodos con los que puedes invalidar que el contexto Spring levante si hay errores en la configuración.

Les dejo un código de ejemplo para que le echen un vistazo (le agregué la interfaz al ejemplo del post anterior)

public class ExampleBean implements InitializingBean {
 
	private Integer _randomValue;
 
	private Integer _newValue;
 
	public final Integer getRandomValue() {
		return _randomValue;
	}
 
	public final Integer getNewValue() {
		return _newValue;
	}
 
	public final void setRandomValue(Integer randomValue) {
		_randomValue = randomValue;
	}
 
	public void afterPropertiesSet() throws Exception {
		Assert.notNull(_randomValue, "randomValue properties cannot be null");
		_newValue = _randomValue * 10;
	}
 
}

Voy a explicar un poco y a groso modo el como funciona esta clase desde el punto de vista de Spring:

• Se lee la configuración asociada a la clase ExampleBean
• Se crea la instancia de la clase ExampleBean
• Luego vía inyección se le settean los atributos, entre ellos randomValue
• Luego de la creación del bean ExampleBean se ejecuta el método afterPropertiesSet(), en donde se realiza una validación del randomValue (este NO puede ser nulo, de serlo, el contexto de Spring no quedara operativo), si eso pasa OK, se calculará el atributo newValue y que será randomValue multipliado por 10.
• Finalmente y si no hay errores en el contexto de Spring, se deja la instancia del bean ExampleBean en el contexto, es decir, el valor randomValue y newValue quedan listos para ser usados.

Este proceso se realiza sólo una vez (salvo que el scope no sea singleton) y es en el momento de la creación del contexto.

Demás esta decir que esta clase/bean (ExampleBean) debe estar configurada en el archivo del contexto de Spring o vía las anotaciones (metadata) provistas para eso.