Carga Perezosa en Clientes Pesados.

/*
 * Copyright 2009-2011 original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jdal.aspects;
 
import java.util.Collection;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.FlushMode;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.collection.AbstractPersistentCollection;
import org.hibernate.engine.PersistenceContext;
import org.hibernate.impl.SessionImpl;
import org.hibernate.persister.collection.CollectionPersister;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
 
/**
 * Hibernate Guard for LazyInitializationException. Open read only session and 
 * load Uninitialized proxy o collection from database before access to it.
 * 
 * @author Jose Luis Martin - (jlm@joseluismartin.info)
 */
privileged public aspect HibernateLazyGuard {
 
	/** hibernate session factory used to create sessions */
	private SessionFactory sessionFactory;
	/** common logging log */
	private static final Log log = LogFactory.getLog(HibernateLazyGuard.class);
 
	/**
	 * Test if PersistentCollection is connected to session
	 * @return true if not connected (detached)
	 */
	public boolean  AbstractPersistentCollection.isDetached() {
		return  !(isConnectedToSession() && session.isConnected());
	}
 
    /** match Collection public methods calls */
	pointcut collection() : call (public * Collection.*(..)) && !within(HibernateLazyGuard);
 
	/** match join points on this advice */
	pointcut me() : cflow(adviceexecution()) && within(HibernateLazyGuard);
 
	/** match access to intialized flag on APC, only if call is in flow of woven collection method */
	pointcut initialized(AbstractPersistentCollection apc) : 
		get(boolean org.hibernate.collection.AbstractPersistentCollection.initialized) && 
		this(apc);
 
	/**
	 * Before Advice, if Collection is unitialized open a new Session
	 * to initialize Collection
	 * @param c AbstractPersistentCollection 
	 */
	boolean around(AbstractPersistentCollection apc) : initialized(apc) && !cflow(me())   {
		if (log.isDebugEnabled())
			log.debug(thisJoinPointStaticPart.toString());
 
		if (!SessionFactoryUtils.hasTransactionalSession(sessionFactory) &&
				!apc.wasInitialized() && apc.isDetached()) {
			log.warn("PersistentCollection will throw exception: " + apc.getRole());
			Session session = sessionFactory.openSession();
			session.setFlushMode(FlushMode.MANUAL);
			Transaction tx = null;
			try {
				tx = session.beginTransaction();
				attachToSession(apc, session);
				Hibernate.initialize(apc);  // will throw lazy if attach was failed
				tx.commit();
			} 
			catch (RuntimeException e) {
				tx.rollback();	
				throw e;
			}
			finally {
				session.close();
			}
		}
		// return true
		return proceed(apc);
	}
 
 
	/**
	 * If PersistentCollection is uninitialized, attach it to new session and 
	 * initialize it. 
	 * @param ps persistent collection
	 * @param session hibernate sesion to use for initialization
	 */
	@SuppressWarnings("unchecked")
	public void attachToSession(AbstractPersistentCollection ps, Session session) {
		if (log.isDebugEnabled())
			log.debug("Attatching PersistentCollection of role: " + ps.getRole());
 
		if (!ps.wasInitialized()) {
			SessionImpl source = (SessionImpl) session;
			PersistenceContext context = source.getPersistenceContext();
			CollectionPersister cp = source.getFactory().getCollectionPersister(ps.getRole());
 
			if (!context.containsCollection(ps)) {  // detached
				context.addUninitializedDetachedCollection(cp, ps);
			}
 
			ps.setCurrentSession(context.getSession());
		}
	}
 
	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}
 
 
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
}
 

<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
		default-lazy-init="false" default-init-method="init">
 
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath*:/jdbc.properties</value>
			</list>
		</property>
	</bean>
 
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
 
		<property name="acquireIncrement" value="3" />
		<property name="minPoolSize" value="2" />
		<property name="maxPoolSize" value="10" />
		<property name="maxIdleTime" value="5" />
		<property name="numHelperThreads" value="5" />
 
		<property name="idleConnectionTestPeriod" value="10" />
		<property name="autoCommitOnClose" value="false" />
		<property name="preferredTestQuery" value="select 1;" />
		<property name="testConnectionOnCheckin" value="true" />
 
		<property name="checkoutTimeout" value="60000" />
	</bean>
 
	<!-- Hibernate SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
    </bean>
 
	 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
 
	<bean id="catDao" class="info.joseluismartin.dao.hibernate.HibernateDao">
		<constructor-arg value="org.jdal.aspects.sample.Cat"/>
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
 
	<bean id="dogDao" class="info.joseluismartin.dao.hibernate.HibernateDao">
		<constructor-arg value="org.jdal.aspects.sample.Dog"/>
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean> 
 
 
	<!-- Tx Advice -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- the transactional semantics... -->
    <tx:attributes>
      <!-- all methods starting with 'get' and 'load' are read-only -->
      <tx:method name="get*" read-only="true"/>
      <tx:method name="load*" read-only="true"/>
      <!-- other methods use the default transaction settings -->
      <tx:method name="*"/>
    </tx:attributes>
  </tx:advice>
 
	 <aop:config>
       <!-- Make all methods on package service transactional  -->
       <aop:pointcut id="daoOperation" expression="execution(* info.joseluismartin.dao.*.*(..))"/>
       <aop:advisor advice-ref="txAdvice" pointcut-ref="daoOperation" order="1"/>
	</aop:config>
 
	<context:load-time-weaver/>
 
	<bean id="lazyGuard" class="org.jdal.aspects.HibernateLazyGuard" factory-method="aspectOf">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
 
</beans>
 

/*
 * Copyright 2009-2011 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jdal.aspects.sample;
 
import info.joseluismartin.beans.AppCtx;
import info.joseluismartin.dao.Dao;
 
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
/**
 * @author Jose Luis Martin - (jlm@joseluismartin.info)
 *
 */
public class Main {
 
	private static final Log log = LogFactory.getLog(Main.class);
 
	@SuppressWarnings("unchecked")
	public static void main (String[] arg) {
		AppCtx.getInstance();
		Dao<Dog, Long> dogDao = (Dao<Dog, Long>) AppCtx.getInstance().getBean("dogDao");
		Dog dog = dogDao.get(1l);
		dogDao.delete(dog);
 
		int i = 0;
 
		for (Cat cat : dog.getCats()) 
			log.info(cat.getName());
	}
 
}