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);
	}

JPopulator

He usado la libreria jPopulator para rellenar unos beans y mockear el comportamiento de unos algoritmos.

Estoy intentando mockear un Web Service. Y estaba rellanado los bean generados con la herramienta cxf codegen. Estas herramientas son geniales super útiles, pero los bean no cumplen los estandars. Por ejemplo:

public class ArrayOfPCGError {
    protected List<PCGError> pcgError;

    public List<PCGError> getPCGError() {
        if (pcgError == null) {
            pcgError = new ArrayList<PCGError>();
        }
        return this.pcgError;
    }
}

En esta clase no hay metodo set y el metodo getPCGError no cumple con el atributo «pcgError». Debiera ser: getPcgError()

Si le dices a jPopulator que te lo rellene, salta una excepcion.

nov 11, 2014 XX:XX:20 PM io.github.benas.jpopulator.impl.PopulatorImpl populateBeanWithExcludeFields
GRAVE: Unable to populate an instance of type class xxx.yyy.zzz.ArrayOfPCGError
java.lang.NoSuchMethodException: Unknown property 'pcgError' on class 'class xxx.yyy.zzz.ArrayOfPCGError'

¿Como solucionarlo?. Añadiendo a la libreria una nueva funcionalidad. La de excluir algunos metodos. HE añadido a la interfaz Populator el siguiente metodo:

public interface Populator {
    //...
    <T> T populateBeanWithExcludeFields(Class<T> type, String... excludeFieldsName);
}

He implementao el metodo resultante sin repetir codigo y he realizado los test.

Espero lo agreguen como funcionalidad, mientras lo tengo compilado en mi maven, en local.

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;
    }
//...

@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.

Vagrant

Me acabo de terminar de leer: «Creating Development Environments with Vagrant«.

Un libro que se lee muy rapido, apenas llega a las 100 paginas. Pero ha satisfecho todas mis dudas sobre que y para que usar Vagrant.

Tengo que decir que no lo he probado, todas estas conclusiones derivan de la lectura de este libro.

Vagrant es un sistema de virtualizacion, que tiene como base VirtualBox. La diferencia con respecto a otros sistemas de virtualizacion, es que este sistema se basa en un fichero de configuracion en el cual se indica, el Sistema Operativo y todas las librerias o productos que se quieren instalar dentro. De manera que si exportas ese fichero de configuracion a otra persona, tiene exactamente el mismo sistema. Solo compartiendo un fichero, que no pesa.

Para configurar el sistema internamente puedes usar tres herramientas, ssh, puppet y chef. Estas ultimas son automatizadores de instalación y configuración de programas. El libro dedica una capitulo a cada configurador de programas. Y en un solo capitulo te explica como usarlos. De hecho podrias usar los tres a la vez.

Es insteresante como puedes montar un entorno de mas de un servidor. Por ejemplo Liferay en un server y MySQL en otro. Todo esta configuracion dentro del mismo fichero Vagrant.

Ahora bien, he estado mirando que es Docker, y creo que ya no es necesario usar Vagrant. Pero esto va en otro post.