public interface DtoDao {
	public List loadDtos(Class dtoClass, Criterion criterion);
 
	// TODO: query by exmaple
	// aber hierzu müssen die dto-properties auf entity-properties zurück gemappt werden
}

public class DvoDaoImpl implements DvoDao, InitializingBean{
	private static final Log LOG = LogFactory.getLog(DvoDaoImpl.class);
 
	private HqlToSqlTranslator translator;
	private SessionFactory sessionFactory;
	private final DvoEntityManager entityManager = DvoEntityManager.getInstance();
 
	@Transactional(isolation=Isolation.READ_COMMITTED, propagation=Propagation.REQUIRED, readOnly=true, rollbackFor=Exception.class)
	public List loadDvos(Class dvoClass, Criterion criterion){
		return loadDvos(entityManager.getMetaByDvo(dvoClass), criterion);
	}
 
	private List loadDvos(DvoEntityMeta meta, Criterion criterion){
		/**/
		// TODO: optimieren: wenn mehrere attribute einer aggregation (z.b. x.y.id und x.y.name) benutzt werden,
		// dann sollen nicht zwei joins erzeugt werden
		final Criteria criteria = sessionFactory.getCurrentSession().createCriteria(meta.getEntityClass(), "d");
		// es werden zwei informationen von der meta benötigt:
		// 1. welche felder sollen in der query geladen werden
		// 2. in welche properties sollen die daten gespeichert werden
 
		// beispiel:
		// dlrListDvoPropertiesByAlias.put("customerName", "referencedMTMessage.customer.name");
		// bedeutet, dass die dvo-property "customerName" mit den daten aus "referencedMTMessage.customer.name"
		// befüllt werden soll.
 
		// der query-teil ("referencedMTMessage.customer.name") muss gesplittet und mit joins in die abfrage integriert werden.
		// auch muss der index jedes feldes nachgehalten werden, da das resultset nur über indizes einzelne kolumnen liefert
 
		final Map<String, String> propertyToQueryMappings = meta.getDvoPropertiesToQueryPaths();
		if (LOG.isDebugEnabled()){
			LOG.debug("propertyToQueryMappings="+propertyToQueryMappings);
		}
		// property -> index in resultset
		final HashMap<String, Integer> columnMappingsByIndex = new HashMap<String, Integer>(10);
		// key -> ag_referencedMTMessage.country, value -> ag_referencedMTMessage_country
		// LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country
		final HashMap<String, String> aggregations = new HashMap<String, String>(10);
		final ProjectionList projections = Projections.projectionList();
 
		int maxAggregationDeepth = 0; // maximale anzahl aggregationen bei allen querypaths
		int propertyColumnIndex = 0; // index der property in resultset
 
		String queryPath; // querypath der aktuellen property
		int aggregationDeepth; // anzahl aggregationen im querypath der aktuellen property
		final ArrayList<String> aggregationParts = new ArrayList<String>(5); // querypath der aktuellen property zerstueckelt
 
		for (final String property:propertyToQueryMappings.keySet()){
			queryPath = propertyToQueryMappings.get(property);
 
			// zur ermittlung der aggregationen
			aggregationDeepth = StringUtil.occurences(queryPath, '.');
			if (LOG.isDebugEnabled()){
				LOG.debug("property="+property+", queryPath="+queryPath+", aggregationDeepth="+aggregationDeepth);
			}
 
			if (aggregationDeepth<1){
				// keine aggregation
				// state -> d.state
				projections.add(Projections.property("d."+queryPath));
				if (LOG.isDebugEnabled()){
					LOG.debug("  adding direct property projection d."+queryPath);
				}
			}
			else{
				maxAggregationDeepth = Math.max(maxAggregationDeepth, aggregationDeepth);
				// aggregationen vorhanden
				// alle abarbeiten
 
				// erst alle teile ermitteln
				aggregationParts.clear();
				CollectionSplitter.toList(aggregationParts, queryPath, "\\.", true, true);
 
				if (LOG.isDebugEnabled()){
					LOG.debug("  aggregationParts="+aggregationParts);
				}
 
				// beispiele für aggregationen:
 
				// customer.id -> ag_customer.id + LEFT JOIN d.customer AS ag_customer
 
				// referencedMTMessage.country.iso3166
				// -> ag_referencedMTMessage_country.iso3166
				// + LEFT JOIN d.referencedMTMessage AS ag_referencedMTMessage
				// + LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country
 
				// Es gibt also 3 verschiedene Positionen, an denen ein queryPath-Teil stehen kann:
				// 1. am anfang. Dann handelt es sich um ein attribut der domain
				//	hier muss ein join erzeugt werden, weil weitere attribute folgen (mindestens ein weiteres, dass das projection attribut des joins darstellt) 
				// 2. am ende. dann handelt es sich um ein attribut der zuletzt erzeugten aggregation (z.b. ag_referencedMTMessage_country.iso3166)
				//	hier braucht nichts mehr gejoint zu werden, sondern das attribut muss als projektion hinzugefügt werden
				// 3. in der mitte. dann handelt es sich um ein attribut der zuletzt erzeugten aggregation, die aber
				// 	gejoint werden muss, weil weitere attribute folgen
 
				// letzte aggregation
				String lastAggregationName = null;
				String currentAggregationPart, currentAggregationName;
 
				// es gibt hier mindestens zwei aggregationParts
				// erster teil beschreibt attribut von domain, also z.b. d.customer
				for (int aggregationIndex=0; aggregationIndex<=aggregationDeepth; aggregationIndex++){
					currentAggregationPart = aggregationParts.get(aggregationIndex);
					if (LOG.isDebugEnabled()){
						LOG.debug("    checking aggregationIndex="+aggregationIndex+", part="+currentAggregationPart);
					}
					if (aggregationIndex==0){
						// entspricht "LEFT JOIN d.referencedMTMessage AS ag_referencedMTMessage"
						lastAggregationName = "ag_"+currentAggregationPart;
						aggregations.put("d."+currentAggregationPart, lastAggregationName);
					}
					else if (aggregationIndex==aggregationDeepth){
						// letzter teil beschreibt das endliche attribut, dass zur projektion hinzukommt
						projections.add(Projections.property(lastAggregationName+"."+currentAggregationPart));
						if (LOG.isDebugEnabled()){
							LOG.debug("    last aggregation part found: adding projection "+lastAggregationName+"."+currentAggregationPart);
						}
					}
					else{
						// mitten drin
						// entspricht "LEFT JOIN ag_referencedMTMessage.country AS ag_referencedMTMessage_country"
						currentAggregationName = lastAggregationName+"_"+currentAggregationPart;
						aggregations.put(lastAggregationName+"."+currentAggregationPart, currentAggregationName);
						if (LOG.isDebugEnabled()){
							LOG.debug("    middle aggregation part found: adding aggregation "+lastAggregationName+"."+currentAggregationPart+" -> "+currentAggregationName);
						}
						lastAggregationName = currentAggregationName;
					}
				}
			}
 
			columnMappingsByIndex.put(property, propertyColumnIndex++);
		}
 
		// wenn aggregationen vorhanden sind, dann einfügen
		if (maxAggregationDeepth>0){
			// aggregationen (joins)
			// nach länge sortieren
			if (LOG.isDebugEnabled()){
				LOG.debug("building aggregations");
			}
			final List<String> aggregationsSizeSorted = new ArrayList<String>(aggregations.keySet());
			Collections.sort(aggregationsSizeSorted, new StringLengthComparator());
			if (LOG.isDebugEnabled()){
				LOG.debug("aggregations (sorted): "+aggregationsSizeSorted);
			}
			for (final String fromAggregation:aggregationsSizeSorted){
				criteria.createAlias(fromAggregation, aggregations.get(fromAggregation));
			}
		}
 
		// projektionen
		criteria.setProjection(projections);
 
		if (criterion!=null){
			criteria.add(criterion);
		}
 
		if (LOG.isDebugEnabled()){ 
			if (translator!=null){
				LOG.debug("created query: "+translator.toSql(criteria));
			}
			LOG.debug("columnmappings: "+columnMappingsByIndex);
		}
 
		// nun abfrage ausführen und dvofactory zum erzeugen der dvos benutzen
		final HibernateBuildByRowScrollAction scrollAction = new DvoBuildByRowScrollActionImpl(meta, columnMappingsByIndex);
		return loadByScroll(scrollAction, criteria);
	}
 
	@SuppressWarnings("unchecked")
	protected List loadByScroll(final HibernateBuildByRowScrollAction scrollAction, final Criteria criteria){
		final ArrayList data = new ArrayList();
		ScrollableResults result = null;
		try{
			if (scrollAction.getCacheMode()!=null){
				criteria.setCacheMode(scrollAction.getCacheMode());
			}
			if (scrollAction.getLockMode()!=null){
				criteria.setLockMode("d", scrollAction.getLockMode());
			}
			if (scrollAction.getScrollMode()!=null){
				result = criteria.scroll(scrollAction.getScrollMode());
			}
			else{
				result = criteria.scroll();
			}
			Object [] rowdata;
			Object resultObject;
			while (result.next()){
				rowdata = result.get();
				resultObject = scrollAction.build(rowdata);
				if (resultObject!=null){
					data.add(resultObject);
				}
			}
		}
		finally{
			if (result!=null){
				result.close();
			}
		}
		return data;
	}
 
	public void setHqlToSqlTranslator(HqlToSqlTranslator translator) {
		this.translator = translator;
	}
 
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
 
	public void afterPropertiesSet() throws Exception {
		if (sessionFactory==null){
			throw new NullPointerException("sessionFactory not set");
		}
	}
}

public class DvoEntityMeta {
	@SuppressWarnings("unused")
	private static final Log LOG = LogFactory.getLog(DvoEntityMeta.class);
 
	private final HashMap<String, String> dvoPropertiesToQueryPaths = new HashMap<String, String>();
	private final Class entityClass;
	private final Class dvoClass;
 
	public DvoEntityMeta(Class entityClass, Class dvoClass){
		this(entityClass, dvoClass, false);
	}
 
	public DvoEntityMeta(Class entityClass, Class dvoClass, boolean useSimplePropertyMapping){
		this.entityClass = entityClass;
		this.dvoClass = dvoClass;
		if (useSimplePropertyMapping){
			try {
				// My custom BeanUtil class extracts all bean-method names from the given class,
				// excluding methods like "getClass()".
				final Collection<String> properties = BeanUtil.getPropertyNamesFilteredFromClass(dvoClass);
				for (final String property:properties){
					dvoPropertiesToQueryPaths.put(property, property);
				}
			}
			catch (Exception e) {
				if (e instanceof RuntimeException){
					throw (RuntimeException) e;
				}
				else{
					final RuntimeException r = new RuntimeException(e);
					r.setStackTrace(e.getStackTrace());
					throw r;
				}
			}
		}
	}
 
 
	public Class getDvoClass() {
		return dvoClass;
	}
 
	public Class getEntityClass() {
		return entityClass;
	}
 
	public Map<String, String> getDvoPropertiesToQueryPaths() {
		return dvoPropertiesToQueryPaths;
	}
 
	public String getQueryPathForDvoProperty(String dvoProperty){
		return dvoPropertiesToQueryPaths.get(dvoProperty);
	}
 
	public void addDvoPropertiesToQueryPaths(String dvoProperty, String queryPath){
		dvoPropertiesToQueryPaths.put(dvoProperty, queryPath);
	}
 
	public String toString(){
		return "dvoClass="+dvoClass.getName()+", domainClass="+entityClass.getName()+", properties="+dvoPropertiesToQueryPaths;
	}
}

public class DvoEntityManager {
	private static final Log LOG = LogFactory.getLog(DvoEntityManager.class);
	private static DvoEntityManager INSTANCE = new DvoEntityManager();
	private HashMap<Class, DvoEntityMeta> entityMetaByDvoClass = new HashMap<Class, DvoEntityMeta>();
 
	private DvoEntityManager(){
		if (LOG.isDebugEnabled()){
			LOG.debug("creating dvo entity manager");
		}
	}
 
	public static DvoEntityManager getInstance(){
		return INSTANCE;
	}
 
	public boolean isDvo(Object o){
		if (o==null){
			return false;
		}
		return isDvo(o.getClass());
	}
 
	@SuppressWarnings("unchecked")
	public boolean isDvo(Class cls){
		if (cls==null){
			return false;
		}
		return cls.getAnnotation(DvoAnnotation.class)!=null;
	}
 
	@SuppressWarnings("unchecked")
	public void registerDvo(Class dvo){
		if (LOG.isDebugEnabled()){
			LOG.debug("registering "+dvo.getName());
		}
		if (isDvo(dvo) && !entityMetaByDvoClass.containsKey(dvo)){
			DvoAnnotation dvoAnnotation = (DvoAnnotation) dvo.getAnnotation(DvoAnnotation.class);
			final DvoEntityMeta meta = new DvoEntityMeta(dvoAnnotation.rootDomainClass(), dvo);
			// erzeugen einer entsprechenden meta-data
			final Method methods [] = dvo.getDeclaredMethods();
			final boolean defaultPropertyMapping = dvoAnnotation.defaultPropertyMapping(); 
			DvoPropertyAnnotation dvoPropertyAnnotation;
			String propertyName;
			for (final Method method:methods){
				propertyName = BeanUtil.getPropertyName(method);
				dvoPropertyAnnotation = method.getAnnotation(DvoPropertyAnnotation.class);
				if (dvoPropertyAnnotation!=null){
					meta.addDvoPropertiesToQueryPaths(propertyName, dvoPropertyAnnotation.attributePath());
				}
				else if (defaultPropertyMapping && !"class".equals(propertyName) && method.getAnnotation(Transient.class)==null && (propertyName.startsWith("get") || propertyName.startsWith("set") || propertyName.startsWith("is"))){
					meta.addDvoPropertiesToQueryPaths(propertyName, propertyName);
				}
			}
			entityMetaByDvoClass.put(dvo, meta);
			if (LOG.isDebugEnabled()){
				LOG.debug("Created entity meta: "+meta);
			}
		}
	}
 
	public void registerDvo(Object dvo){
		registerDvo(dvo.getClass());
	}
 
	public DvoEntityMeta getMetaByDvo(Class dvoClass){
		if (isDvo(dvoClass)){
			registerDvo(dvoClass);
		}
		return entityMetaByDvoClass.get(dvoClass);
	}
 
	public DvoEntityMeta getMetaByDvo(Object dvo){
		if (isDvo(dvo)){
			registerDvo(dvo);
		}
		return entityMetaByDvoClass.get(dvo.getClass());
	}
 
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface DvoAnnotation {
	Class rootDomainClass();
	boolean defaultPropertyMapping() default true;
}

@DvoAnnotation(rootDomainClass=Person.class)
public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
	// more to come
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface DvoPropertyAnnotation {
	String attributePath();
}

@DvoAnnotation(rootDomainClass=Person.class)
public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
 
	@DvoPropertyAnnotation(attributePath="lastName")
	public Long getLastName() {
		return id;
	}
 
	public void setLastName(Long id) {
		this.id = id;
	}
 
	@DvoPropertyAnnotation(attributePath="address.country.name")
	public String getCountryName() {
		return name;
	}
 
	public void setCountryName(String countryName){
		this.countryName = countryName;
	}

public class DvoBuildByRowScrollActionImpl{
	private CacheMode cacheMode;
	private LockMode lockMode;
	private DvoEntityMeta meta;
	private Map<String, Integer> propertyColumnMapping;
 
	public DvoBuildByRowScrollActionImpl(DvoEntityMeta meta, Map<String, Integer> propertyColumnMapping){
		this.meta = meta;
		this.propertyColumnMapping = propertyColumnMapping;
	}
 
	public final Object build(Object[] resultSetRow) {
		Object dvo;
		try {
			dvo = meta.getDvoClass().newInstance();
		}
		catch (Exception e) {
			final String err = "While creating instance of dvo "+meta.getDvoClass().getName()+" with default constructor";
			if (LOG.isErrorEnabled()){
				LOG.error(err, e);
			}
			if (e instanceof RuntimeException){
				throw (RuntimeException) e;
			}
			else{
				RuntimeException rt = new RuntimeException(err, e);
				rt.setStackTrace(e.getStackTrace());
				throw rt;
			}
		}
		for (final String property:propertyColumnMapping.keySet()){
			try {
				PropertyUtils.setProperty(dvo, property, resultSetRow[propertyColumnMapping.get(property)]);
			}
			catch (Exception e) {
				final String err = "While setting property \""+property+"\" from column \""+propertyColumnMapping.get(property)+"\" on dvo "+dvo.getClass().getName();
				if (LOG.isErrorEnabled()){
					LOG.error(err, e);
				}
				if (e instanceof RuntimeException){
					throw (RuntimeException) e;
				}
				else{
					RuntimeException rt = new RuntimeException(err, e);
					rt.setStackTrace(e.getStackTrace());
					throw rt;
				}
			}
		}
		return dvo;
	}
 
	public final CacheMode getCacheMode() {
		return cacheMode;
	}
 
	public final LockMode getLockMode() {
		return lockMode;
	}
 
	public final ScrollMode getScrollMode() {
		return ScrollMode.FORWARD_ONLY;
	}
}

@Entity
public class Person{
	private Long id;
	private String firstname:
	private String lastName;
	private Date birthdate;
	private String comment;
	private Address address;
 
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public Long getId(){
		return id;
	}
 
	// appropriate getters and setter for id,
	// firstname, lastname, birthdate and comment
 
	@ManyToOne
	public Address getAddress(){
		return address;
	}
}
 
@Entity
public class Address{
	private Long id;
	private String street;
	private Country country;
 
	// appropriate getters and setter for 
	// id, street and country
 
	@ManyToOne
	public Country getCountry(){
		return country;
	}
}
 
@Entity
public class Country{
	private String iso3166; 
	// iso 3166 2 letter code 
	// (uppercase), like DE for Germany
	private String name;
 
	@Id
	@Column(length=2)
	public String getIso3166(){
		return iso3166;
	}
 
	// appropriate getters and setter for name and iso3166
}

public class PersonLastNameCountryViewObject{
	private String lastName;
	private String countryName;
 
	// appropriate getters and setter
}

// Just an interface that will create a 
// view object for us for each resultset row
public interface ViewObjectFactory{
  public Object createNewViewObject();
}
 
// a cimple class to hold all ,eta data needed for building our view objects
public class ViewObjectMetaData{
  // This will hold the mappings like
  // lastName -> lastName
  // countryName -> address.country.name
  private final HashMap<String, String> 
    propertiesToObjectPaths = new HashMap<String, String>();
 
  // this will hold our initial domain class, like Person.class.
  // we need this to create a criteria in hibernate later on
  private Class domainClass;
 
  // the factory we will use to create the view objects
  private ViewObjectFactory voFactory;
 
  // as default, if no object paths are given, we assume that each view object property
  // will be mapped non-nestingly to the domain class propertys with the same name.
  // so the mapping will be something like:
  // propertyA -> propertyA
  // propertyB -> propertyB
  // will need BeanUtils to work, or make some own code with reflection
  public ViewObjectMetaData(ViewObjectFactory voFactory, 
    Class domainClass){
    this.voFactory = voFactory;
    this.domainClass = domainClass;
    try {
      Map desc = BeanUtils.describe(dtoFactory.createDto());
      desc.remove("class");
      final Collection<String> properties = 
        (Collection<String>) desc.keySet();
      for (final String property:properties){
        propertiesToObjectPaths.put(property, property);
      }
    }
    catch (Exception e) {
      // just make a runtime exception from it...
      if (e instanceof RuntimeException){
        throw (RuntimeException) e;
      }
      else{
        final RuntimeException r = new RuntimeException(e);
        r.setStackTrace(e.getStackTrace());
        throw r;
      }
    }
  }
 
  public ViewObjectMetaData(ViewObjectFactory voFactory, 
    Class domainClass, 
    Map<String, String> propertiesToObjectPaths){
    this.voFactory = voFactory;
    this.domainClass = domainClass;
    this.propertiesToObjectPaths.putAll(propertiesToObjectPaths); 
  }
 
  // appropriate getters
}

public class ViewObjectCriteriaBuilder{
 
  // just a helper class to transport 
  // criteria and columnmappings
  public static class ViewObjectCriteria{
    private Criteria criteria;
    private HashMap<String, Integer> propertyToColumnMappings = 
      new HashMap<String, Integer>();
 
    // apropriate getters/setters
  }
 
  private SessionFactory sessionFactory;
 
  // appropriate setter for the sessionFactory 
  // or just pass a current session to the next method
 
  public ViewObjectCriteria buildCriteria(ViewObjectMetaData voMetaData){
    final ViewObjectCriteria voCriteria = new ViewObjectCriteria();
 
    final Criteria criteria = sessionFactory.
      getCurrentSession().
      createCriteria("d", voMetaData.getDomainClass());
    voCriteria.setCriteria(criteria);
 
    final Map<String, String> propertiesToObjectPaths = 
      voMetaData.getPropertiesToObjectPaths();
 
    // our projections
    final ProjectionList projections = Projections.projectionList();
 
    // max. amount of aggregations in object path
    int maxAggregationDeepth = 0;
    // index of property in resultset
    int propertyColumnIndex = 0;
 
    String objectPath; // objectpath of current vo property
    // amount of aggregations in current object path
    int aggregationDeepth; 
    final ArrayList<String> aggregationParts = 
      new ArrayList<String>(5); // parts of the object path, splitted
 
 
    // in the first step we only collect information 
    // about the needed aggregations,
    // the joins will be build later on
    for (final String property:propertiesToObjectPaths.keySet()){
      objectPath = propertiesToObjectPaths.get(property);
 
      // this helper just counts the 
      // occurences of '.' in the objectPath
      aggregationDeepth = StringUtil.occurences(objectPath, '.');
 
      if (aggregationDeepth<1){
        // no aggregation, like
        // lastName -> d.lastName
        projections.add(Projections.property("d."+objectPath));
      }
      else{
        maxAggregationDeepth = 
          Math.max(maxAggregationDeepth, aggregationDeepth);
        // aggregations exist
 
        // first split the object path
        aggregationParts.clear();
        // this helper splits the objectPath 
        // on "\\." and adds all parts to the 
        // aggregationParts-list. Works the same 
        // way as String.split
        CollectionSplitter.toList(aggregationParts, objectPath, "\\.");
 
        // last aggregations alias
        String lastAggregationName = null;
        String currentAggregationPart, currentAggregationName;
 
        // when we're here, there are at least two parts in the object path
        // first part is an property of the 
        // root domain class, e. g. address -> d.address
        for (int aggregationIndex=0; 
          aggregationIndex<=aggregationDeepth; aggregationIndex++){
 
          currentAggregationPart = aggregationParts.get(aggregationIndex);
          if (aggregationIndex==0){
            // equals to "LEFT JOIN d.address AS ag_address"
            lastAggregationName = "ag_"+currentAggregationPart;
            aggregations.put(
              "d."+currentAggregationPart, 
              lastAggregationName);
          }
          else if (aggregationIndex==aggregationDeepth){
            // last part in object path, which 
            // denotes a property we want to have projected
            // equals to "SELECT ... ag_address_country.name FROM ..."
            projections.add(
              Projections.property(
                lastAggregationName+"."+currentAggregationPart));
          }
          else{
            // somewhere in the middle
            // equals to 
            // "LEFT JOIN ag_address.country AS ag_address_country"
            currentAggregationName = 
              lastAggregationName+"_"+currentAggregationPart;
            aggregations.put(
              lastAggregationName+"."+currentAggregationPart, 
              currentAggregationName);
            lastAggregationName = currentAggregationName;
          }
        }
      }
 
      // update index of property in resultset
      voCriteria.getPropertyToColumnMappings().
        put(property, propertyColumnIndex++);
    }
 
    // if there are any aggregations, we have
    // to add an alias for each to the criteria
    if (maxAggregationDeepth>0){
      // sort aggregatios (joins) by their alias length
      // this is to enshure that ag_address is 
      // added before ag_address_country
 
      final List<String> aggregationsSizeSorted = 
        new ArrayList<String>(aggregations.keySet());
 
      Collections.sort(aggregationsSizeSorted, 
        // the string length comparator just compares
        // the length of two strings
        new StringLengthComparator());
      for (final String fromAggregation:aggregationsSizeSorted){
        // here we also may use LEFT JOIN or some other join type
        criteria.createAlias(
          fromAggregation, 
          aggregations.get(fromAggregation));
      }
    }
 
    // add projections to criteria
    criteria.setProjection(projections);
 
    return voCriteria;    
  }
}

public List buildViewObjects(ViewObjectCriteria voCriteria, 
  ViewObjectMetaData voMetaData){
 
  ScrollableResults result = null;
  try{
    Criteria criteria = voCriteria.getCriteria();
    Map<String, Integer> propertyColumnMappings = 
      voCriteria.getPropertyColumnMappings();
    // some cache method or scroll lock method here, if needed
    result = criteria.scroll(ScrollMode.FORWARD_ONLY);
    Object [] rowdata;
    Object resultObject;
    final ArrayList viewObjects = new ArrayList();
    while (result.next()){
      rowdata = result.get();
      resultObject = voMetaData.getViewObjectFactory().
        createNewViewObject();
      for (final String property:
        propertyColumnMapping.keySet()){
        try {
          // also possible via reflection
          PropertyUtils.setProperty(resultObject, 
            property, rowdata[propertyColumnMappings.get(property)]);
        }
        catch (Exception e) {
          if (LOG.isErrorEnabled()){
            LOG.error("While setting property \""+
              property+"\" from column \""+
              propertyColumnMapping.get(property)+"\"", e);
          }
          resultObject = null;
        }
      }
      if (resultObject!=null){
        viewObjects.add(resultObject);
      }
    }
    return viewObjects;
  }
  finally{
    if (result!=null){
      result.close();
    }
  }
}

final Criteria criteria = getCurrentSession().createCriteria(MyDomain.class, "d");
// d ist alias für unser domain objekt
 
if (orderBy!=null && orderBy.trim().length()>0){
  // erlaubt die benutzung von z. b. d.parent.object.name zum sortieren
  if (StringUtil.occurences(orderBy, '.')>0){
    final String [] parts = orderBy.split("\\.");
    criteria.createAlias("d."+parts[0], "x"+parts[0]);
    for (int t=1; t<=parts.length-2; t++){
      criteria.createAlias("x"+parts[t-1]+"."+parts[t], "x"+parts[t]);
    }
    orderBy = "x"+parts[parts.length-2]+"."+parts[parts.length-1];
  }
  if (asc){
    criteria.addOrder( Order.asc(orderBy) );
  }
  else{
    criteria.addOrder( Order.desc(orderBy) );
  }
}

<bean name="systemProperties" 
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" 
  lazy-init="false">
  <property name="location" value="classpath:myproject.properties"/>
</bean>
 
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  <property name="url" value="${db.url}" />
  <property name="username" value="${db.user}" />
  <property name="password" value="${db.password}" />
  <property name="maxActive" value="${db.maxconnections}"/>
  <property name="maxIdle" value="${db.minconnections}"/>
  <property name="maxWait" value="1500"/>
  <property name="poolPreparedStatements" value="true"/>
  <property name="initialSize" value="${db.minconnections}"/>
</bean>
 
<!-- not explained here, but sets the default table type on create tables -->
<bean id="customTableTypeMySQLInnoDBDialectInjector" 
  class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
  <property name="staticMethod" 
    value="de.keyboardsamurais.narcanti.common.hibernate.CustomTableTypeMySQLInnoDBDialect.setTableTypeString"/>
  <property name="arguments" value="DEFAULT CHARSET=utf8 COLLATE=utf8_bin"/>
</bean>
 
<!-- AnnotationSessionFactoryBean finds annotated beans in packages automaticaly -->	
<bean id="sessionFactory" 
  class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" 
  depends-on="customTableTypeMySQLInnoDBDialectInjector">
  <property name="dataSource" ref="dataSource"/>
  <property name="annotatedPackages" value="myproject.domain"/>
  <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/>
  <property name="hibernateProperties">
    <props>
      <prop key="hibernate.dialect">
        de.keyboardsamurais.narcanti.common.hibernate.CustomTableTypeMySQLInnoDBDialect
      </prop>
      <prop key="hibernate.hbm2ddl.auto">${db.hbm2ddl.auto}</prop>
      <prop key="hibernate.order_updates">true</prop>
      <prop key="hibernate.max_fetch_depth">1</prop>
      <prop key="hibernate.jdbc.batch_size">10</prop>
      <prop key="hibernate.connection.useUnicode">true</prop>
      <prop key="hibernate.connection.characterEncoding">utf8</prop>
      <prop key="hibernate.connection.characterSetResults">utf8</prop>
      <prop key="hibernate.connection.clobCharacterEncoding">utf8</prop>
    </props>
  </property>
</bean>
 
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
</bean>
 
<!-- I preferr defining this here instead of using aspects -->
<bean id="daoTransactionProxyTemplate" abstract="true" 
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionAttributeSource">
    <bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"/>
  </property>
  <property name="transactionManager" ref="transactionManager" />
</bean>
 
<!-- for all daos with setSessionFactory -->
<bean id="daoTemplate" abstract="true">
  <property name="sessionFactory" ref="sessionFactory"/>
</bean>
 
<!-- example dao -->
<bean id="myDao" parent="daoTransactionProxyTemplate">
  <property name="target">
    <bean class="myproject.dao.MyDaoImpl" parent="daoTemplate"/>
  </property>
  <property name="proxyInterfaces" value="myproject.dao.MyDao"/>
</bean>

import java.lang.reflect.Field;
import java.util.Collections;
 
import org.hibernate.Criteria;
import org.hibernate.SessionFactory;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.hql.QueryTranslator;
import org.hibernate.hql.QueryTranslatorFactory;
import org.hibernate.hql.ast.ASTQueryTranslatorFactory;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.impl.SessionImpl;
import org.hibernate.loader.OuterJoinLoader;
import org.hibernate.loader.criteria.CriteriaLoader;
import org.hibernate.persister.entity.OuterJoinLoadable;
 
public class HibernateHqlAndCriteriaToSqlTranslator {
  private SessionFactory sessionFactory;
 
  public void setSessionFactory(SessionFactory sessionFactory){
    this.sessionFactory = sessionFactory;
  }
 
  public String toSql(Criteria criteria){
    try{
      CriteriaImpl c = (CriteriaImpl) criteria;
      SessionImpl s = (SessionImpl)c.getSession();
      SessionFactoryImplementor factory = (SessionFactoryImplementor)s.getSessionFactory();
      String[] implementors = factory.getImplementors( c.getEntityOrClassName() );
      CriteriaLoader loader = new CriteriaLoader((OuterJoinLoadable)factory.getEntityPersister(implementors[0]),
        factory, c, implementors[0], s.getEnabledFilters());
      Field f = OuterJoinLoader.class.getDeclaredField("sql");
      f.setAccessible(true);
      return (String) f.get(loader);
    }
    catch(Exception e){
      throw new RuntimeException(e); 
    }
  }
 
  public String toSql(String hqlQueryText){
    if (hqlQueryText!=null && hqlQueryText.trim().length()>0){
      final QueryTranslatorFactory translatorFactory = new ASTQueryTranslatorFactory();
      final SessionFactoryImplementor factory = 
        (SessionFactoryImplementor) sessionFactory;
      final QueryTranslator translator = translatorFactory.
        createQueryTranslator(
          hqlQueryText, 
          hqlQueryText, 
          Collections.EMPTY_MAP, factory
        );
      translator.compile(Collections.EMPTY_MAP, false);
      return translator.getSQLString(); 
    }
    return null;
  }
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<jsp:directive.page import="java.util.*"/>
<jsp:directive.page import="org.hibernate.SessionFactory"/>
<jsp:directive.page import="org.hibernate.stat.Statistics"/>
<jsp:directive.page import="org.hibernate.stat.QueryStatistics"/>
<jsp:directive.page import="java.text.Collator"/>
<jsp:directive.page import="org.hibernate.stat.EntityStatistics"/>
<jsp:directive.page import="org.hibernate.stat.CollectionStatistics"/>
<jsp:directive.page import="org.hibernate.stat.SecondLevelCacheStatistics"/>
<jsp:directive.page import="org.springframework.context.ApplicationContext"/>
<jsp:directive.page import="org.springframework.web.context.support.WebApplicationContextUtils"/>
<jsp:directive.page import="java.util.Map"/>
<jsp:directive.page import="java.util.Date"/>
<%!
	static Map<String, QueryStatistics> queryStatistics = 
		Collections.synchronizedMap(
			new TreeMap<String, QueryStatistics>(Collator.getInstance()));
	static Map<String, EntityStatistics> entityStatistics = 
		Collections.synchronizedMap(
			new TreeMap<String, EntityStatistics>(Collator.getInstance()));
	static Map<String, CollectionStatistics> collectionStatistics = 
		Collections.synchronizedMap(
			new TreeMap<String, CollectionStatistics>(Collator.getInstance()));
	static Map<String, SecondLevelCacheStatistics> secondLevelCacheStatistics = 
		Collections.synchronizedMap(new TreeMap<String, SecondLevelCacheStatistics>(Collator.getInstance()));
	static List<Long> generalStatistics = Collections.synchronizedList(new ArrayList<Long>(18));
	static{
		for (int i=0; i<9; i++){
			generalStatistics.add(new Long(-1));
		}
	}
	static Date lastUpdate;
	static Date activation;
	static Date deactivation;
 
	public class HqlToSqlTranslator {
		public String toSql(SessionFactory sessionFactory, String hqlQueryText){
		    if (hqlQueryText!=null){
 
		        final QueryTranslatorFactory ast = new ASTQueryTranslatorFactory();
	    	    final SessionFactoryImplementor factory =
	        		(SessionFactoryImplementor) sessionFactory;
		        final QueryTranslator newQueryTranslator = 
		        	ast.createQueryTranslator( 
	    	    		hqlQueryText, 
	        			hqlQueryText, 
	        			Collections.EMPTY_MAP, factory );
		        newQueryTranslator.compile( Collections.EMPTY_MAP, false );
		        return newQueryTranslator.getSQLString(); 
	    	}
 
		    return null;
		}
	}
	static HqlToSqlTranslator translator = new HqlToSqlTranslator();
 
	public static StringUtils{
		public static final String format(final Date date, final String dateformat) {
			if (date == null){
				return null;
			}
			final SimpleDateFormat sdf = new SimpleDateFormat(dateformat);
			return sdf.format(date);
		}
	}
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<title>Hibernate statistics</title>
	<style>
.c{
	text-align: center;
}
.r{
	text-align: right;
}
.l{
	text-align: left;
}
.t{
	vertical-align: top;
}
.b{
	vertical-align: bottom;
}
.odd{
	background-color: #D4D4D4;
}
.even{
	background-color: #EEEEEE;
}
.bd1{
	border: solid #888888 1px;
}
.bg1{
	background-color: #CCCCCC;
}
.bg2{
	background-color: #DDDDDD;
}
	</style>
</head>
<body>
<p/>
<%
	final ApplicationContext appContext = 
		WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
	final SessionFactory sessionFactory = 
		(SessionFactory) appContext.getBean("hibernateSessionFactory");
	final Statistics statistics = sessionFactory.getStatistics();
 
	final String action = request.getParameter("do");
	final StringBuilder info = new StringBuilder(512);
 
 
	if ("activate".equals(action) && 
			!statistics.isStatisticsEnabled()){
		statistics.setStatisticsEnabled(true);
		activation = new Date();
		info.append("Statistics enabled\n");
	}
	else if ("deactivate".equals(action) && 
			statistics.isStatisticsEnabled()){
		statistics.setStatisticsEnabled(false);
		deactivation = new Date();
		info.append("Statistics disabled\n");
	}
	else if ("clear".equals(action)){
		activation = null;
		deactivation = null;
		statistics.clear();
		generalStatistics.set(0, new Long(0));
		generalStatistics.set(1, new Long(0));
 
		generalStatistics.set(2, new Long(0));
		generalStatistics.set(3, new Long(0));
 
		generalStatistics.set(4, new Long(0));
		generalStatistics.set(5, new Long(0));
 
		generalStatistics.set(6, new Long(0));
		generalStatistics.set(7, new Long(0));
		generalStatistics.set(8, new Long(0));
		queryStatistics.clear();
		entityStatistics.clear();
		collectionStatistics.clear();
		secondLevelCacheStatistics.clear();
		info.append("Statistics cleared\n");
	}
 
	boolean active = statistics.isStatisticsEnabled();
	if (info.length()>0){
		%>
		<p/><div class="success">
				<%=HTMLEscapeWriter.escape(info.toString())%>
			</div>
		<%
	}
	%>
<p/>
<a href="hibernate.jsp">Reload</a>
<p/>
<a href="hibernate.jsp?do=<%=(active?"deactivate":"activate")%>">
<%=(active?"DEACTIVATE":"ACTIVATE")%></a> | 
<a href="hibernate.jsp?do=clear">CLEAR</a>
<%
	if (active){
		lastUpdate = new Date();
		String [] names;
 
		generalStatistics.set(0, statistics.getConnectCount());
		generalStatistics.set(1, statistics.getFlushCount());
 
		generalStatistics.set(2, statistics.getPrepareStatementCount());
		generalStatistics.set(3, statistics.getCloseStatementCount());
 
		generalStatistics.set(4, statistics.getSessionCloseCount());
		generalStatistics.set(5, statistics.getSessionOpenCount());
 
		generalStatistics.set(6, statistics.getTransactionCount());
		generalStatistics.set(7, statistics.getSuccessfulTransactionCount());
		generalStatistics.set(8, statistics.getOptimisticFailureCount());
 
		queryStatistics.clear();
		names = statistics.getQueries();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				queryStatistics.put(names[i], 
					statistics.getQueryStatistics(names[i]));
			}
		}
 
		entityStatistics.clear();
		names = statistics.getEntityNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				entityStatistics.put(names[i], 
					statistics.getEntityStatistics(names[i]));
			}
		}
 
		collectionStatistics.clear();
		names = statistics.getCollectionRoleNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				collectionStatistics.put(names[i], 
					statistics.getCollectionStatistics(names[i]));
			}
		}
 
		secondLevelCacheStatistics.clear();
		names = statistics.getSecondLevelCacheRegionNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				secondLevelCacheStatistics.put(names[i], 
					statistics.getSecondLevelCacheStatistics(names[i]));
			}
		}
	}
 
	%>
	<p/>
	Last update: <%=(lastUpdate!=null?
		StringUtils.format(lastUpdate, "dd.MM.yy HH:mm:ss"):"none")%><br/>
	Activation: <%=(activation!=null?
		StringUtils.format(activation, "dd.MM.yy HH:mm:ss"):"none")%><br/>
	Deactivation: <%=(deactivation!=null?
		StringUtils.format(deactivation, "dd.MM.yy HH:mm:ss"):"none")%><br/>
	Active duration: <%=(activation!=null?
		StringUtils.formatTime((deactivation!=null?
			deactivation.getTime():
			new Date().getTime())-activation.getTime()):
			"none")%>
	<p/>
	<%
	boolean hasGeneral = false;
	for (int i=0; i<9; i++){
		if (generalStatistics.get(i).longValue()>-1){
			hasGeneral = true;
			break;
		}
	}
	if (hasGeneral){
		%>
		<table>
			<tr>
				<th class="c bd1 bg1">Connects</th>
				<td><%=generalStatistics.get(0)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Flushes</th>
				<td><%=generalStatistics.get(1)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Prepare statements</th>
				<td><%=generalStatistics.get(2)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Close statements</th>
				<td><%=generalStatistics.get(3)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Session opens</th>
				<td><%=generalStatistics.get(5)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Session closes</th>
				<td><%=generalStatistics.get(4)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Total Transactions</th>
				<td><%=generalStatistics.get(6)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Successfull Transactions</th>
				<td><%=generalStatistics.get(7)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Optimistic failures</th>
				<td><%=generalStatistics.get(8)%></td>
			</tr>
		</table>
		<p/>
		<%
	}
	%>
 
	<%
	if (queryStatistics.size()>0){
		%>
		<table width="100%">
			<tr><th colspan="11" class="c bd1 bg2">Query statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">HQL Query</th>
				<th class="c bd1 bg1">SQL Query</th>
				<th class="c bd1 bg1">Calls</th>
				<th class="c bd1 bg1">Total rowcount</th>
				<th class="c bd1 bg1">Max dur.</th>
				<th class="c bd1 bg1">Min dur.</th>
				<th class="c bd1 bg1">Avg dur.</th>
				<th class="c bd1 bg1">Total dur.</th>
				<th class="c bd1 bg1">Cache hits</th>
				<th class="c bd1 bg1">Cache miss</th>
				<th class="c bd1 bg1">Cache put</th>
			</tr>
		<%
		QueryStatistics queryStats;
		boolean odd = true;
		for (String query:queryStatistics.keySet()){
			queryStats = queryStatistics.get(query);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td class="t"><%=query%></td>
				<td><small><%=translator.toSql(sessionFactory, query)%></small></td>
				<td class="t"><%=queryStats.getExecutionCount()%></td>
				<td class="t"><%=queryStats.getExecutionRowCount()%></td>
				<td class="t"><%=queryStats.getExecutionMaxTime()%></td>
				<td class="t"><%=queryStats.getExecutionMinTime()%></td>
				<td class="t"><%=queryStats.getExecutionAvgTime()%></td>
				<td class="t">
					<%=queryStats.getExecutionAvgTime()*queryStats.getExecutionCount()%>
				</td>
				<td class="t"><%=queryStats.getCacheHitCount()%></td>
				<td class="t"><%=queryStats.getCacheMissCount()%></td>
				<td class="t"><%=queryStats.getCachePutCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (entityStatistics.size()>0){
	%>
		<table width="100%">
			<tr><th colspan="7" class="c bd1 bg2">Entity statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Entity</th>
				<th class="c bd1 bg1">Loads</th>
				<th class="c bd1 bg1">Fetches</th>
				<th class="c bd1 bg1">Inserts</th>
				<th class="c bd1 bg1">Updates</th>
				<th class="c bd1 bg1">Deletes</th>
				<th class="c bd1 bg1">Optimistic failures</th>
			</tr>
		<%
		EntityStatistics entityStats;
		boolean odd = true;
		for (String entity:entityStatistics.keySet()){
			entityStats = entityStatistics.get(entity);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=entity%></td>
				<td><%=entityStats.getLoadCount()%></td>
				<td><%=entityStats.getFetchCount()%></td>
				<td><%=entityStats.getInsertCount()%></td>
				<td><%=entityStats.getUpdateCount()%></td>
				<td><%=entityStats.getDeleteCount()%></td>
				<td><%=entityStats.getOptimisticFailureCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (collectionStatistics.size()>0){
	%>
		<table width="100%">
			<tr><th colspan="6" class="c bd1 bg2">Collection statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Role</th>
				<th class="c bd1 bg1">Loads</th>
				<th class="c bd1 bg1">Fetches</th>
				<th class="c bd1 bg1">Updates</th>
				<th class="c bd1 bg1">Recreate</th>
				<th class="c bd1 bg1">Remove</th>
			</tr>
		<%
		CollectionStatistics collectionStats;
		boolean odd = true;
		for (String collection:collectionStatistics.keySet()){
			collectionStats = collectionStatistics.get(collection);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=collection%></td>
				<td><%=collectionStats.getLoadCount()%></td>
				<td><%=collectionStats.getFetchCount()%></td>
				<td><%=collectionStats.getUpdateCount()%></td>
				<td><%=collectionStats.getRecreateCount()%></td>
				<td><%=collectionStats.getRemoveCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (secondLevelCacheStatistics.size()>0){
		long totalSizeInMemory = 0;
	%>
		<table width="100%">
			<tr><th colspan="7" class="c bd1 bg2">2nd level cache statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Regionname</th>
				<th class="c bd1 bg1">Puts</th>
				<th class="c bd1 bg1">Hits</th>
				<th class="c bd1 bg1">Misses</th>
				<th class="c bd1 bg1">Elements in memory</th>
				<th class="c bd1 bg1">Size in memory</th>
				<th class="c bd1 bg1">Elements on disk</th>
			</tr>
		<%
		SecondLevelCacheStatistics cacheStats;
		boolean odd = true;
		for (String cache:secondLevelCacheStatistics.keySet()){
			cacheStats = secondLevelCacheStatistics.get(cache);
			totalSizeInMemory += cacheStats.getSizeInMemory();
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=cache%></td>
				<td><%=cacheStats.getPutCount()%></td>
				<td><%=cacheStats.getHitCount()%></td>
				<td><%=cacheStats.getMissCount()%></td>
				<td><%=cacheStats.getElementCountInMemory()%></td>
				<td><%=cacheStats.getSizeInMemory()%></td>
				<td><%=cacheStats.getElementCountOnDisk()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
			<tr>
				<td colspan="5">&nbsp;</td>
				<td><%=totalSizeInMemory%></td>
				<td>&nbsp;</td>
			</tr>
		</table>
		<p/>
	<%
	}
	%>
</body>
</html>

import org.hibernate.SessionFactory;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.hql.QueryTranslator;
import org.hibernate.hql.QueryTranslatorFactory;
import org.hibernate.hql.ast.ASTQueryTranslatorFactory;
 
public class HqlToSqlTranslator {
  private SessionFactory sessionFactory;
 
  public void setSessionFactory(SessionFactory sessionFactory){
    this.sessionFactory = sessionFactory;
  }
 
  public String toSql(String hqlQueryText){
    if (hqlQueryText!=null && hqlQueryText.trim().length()>0){
      final QueryTranslatorFactory translatorFactory = new ASTQueryTranslatorFactory();
      final SessionFactoryImplementor factory = 
        (SessionFactoryImplementor) sessionFactory;
      final QueryTranslator translator = translatorFactory.
        createQueryTranslator(
          hqlQueryText, 
          hqlQueryText, 
          Collections.EMPTY_MAP, factory
        );
      translator.compile(Collections.EMPTY_MAP, false);
      return translator.getSQLString(); 
    }
    return null;
  }
}

package project.dao;
 
import java.io.Serializable;
import java.util.List;
 
/**
 * D = domain object<br/>
 * K = Primary key of domain object, eg. Long<br/>
 * <p/>
 * @author M. Serhat Cinar
 *
 */
public interface Dao<D, K extends Serializable> {
	public D getById(K id);
	public void save(D d);
	public void delete(D d);
	public List<D> getAll(int offset, int amount);
	public List<D> getAll(int offset, int amount, String orderBy, boolean asc);
 
	/**
	 * Count of all available objects
	 * 
	 * @return Anzahl
	 */
	public long getTotalCount();
}

package project.dao.hibernate;
 
import java.io.Serializable;
import java.util.List;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
 
import project.dao.Dao;
 
/**
 * 
 * @author M. Serhat Cinar
 */
public abstract class AbstractDaoImpl<D, K extends Serializable> implements Dao<D, K> {
	private Log LOG = LogFactory.getLog(getClass());
	private SessionFactory sessionFactory;
 
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
 
	protected Session getCurrentSession() {
		return sessionFactory.getCurrentSession();
	}
 
	public void delete(D d) {
		getCurrentSession().delete(d);
	}
 
	@SuppressWarnings("unchecked")
	public List<D> getAll(int offset, int amount) {
		if (LOG.isDebugEnabled()){
			LOG.debug("getAll("+offset+","+amount+")");
		}
		List<D> list = getCurrentSession()
			.createQuery("FROM "+getDomain().getSimpleName())
			.setMaxResults(amount)
			.setFirstResult(offset)
			//.setFetchSize(amount)
			.list();
		if (LOG.isDebugEnabled()){
			LOG.debug("found "+list.size()+" datasets");
		}
		return list; 
	}
 
	@SuppressWarnings("unchecked")
	public List<D> getAll(int offset, int amount, String orderBy, boolean asc) {
		if (LOG.isDebugEnabled()){
			LOG.debug("getAll("+offset+","+amount+","+orderBy+","+
				(asc?"asc":"desc")+")");
		}
		List<D> list = getCurrentSession()
			.createQuery("FROM "+getDomain().getSimpleName()+
				" d ORDER BY d."+orderBy+" "+(asc?"ASC":"DESC"))
			.setMaxResults(amount)
			.setFirstResult(offset)
			//.setFetchSize(amount)
			.list();
		if (LOG.isDebugEnabled()){
			LOG.debug("found "+list.size()+" datasets");
		}
		return list; 
	}
 
	@SuppressWarnings("unchecked")
	public D getById(K id) {
		if (id==null){
			return null;
		}
		return (D) getCurrentSession().get(getDomain(), id);
	}
 
	/**
	 * Returns the domain class of this DAO. That's the class which is processed by this DAO.
	 * 
	 * @return domainclass of this DAO
	 */
	public abstract Class getDomain();
 
	public long getTotalCount() {
		Object result = getCurrentSession()
			.createQuery("SELECT COUNT(d.id) FROM "+
				getDomain().getSimpleName()+" d")
			.setMaxResults(1)
			.uniqueResult();
		if (result==null) return 0L;
		if (result instanceof Integer){
			return ((Integer) result).longValue(); 
		}
		return ((Long) result).longValue();
	}
 
	public void save(D d) {
		getCurrentSession().saveOrUpdate(d);
	}
}

String value = new String(request.getParameter("name").getBytes("ISO-8859-1"), "UTF-8");

useUnicode=true&characterEncoding=utf8&characterResultSets=utf8
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection("jdbc:mysql://localhost/db?user=blah&password=blah&
  useUnicode=true&characterEncoding=UTF-8" );

<property name="hibernateProperties">
  <props>
    <prop key="hibernate.dialect">
        org.hibernate.dialect.MySQLInnoDBDialect
    </prop>
    <prop key="hibernate.show_sql">false</prop>
    <prop key="hibernate.hbm2ddl.auto">update</prop>
    <prop key="hibernate.cache.use_second_level_cache">true</prop>
    <prop key="hibernate.cache.provider_class">
        org.hibernate.cache.EhCacheProvider
    </prop>
    <prop key="hibernate.cache.use_query_cache">false</prop>
    <prop key="hibernate.current_session_context_class">thread</prop>
    <prop key="connection.provider_class">
        org.hibernate.connection.C3P0ConnectionProvider
    </prop>
    <prop key="hibernate.connection.useUnicode">true</prop>
    <prop key="hibernate.connection.characterEncoding">utf8</prop>
    <prop key="hibernate.connection.characterSetResults">utf8</prop>
    <prop key="hibernate.connection.clobCharacterEncoding">utf8</prop>
..

/**
 * Will decode unicode escapes to character.
 * ä will be converted to ä. Also supports hex-unicode like
 * &amp;#xE4; for &amp;#228;.<br/>
 * No support for named entities.
 * 
 * @param encoded
 * @return
 */
public static final 
	String decodeUnicodeEntities(String encoded){
 
	if (encoded==null) return null;
	final StringBuilder target = 
		new StringBuilder(encoded.length());
	char c;
	final StringBuilder entityBuffer = 
		new StringBuilder(10);
	final int state_normal = 0;
	final int state_was_ampersand = 1;
	final int state_in_entity_code = 2;
	int state = state_normal; 
	for (int i=0; i<encoded.length(); 
		i++){
 
		c = encoded.charAt(i);
		switch(state){
			case state_normal:
			default:
				if (c=='&'){
					state = state_was_ampersand;
				}
				else{
					target.append(c);
				}
				break;
			case state_was_ampersand:
				if (c=='#'){
					state = state_in_entity_code;
					entityBuffer.
						delete(0, entityBuffer.length());
				}
				else{
					state  = state_normal;
					target.append('&');
				}
				break;
			case state_in_entity_code:
				if (c==';'){
					// end of entity
					int value;
					if ("x".equalsIgnoreCase(
						entityBuffer.substring(0, 1))){
						// hex
						value = Integer.parseInt(
							entityBuffer.substring(1), 16);
					}
					else{
						value = Integer.parseInt(
							entityBuffer.toString());
					}
					target.append(
						Character.toChars(value));
					state = state_normal;
				}
				else{
					// within entity
					entityBuffer.append(c);
				}
				break;
		}
	}
 
	return target.toString();
}
 
public static final String 
	encodeUnicodeEntities(String uncoded){
 
	if (uncoded==null) return null;
	char c;
	int ci;
	final StringBuilder target = 
		new StringBuilder(uncoded.length()*7);
	for (int i=0; i<uncoded.length(); i++){
		c = uncoded.charAt(i);
		ci = 0xffff & c;
		if (ci >= 160 || c=='&'){
			// Not 7 Bit use the unicode system
			target.append("&#");
			target.append(Integer.toString(ci));
			target.append(';');
		}
		else{
			// nothing special only 7 Bit
			target.append(c);
		}
	}
 
	return target.toString();
}

<jsp:directive.page import="narcanti.service.Services"/>
<jsp:directive.page import="java.util.*"/>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<jsp:directive.page import="narcanti.util.HTMLEscapeWriter"/>
<jsp:directive.page import="org.hibernate.SessionFactory"/>
<jsp:directive.page import="org.hibernate.stat.Statistics"/>
<jsp:directive.page import="narcanti.util.StringUtils"/>
<jsp:directive.page import="org.hibernate.stat.QueryStatistics"/>
<jsp:directive.page import="java.text.Collator"/>
<jsp:directive.page import="org.hibernate.stat.EntityStatistics"/>
<jsp:directive.page import="org.hibernate.stat.CollectionStatistics"/>
<jsp:directive.page import="org.hibernate.stat.SecondLevelCacheStatistics"/>
<%!
	static Map<String, QueryStatistics> queryStatistics = 
		Collections.synchronizedMap(
		new TreeMap<String, QueryStatistics>(Collator.getInstance()));
	static Map<String, EntityStatistics> entityStatistics = 
		Collections.synchronizedMap(
		new TreeMap<String, EntityStatistics>(Collator.getInstance()));
	static Map<String, CollectionStatistics> collectionStatistics = 
		Collections.synchronizedMap(
		new TreeMap<String, CollectionStatistics>(Collator.getInstance()));
	static Map<String, SecondLevelCacheStatistics> secondLevelCacheStatistics = 
		Collections.synchronizedMap(
		new TreeMap<String, SecondLevelCacheStatistics>(Collator.getInstance()));
	static List<Long> generalStatistics = 
		Collections.synchronizedList(new ArrayList<Long>(18));
	static{
		for (int i=0; i<9; i++){
			generalStatistics.add(new Long(-1));
		}
	}
	static Date lastUpdate;
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<title>Hibernate statistics</title>
	<link href="../default.css" rel="stylesheet" type="text/css"></link>
</head>
<body>
<p/>
<%
	String action = request.getParameter("do");
	StringBuilder errors = new StringBuilder(512);
	StringBuilder warnings = new StringBuilder(512);
	StringBuilder info = new StringBuilder(512);
 
	// hier die Session Factory von Hibernate holen
	SessionFactory sessionFactory = Services.getInstance().getSessionFactory();
	Statistics statistics = sessionFactory.getStatistics();
 
	if ("activate".equals(action) && !statistics.isStatisticsEnabled()){
		statistics.setStatisticsEnabled(true);
		info.append("Statistics enabled\n");
	}
	else if ("deactivate".equals(action) && statistics.isStatisticsEnabled()){
		statistics.setStatisticsEnabled(false);
		info.append("Statistics disabled\n");
	}
 
	boolean active = statistics.isStatisticsEnabled();
 
	if (errors.length()>0){
		%>
		<p/>
		<div class="error"><%=HTMLEscapeWriter.escape(errors.toString())%></div>
		<%
	}
	if (warnings.length()>0){
		%>
		<p/>
		<div class="warn"><%=HTMLEscapeWriter.escape(warnings.toString())%></div>
		<%
	}
	if (info.length()>0){
		%>
		<p/>
		<div class="success"><%=HTMLEscapeWriter.escape(info.toString())%></div>
		<%
	}
	%>
<p/>
<a href="hibernate.jsp">Reload</a>
<p/>
<a href="hibernate.jsp?do=<%=(active?"deactivate":"activate")%>">
<%=(active?"DEACTIVATE":"ACTIVATE")%></a>
<%
	if (active){
		lastUpdate = new Date();
		String [] names;
 
		generalStatistics.set(0, statistics.getConnectCount());
		generalStatistics.set(1, statistics.getFlushCount());
 
		generalStatistics.set(2, statistics.getPrepareStatementCount());
		generalStatistics.set(3, statistics.getCloseStatementCount());
 
		generalStatistics.set(4, statistics.getSessionCloseCount());
		generalStatistics.set(5, statistics.getSessionOpenCount());
 
		generalStatistics.set(6, statistics.getTransactionCount());
		generalStatistics.set(7, statistics.getSuccessfulTransactionCount());
		generalStatistics.set(8, statistics.getOptimisticFailureCount());
 
		queryStatistics.clear();
		names = statistics.getQueries();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				queryStatistics.put(names[i], 
					statistics.getQueryStatistics(names[i]));
			}
		}
 
		entityStatistics.clear();
		names = statistics.getEntityNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				entityStatistics.put(names[i], 
					statistics.getEntityStatistics(names[i]));
			}
		}
 
		collectionStatistics.clear();
		names = statistics.getCollectionRoleNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				collectionStatistics.put(names[i], 
					statistics.getCollectionStatistics(names[i]));
			}
		}
 
		secondLevelCacheStatistics.clear();
		names = statistics.getSecondLevelCacheRegionNames();
		if (names!=null && names.length>0){
			for (int i=0; i<names.length; i++){
				secondLevelCacheStatistics.put(names[i], 
					statistics.getSecondLevelCacheStatistics(names[i]));
			}
		}
	}
 
	%>
	<p/>
	Last update: <%=(lastUpdate!=null?StringUtils.format(lastUpdate, 
		"dd.MM.yy HH:mm:ss"):"none")%>
	<p/>
	<%
	boolean hasGeneral = false;
	for (int i=0; i<9; i++){
		if (generalStatistics.get(i).longValue()>-1){
			hasGeneral = true;
			break;
		}
	}
	if (hasGeneral){
		%>
		<table>
			<tr>
				<th class="c bd1 bg1">Connects</th>
				<td><%=generalStatistics.get(0)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Flushes</th>
				<td><%=generalStatistics.get(1)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Prepare statements</th>
				<td><%=generalStatistics.get(2)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Close statements</th>
				<td><%=generalStatistics.get(3)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Session opens</th>
				<td><%=generalStatistics.get(5)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Session closes</th>
				<td><%=generalStatistics.get(4)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Total Transactions</th>
				<td><%=generalStatistics.get(6)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Successfull Transactions</th>
				<td><%=generalStatistics.get(7)%></td>
			</tr>
			<tr>
				<th class="c bd1 bg1">Optimistic failures</th>
				<td><%=generalStatistics.get(8)%></td>
			</tr>
		</table>
		<p/>
		<%
	}
	%>
 
	<%
	if (queryStatistics.size()>0){
		%>
		<table width="100%">
			<tr><th colspan="10" class="c bd1 bg2">Query statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Query</th>
				<th class="c bd1 bg1">Calls</th>
				<th class="c bd1 bg1">Total rowcount</th>
				<th class="c bd1 bg1">Max dur.</th>
				<th class="c bd1 bg1">Min dur.</th>
				<th class="c bd1 bg1">Avg dur.</th>
				<th class="c bd1 bg1">Total dur.</th>
				<th class="c bd1 bg1">Cache hits</th>
				<th class="c bd1 bg1">Cache miss</th>
				<th class="c bd1 bg1">Cache put</th>
			</tr>
		<%
		Iterator<String> queryIter = queryStatistics.keySet().iterator();
		String query;
		QueryStatistics queryStats;
		boolean odd = true;
		while (queryIter.hasNext()){
			query = queryIter.next();
			queryStats = queryStatistics.get(query);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=query%></td>
				<td><%=queryStats.getExecutionCount()%></td>
				<td><%=queryStats.getExecutionRowCount()%></td>
				<td><%=queryStats.getExecutionMaxTime()%></td>
				<td><%=queryStats.getExecutionMinTime()%></td>
				<td><%=queryStats.getExecutionAvgTime()%></td>
				<td><%=queryStats.getExecutionAvgTime()*queryStats.getExecutionCount()%></td>
				<td><%=queryStats.getCacheHitCount()%></td>
				<td><%=queryStats.getCacheMissCount()%></td>
				<td><%=queryStats.getCachePutCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (entityStatistics.size()>0){
	%>
		<table width="100%">
			<tr><th colspan="7" class="c bd1 bg2">Entity statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Entity</th>
				<th class="c bd1 bg1">Loads</th>
				<th class="c bd1 bg1">Fetches</th>
				<th class="c bd1 bg1">Inserts</th>
				<th class="c bd1 bg1">Updates</th>
				<th class="c bd1 bg1">Deletes</th>
				<th class="c bd1 bg1">Optimistic failures</th>
			</tr>
		<%
		Iterator<String> entityIter = entityStatistics.keySet().iterator();
		String entity;
		EntityStatistics entityStats;
		boolean odd = true;
		while (entityIter.hasNext()){
			entity = entityIter.next();
			entityStats = entityStatistics.get(entity);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=entity%></td>
				<td><%=entityStats.getLoadCount()%></td>
				<td><%=entityStats.getFetchCount()%></td>
				<td><%=entityStats.getInsertCount()%></td>
				<td><%=entityStats.getUpdateCount()%></td>
				<td><%=entityStats.getDeleteCount()%></td>
				<td><%=entityStats.getOptimisticFailureCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (collectionStatistics.size()>0){
	%>
		<table width="100%">
			<tr><th colspan="6" class="c bd1 bg2">Collection statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Role</th>
				<th class="c bd1 bg1">Loads</th>
				<th class="c bd1 bg1">Fetches</th>
				<th class="c bd1 bg1">Updates</th>
				<th class="c bd1 bg1">Recreate</th>
				<th class="c bd1 bg1">Remove</th>
			</tr>
		<%
		Iterator<String> collectionIter = collectionStatistics.keySet().iterator();
		String collection;
		CollectionStatistics collectionStats;
		boolean odd = true;
		while (collectionIter.hasNext()){
			collection = collectionIter.next();
			collectionStats = collectionStatistics.get(collection);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=collection%></td>
				<td><%=collectionStats.getLoadCount()%></td>
				<td><%=collectionStats.getFetchCount()%></td>
				<td><%=collectionStats.getUpdateCount()%></td>
				<td><%=collectionStats.getRecreateCount()%></td>
				<td><%=collectionStats.getRemoveCount()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
 
	if (secondLevelCacheStatistics.size()>0){
	%>
		<table width="100%">
			<tr><th colspan="7" class="c bd1 bg2">2nd level cache statistics</th></tr>
			<tr>
				<th class="c bd1 bg1">Regionname</th>
				<th class="c bd1 bg1">Puts</th>
				<th class="c bd1 bg1">Hits</th>
				<th class="c bd1 bg1">Misses</th>
				<th class="c bd1 bg1">Elements in memory</th>
				<th class="c bd1 bg1">Size in memory</th>
				<th class="c bd1 bg1">Elements on disk</th>
			</tr>
		<%
		Iterator<String> cacheIter = secondLevelCacheStatistics.keySet().iterator();
		String cache;
		SecondLevelCacheStatistics cacheStats;
		boolean odd = true;
		while (cacheIter.hasNext()){
			cache = cacheIter.next();
			cacheStats = secondLevelCacheStatistics.get(cache);
			%>
			<tr class="<%=(odd?"odd":"even")%>">
				<td><%=cache%></td>
				<td><%=cacheStats.getPutCount()%></td>
				<td><%=cacheStats.getHitCount()%></td>
				<td><%=cacheStats.getMissCount()%></td>
				<td><%=cacheStats.getElementCountInMemory()%></td>
				<td><%=cacheStats.getSizeInMemory()%></td>
				<td><%=cacheStats.getElementCountOnDisk()%></td>
			</tr>
			<%
			odd = !odd;
		}
		%>
		</table>
		<p/>
	<%
	}
	%>
</body>
</html>