Java tutorial
/** * Helios, OpenSource Monitoring * Brought to you by the Helios Development Group * * Copyright 2012, Helios Development Group and individual contributors * as indicated by the @author tags. See the copyright.txt file in the * distribution for a full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. * */ package org.helios.apmrouter.catalog.api.impl; import java.io.Serializable; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.hibernate.CacheMode; import org.hibernate.Criteria; import org.hibernate.FetchMode; import org.hibernate.FlushMode; import org.hibernate.Session; import org.hibernate.criterion.DetachedCriteria; import org.hibernate.criterion.ProjectionList; /** * <p>Title: ExtendedDetachedCriteria</p> * <p>Description: An extended implementation of {@link DetachedCriteria} that facades some of the functionality only found in the attached {@link Criteria} class. * Extended functionality is applied when {@link DetachedCriteria#getExecutableCriteria(org.hibernate.Session)} is called.</p> * <p>Company: Helios Development Group LLC</p> * @author Whitehead (nwhitehead AT heliosdev DOT org) * <p><code>org.helios.apmrouter.catalog.api.impl.ExtendedDetachedCriteria</code></p> */ public class ExtendedDetachedCriteria extends DetachedCriteria implements Parsed<ExtendedDetachedCriteria>, ExecutableQuery { /** */ private static final long serialVersionUID = -1135481743060334307L; /** The op code to set the query fetch size */ public static final String EXT_FETCHSIZE = "fs"; /** The op code to set the query timeout in seconds */ public static final String EXT_TIMEOUT = "t"; /** The op code to enable query caching for this query */ public static final String EXT_CACHEABLE = "c"; /** The op code to set override the flush mode for this query */ public static final String EXT_FLUSHMODE = "fm"; /** The op code to set override the cache mode for this query */ public static final String EXT_CACHEMODE = "cm"; /** The op code to set the maximum number of results */ public static final String EXT_MAXRESULTS = "mr"; /** The op code to set first result returned for this query */ public static final String EXT_FIRSTRESULT = "fr"; /** The op code to set the cache region name to be used for query caching for this query */ public static final String EXT_CACHEREGION = "cr"; /** The op code to set the fetch mode for this query */ public static final String EXT_FETCHMODE = "fmd"; /** The op code to to start setting projections on the query */ public static final String EXT_PROJS = "projs"; /** The op code to to add a projection to the projection list of this query */ public static final String EXT_PROJ = "proj"; /** The op code to to add a criterion to this query */ public static final String EXT_CRIT = "cond"; /** The recognized op codes */ public static final Set<String> ATTR_OP_CODES; /** The available fetch modes (since the class does not have a static parse) */ private static final Map<String, FetchMode> fetchModes = new HashMap<String, FetchMode>(5); /** Method handles for the extended Criteria methods, keyed by the JSON op code */ private static final Map<String, MethodHandle> myMethodHandles = new HashMap<String, MethodHandle>(); /** Method handles for the attached Criteria methods, keyed by the JSON op code */ private static final Map<String, MethodHandle> criteriaMethodHandles = new HashMap<String, MethodHandle>(); /** Saved extended Criteria method values, keyed by the JSON op code */ private final Map<String, Serializable> extendedCriteria = new HashMap<String, Serializable>(); /** a map of {@link Criteria} methods keyed by method name */ private static final Map<String, Method> criteriaMethods = new HashMap<String, Method>(); /** The running projection list for this query */ protected ProjectionListAccumulator projectionList = null; static { Set<String> tmp = new HashSet<String>(); for (Field field : ExtendedDetachedCriteria.class.getDeclaredFields()) { if (Modifier.isStatic(field.getModifiers()) && field.getName().startsWith("EXT_")) { try { tmp.add((String) field.get(null)); } catch (Exception e) { throw new RuntimeException(e); } } } ATTR_OP_CODES = Collections.unmodifiableSet(tmp); System.out.println("" + ATTR_OP_CODES.size() + " Op Codes:" + ATTR_OP_CODES); for (Field field : FetchMode.class.getDeclaredFields()) { if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(FetchMode.class)) { try { fetchModes.put(field.getName(), (FetchMode) field.get(null)); } catch (Exception e) { throw new RuntimeException(e); } } } for (Method m : Criteria.class.getDeclaredMethods()) { if (m.getName().startsWith("set")) { criteriaMethods.put(m.getName(), m); } } for (Method m : ExtendedDetachedCriteria.class.getDeclaredMethods()) { if (!Modifier.isStatic(m.getModifiers()) && m.getName().startsWith("set")) { saveHandle(m); } } saveHandle(EXT_PROJS, ExtendedDetachedCriteria.class, "setProjection", Object[].class); saveHandle(EXT_PROJ, ExtendedDetachedCriteria.class, "setProjection", Object[].class); saveHandle(EXT_CRIT, ExtendedDetachedCriteria.class, "createCriteria", Object.class); // System.out.println("Criteria Codes:" + criteriaMethodHandles.keySet()); // System.out.println("My Codes:" + myMethodHandles.keySet()); } private static void saveHandle(String key, Class<?> clazz, String name, Class<?>... pattern) { try { Method m = null; try { m = clazz.getDeclaredMethod(name, pattern); } catch (NoSuchMethodException nex) { m = clazz.getMethod(name, pattern); } saveHandle(key, m); } catch (Exception ex) { throw new RuntimeException(ex); } } private static void saveHandle(Method method) { saveHandle(null, method); } private static void saveHandle(String dkey, Method method) { try { MethodType desc = MethodType.methodType(method.getReturnType(), method.getParameterTypes()); MethodHandle mh = MethodHandles.lookup().findVirtual(method.getDeclaringClass(), method.getName(), desc); String key = dkey != null ? dkey : (method.getName().equals("setFetchMode")) ? "fmd" : getKey(method.getName()); myMethodHandles.put(key, mh); if (method.getDeclaringClass() != ExtendedDetachedCriteria.class) { System.out.println(method.toGenericString()); } if (method.getDeclaringClass() == Criteria.class) { Method cmethod = criteriaMethods.get(method.getName()); desc = MethodType.methodType(Criteria.class, cmethod.getParameterTypes()); mh = MethodHandles.lookup().findVirtual(Criteria.class, method.getName(), desc); criteriaMethodHandles.put(key, mh); } } catch (Exception ex) { ex.printStackTrace(System.err); throw new RuntimeException(ex); } } /** The first int of upper case letters */ private static final int LOWER = 'A'; /** The last int of upper case letters */ private static final int UPPER = 'Z'; @Override public Parsed<ExtendedDetachedCriteria> applyPrimitive(String op, Object value) { Object nestedReturn = null; try { if (value.getClass().isArray()) { Object[] args = new Object[Array.getLength(value) + 1]; args[0] = this; System.arraycopy(value, 0, args, 1, args.length - 1); nestedReturn = myMethodHandles.get(op).invokeWithArguments(args); } else { nestedReturn = myMethodHandles.get(op).invoke(this, value); } if (nestedReturn != null && nestedReturn != this && nestedReturn instanceof Parsed) { return (Parsed<ExtendedDetachedCriteria>) nestedReturn; } return this; } catch (Throwable t) { throw new RuntimeException(t); } } /** * {@inheritDoc} * @see org.helios.apmrouter.catalog.api.impl.ExecutableQuery#execute(org.hibernate.Session) */ @Override public List<?> execute(Session session) { Criteria criteria = getExecutableCriteria(session); return criteria.list(); } /** * {@inheritDoc} * @see org.helios.apmrouter.catalog.api.impl.ExecutableQuery#unique(org.hibernate.Session) */ @Override public Object unique(Session session) { Criteria criteria = getExecutableCriteria(session); return criteria.uniqueResult(); } private static String getKey(String methodName) { StringBuilder b = new StringBuilder(); for (int c : methodName.replace("set", "").toCharArray()) { if (c >= LOWER && c <= UPPER) { b.append((char) c); } } return b.toString().toLowerCase(); } /** * Creates a new ExtendedDetachedCriteria * @param entityName the entity name this query is for */ public ExtendedDetachedCriteria(String entityName) { super(entityName); } /** * Creates a new ExtendedDetachedCriteria * @param entityName the entity name this query is for * @param alias the entity alias */ public ExtendedDetachedCriteria(String entityName, String alias) { super(entityName, alias); } /** * Sets or adds a projection * @param args The projection op arguments * @return the projection list parsed. */ public Parsed<ProjectionList> setProjection(Object... args) { if (projectionList == null) { projectionList = new ProjectionListAccumulator(); } Object[] pargs = null; if (args.length > 1) { pargs = new Object[args.length - 1]; System.arraycopy(args, 1, pargs, 0, pargs.length); } return projectionList.applyPrimitive((String) args[0], pargs); } /** * {@inheritDoc} * @see org.hibernate.criterion.DetachedCriteria#getExecutableCriteria(org.hibernate.Session) */ @Override public Criteria getExecutableCriteria(Session session) { if (projectionList != null) this.setProjection(projectionList.get()); Criteria criteria = super.getExecutableCriteria(session); for (Map.Entry<String, Serializable> ext : extendedCriteria.entrySet()) { try { criteriaMethodHandles.get(ext.getKey()).invokeWithArguments(criteria, extendedCriteria.get(ext.getKey())); } catch (Throwable e) { throw new RuntimeException( "Failed to invoke extended criteria application for [" + ext.getKey() + "]", e); } } return criteria; } public static void main(String[] args) { } /** * Returns a new nested detached criteria * @param value The value to create the with * @return a new ExtendedDetachedCriteria */ public ExtendedDetachedCriteria createCriteria(Object value) { try { if (value.getClass().isArray()) { Object[] args = new Object[Array.getLength(value)]; System.arraycopy(value, 0, args, 0, args.length); return new ExtendedDetachedCriteria((String) args[0], (String) args[1]); } return new ExtendedDetachedCriteria((String) value); } catch (Throwable t) { throw new RuntimeException(t); } } /** * Specify an association fetching strategy for an association or a * collection of values. * * @param associationPath a dot seperated property path * @param mode The fetch mode for the referenced association * @return this (for method chaining) */ public ExtendedDetachedCriteria setFetchMode(String associationPath, String mode) { setFetchMode(associationPath, fetchModes.get(mode.trim().toUpperCase())); return this; } /** * Set a limit upon the number of objects to be retrieved. * * @param maxResults the maximum number of results * @return this (for method chaining) */ public ExtendedDetachedCriteria setMaxResults(Number maxResults) { extendedCriteria.put(EXT_MAXRESULTS, maxResults.intValue()); return this; } /** * Set the first result to be retrieved. * * @param firstResult the first result to retrieve, numbered from <tt>0</tt> * @return this (for method chaining) */ public ExtendedDetachedCriteria setFirstResult(Number firstResult) { extendedCriteria.put(EXT_FIRSTRESULT, firstResult.intValue()); return this; } /** * Set a fetch size for the underlying JDBC query. * * @param fetchSize the fetch size * @return this (for method chaining) * * @see java.sql.Statement#setFetchSize */ public ExtendedDetachedCriteria setFetchSize(Number fetchSize) { extendedCriteria.put(EXT_FETCHSIZE, fetchSize.intValue()); return this; } /** * Set a timeout for the underlying JDBC query. * * @param timeout The timeout value to apply. * @return this (for method chaining) * * @see java.sql.Statement#setQueryTimeout */ public ExtendedDetachedCriteria setTimeout(Number timeout) { extendedCriteria.put(EXT_TIMEOUT, timeout.intValue()); return this; } /** * Enable caching of this query result, provided query caching is enabled * for the underlying session factory. * * @param cacheable Should the result be considered cacheable; default is * to not cache (false). * @return this (for method chaining) */ public ExtendedDetachedCriteria setCacheable(boolean cacheable) { extendedCriteria.put(EXT_CACHEABLE, cacheable); return this; } /** * Set the name of the cache region to use for query result caching. * * @param cacheRegion the name of a query cache region, or <tt>null</tt> * for the default query cache * @return this (for method chaining) * * @see #setCacheable */ public ExtendedDetachedCriteria setCacheRegion(String cacheRegion) { extendedCriteria.put(EXT_CACHEREGION, cacheRegion); return this; } /** * Override the flush mode for this particular query. * * @param flushMode The flush mode to use. * @return this (for method chaining) */ public ExtendedDetachedCriteria setFlushMode(String flushMode) { extendedCriteria.put(EXT_FLUSHMODE, FlushMode.parse(flushMode.trim().toUpperCase())); return this; } /** * Override the cache mode for this particular query. * * @param cacheMode The cache mode to use. * @return this (for method chaining) */ public ExtendedDetachedCriteria setCacheMode(String cacheMode) { extendedCriteria.put(EXT_CACHEMODE, CacheMode.parse(cacheMode.trim().toUpperCase())); return this; } /** * {@inheritDoc} * @see org.helios.apmrouter.catalog.api.impl.Parsed#get() */ @Override public ExtendedDetachedCriteria get() { return this; } }