addProxy

gist

	public static void addProxy(String user, String pass, String host, String port) {

		if(user!= null && pass != null) {
			final String authUser = user;
			final String authPassword = pass;

			Authenticator.setDefault(
					new Authenticator() {
						public PasswordAuthentication getPasswordAuthentication() {
							return new PasswordAuthentication(
									authUser, authPassword.toCharArray());
						}
					}
			);

			System.setProperty("http.proxyUser", authUser);
			System.setProperty("http.proxyPassword", authPassword);
		}

		System.setProperty("http.proxyHost", host);
		System.setProperty("http.proxyPort", port);
	}
Anuncios
addProxy

Reflection: Prohibited package name

Estaba invocando una clase para hacer reflexión sobre ella y llamar a un método especifico. Esta clase tenia un paquete que se denomina tal que asi:
java.xxx.yyy.clase.java

Y me salta en las pruebas un error tal que:

java.lang.SecurityException: Prohibited package name: java.xxx.yyy

Motivo: aquellos paquetes que empiezan por ‘java.‘ están “reservados”, es decir no se puede hacer reflexión sobre ellos pues en su código fuente así lo especifica. En la clase ClassLoader. Aquí el fragmento:

//...
private ProtectionDomain More preDefineClass(String name, ProtectionDomain protectionDomain) {
        if (!checkName(name))
            throw new NoClassDefFoundError("IllegalName: " + name);

        if ((name != null) && name.startsWith("java.")) {
            throw new SecurityException("Prohibited package name: " +
                                        name.substring(0, name.lastIndexOf('.')));
        }
        if (protectionDomain == null) {
            protectionDomain = getDefaultDomain();
        }

        if (name != null)
            checkCerts(name, protectionDomain.getCodeSource());

        return protectionDomain;
    }
//...
Reflection: Prohibited package name

@Transactional y @Rollback en Spring JDBC

Estoy en un proyecto en el que he abandonado Hibernate. Prefiero tener el control de las queries. Realmente no van a ser unas queries poderosas, pero tambien es cierto que realmente no entiendo la ventaja de Hibernate. Y para colmo no tengo acceso a ningun curso, con el cual pueda abrir los ojos.

He decidido probar Spring JDBC. Uso NamedParameterJdbcTemplate para todas las operaciones. Esto implica no tener que estar inyectando el DataSource por todos los lados. Simplificación y legibilidad.

Con el paso de los días, y en progresión a la experiencia. Decidí hacer test, pero sin grabar en bbdd. Haciendo rollback. Así me queda un proyecto tan completo como los que he realizado con Hibernate. Añadí a mi fichero de configuración de Spring:


    <tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager" />

    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

y en los métodos en los que se hace insert, update ó delete, indico la anotación @Transactional

	@Transactional
	protected void update(String query, T bean) {
	      // ...
	}

Ahora bien, en los test. He estado probando y realizando pruebas para saber concretamente el uso que tiene Transactional y Rollback.

  • Si pones solo Transacctional , hara rollback, cuando se lance alguna excepción no cacheadas (derivadas de RuntimeException). Dentro de la anotación puedes indicarle otras opciones.
  • Si acompañas la anotacion @Transacctional con @Rollback (por defecto es true), estas indicando que siempre se va a hacer Rollback. Mediante la anotacion Rollback, estas sobreescribiendo el comportamiento de Transacctional, referente a los rollback.
  • 	@Test
    	@Transactional
    	@Rollback
    	public void testSave() {
    	      // ...
    	}
    

    Indicar @Transacctional en el metodo de test, es sobreescribir el comportamiento de @Transacctional en el metodo a testear.

El Javadoc de Rollback dice:

Test annotation to indicate whether or not the transaction for the annotated
test method should be rolled back after the test method has
completed. If {@code true}, the transaction will be rolled back;
otherwise, the transaction will be committed.

@Transactional y @Rollback en Spring JDBC

Semaforos en Java

Me había construido una clase que era un semáforo de procesos. Cuando me he preguntado, lo que suelo preguntarme: “¿y esto, no lo habrá hecho otro ya?”. Y la respuesta es si, existen desde hace ni se sabe .

java.util.concurrent.Semaphore

y se pueden instanciar desde Spring.

	<bean id="semaphoreJobA" class="java.util.concurrent.Semaphore">
		<constructor-arg index="0" type="int" value="1" />
		<constructor-arg index="1" type="boolean" value="true" />
		<!-- permits - the initial number of permits available. This value may 
			be negative, in which case releases must occur before any acquires will be 
			granted. -->
		<!-- fair - true if this semaphore will guarantee first-in first-out granting 
			of permits under contention, else false -->
	</bean>

Luego en tu clase, los invocas y les dejas hacer su magia.

	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {

		// Invoco a Spring, por que estoy ejecutando fuera de su contexto.
		Semaphore semaphoreJobA = (Semaphore) SpringApplicationContext.getBean("semaphoreJobA");
		String whoiam = String.valueOf(this.hashCode());
		try{
			LOGGER.info("t"+whoiam +"-"+ taskType.name()+"t Pregunto al semaforo si puedo continuar");
			semaphoreJobA.acquire();
			LOGGER.info("t"+whoiam +"-"+ taskType.name()+"t He pasado, ejecutando tarea...");
			doTask(whoiam);
		}catch(Exception e){
			LOGGER.error("t"+whoiam +"-"+ taskType.name()+"t Error: ", e);
			
			JobExecutionException e2 = new JobExecutionException(e);
			e2.setStackTrace(e.getStackTrace());
			throw e2;			
		}finally{
			semaphoreJobA.release();
		}

	}

¿Como era mi clase?, ya probada y testeada. Con muchas mejoras por hacer…

package net.pp.jm.scheduler;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Cualquiera puede coger la vez no importa el orden de llegada sino el mas rapido en cuanto este vacio el semaforo
 * 
 * @author josemanuel.prietopalacios.net
 *
 */
public class Semaforo {

	private static final Logger LOGGER = LoggerFactory.getLogger(Semaforo.class);

	// estos podrian ser semaforos del API Java...
	int hashCodeTask1;
	int hashCodeTask2;
	int hashCodeTask3;
	int hashCodeTask4;

	private boolean finish_method_run;

	public synchronized boolean running(TaskType tarea, int hashCode){
		LOGGER.info(hashCode +"-"+ tarea.name() + " solicitud de ejecucion");

		// Aqui se puede usar un Lock: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/Lock.html
		if(finish_method_run){
			while(!finish_method_run){
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					LOGGER.error("ERROR: ", e);
				}
			}
		}
		
		if(ican(tarea, hashCode)){
			switch(tarea){
			case tarea1: hashCodeTask1 = hashCode; break;
			case tarea2: hashCodeTask2 = hashCode; break;
			case tarea3: hashCodeTask3 = hashCode; break;
			case tarea4: hashCodeTask4 = hashCode; break;
			}
			LOGGER.info(hashCode +"-"+ tarea.name() + " running...");
			return true;
		}else{
			return false;
		}
	}

	private boolean ican(TaskType tarea, int hashCode){
		boolean ican = false;
		switch(tarea){
		case tarea1: ican = (hashCodeTask1 != 0) ? false : true; break;
		case tarea2: ican = (hashCodeTask2 != 0) ? false : true; break;
		case tarea3: ican = (hashCodeTask3 != 0) ? false : true; break;
		case tarea4: ican = (hashCodeTask4 != 0) ? false : true; break;
		}
		return ican;
	}

	public synchronized void finish(TaskType tarea, int hashCode){
		finish_method_run = true;
		switch(tarea){
		case tarea1: hashCodeTask1 = 0; break;
		case tarea2: hashCodeTask2 = 0; break;
		case tarea3: hashCodeTask3 = 0; break;
		case tarea4: hashCodeTask4 = 0; break;
		}
		LOGGER.info(hashCode +"-"+ tarea.name() + " finish");
		finish_method_run = false;
	}

}
Semaforos en Java

listar librerias java del servidor

Con este comando listamos todas las librerias del servidor y quitamos la ruta, nos quedamos solo con el nombre del jar.

locate *.jar | sed 's/// /g' | sed '/[a-z]*.jar$/ s/[a-z]* //g' | sort

comando locate *.jar : busca todos los ficheros que acaben por .jar
comando sed ‘s/// /g’ : elimina la barra y la sustituye por ‘ ‘(espacio en blanco).
comando sed ‘/[a-z]*.jar$/ s/[a-z]* //g’ : de todas las lineas que cumplan el patrón (la linea termina por .jar) elimina cualquier elemento que contemple el patron (letras seguidas de un espacio). Es decir, elimino la ruta de los ficheros.

listar librerias java del servidor

Java UNICODE

Recientemente el eclipse ha dejado de convertir de UTF-8 a unicode mis properties de i18n. En lugar de intentar arreglarlo (acierto), me he puesto a configurar los acentos y eñes en los distintos lenguajes con los que trabajamos, a mano (error).

Aquí esta la tabla con los caracteres específicos del castellano.

Como no tengo tiempo a mas, aquí pongo unos blogs y tutoriales sobre como maneja Java el UNICODE:

Java UNICODE