com.liferay.portal.kernel.util.ProxyUtil Maven / Gradle / Ivy

/**
 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
 *
 * This library 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 library 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.
 */

package com.liferay.portal.kernel.util;

import com.liferay.portal.kernel.memory.EqualityWeakReference;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * @author Shuyang Zhou
 */
public class ProxyUtil {

	public static InvocationHandler getInvocationHandler(Object proxy) {
		if (!isProxyClass(proxy.getClass())) {
			throw new IllegalArgumentException("Not a proxy instance");
		}

		try {
			return (InvocationHandler)_invocationHandlerField.get(proxy);
		}
		catch (Exception e) {
			throw new IllegalArgumentException(e);
		}
	}

	public static Class getProxyClass(
		ClassLoader classLoader, Class... interfaceClasses) {

		EqualityWeakReference classLoaderReference =
			new EqualityWeakReference(classLoader);

		ConcurrentMap>> classReferences =
			_classReferences.get(classLoaderReference);

		if (classReferences == null) {
			classReferences =
				new ConcurrentHashMap>>();

			classLoaderReference = new EqualityWeakReference(
				classLoader, _classLoaderReferenceQueue);

			ConcurrentMap>> oldClassReferences =
				_classReferences.putIfAbsent(
					classLoaderReference, classReferences);

			if (oldClassReferences != null) {
				classReferences = oldClassReferences;

				classLoaderReference.enqueue();
			}
		}

		LookupKey lookupKey = new LookupKey(interfaceClasses);

		Reference> classReference = classReferences.get(lookupKey);

		Class clazz = null;

		if ((classReference == null) ||
			((clazz = classReference.get()) == null)) {

			synchronized(classReferences) {
				classReference = classReferences.get(lookupKey);

				if ((classReference == null) ||
					((clazz = classReference.get()) == null)) {

					clazz = Proxy.getProxyClass(classLoader, interfaceClasses);

					classReferences.put(
						lookupKey, new WeakReference>(clazz));
				}
			}
		}

		Constructor constructor = null;

		try {
			constructor = clazz.getConstructor(_argumentsClazz);
		}
		catch (Exception e) {
			throw new InternalError(e.toString());
		}

		EqualityWeakReference> proxyClassReference =
			new EqualityWeakReference>(
				clazz, _proxyClassReferenceQueue);

		_constructors.putIfAbsent(proxyClassReference, constructor);

		while (true) {
			EqualityWeakReference staleClassLoaderReference =
				(EqualityWeakReference)
					_classLoaderReferenceQueue.poll();

			if (staleClassLoaderReference == null) {
				break;
			}

			_classReferences.remove(staleClassLoaderReference);
		}

		while (true) {
			EqualityWeakReference> staleProxyClassReference =
				(EqualityWeakReference>)
					_proxyClassReferenceQueue.poll();

			if (staleProxyClassReference == null) {
				break;
			}

			_constructors.remove(staleProxyClassReference);
		}

		return clazz;
	}

	public static boolean isProxyClass(Class clazz) {
		if (clazz == null) {
			throw new NullPointerException();
		}

		EqualityWeakReference> equalityWeakReference =
			new EqualityWeakReference>(clazz);

		return _constructors.containsKey(equalityWeakReference);
	}

	public static Object newProxyInstance(
		ClassLoader classLoader, Class[] interfaces,
		InvocationHandler invocationHandler) {

		Class clazz = getProxyClass(classLoader, interfaces);

		EqualityWeakReference> proxyClassReference =
			new EqualityWeakReference>(clazz);

		Constructor constructor = _constructors.get(proxyClassReference);

		try {
			return constructor.newInstance(new Object[] {invocationHandler});
		}
		catch (Exception e) {
			throw new InternalError(e.toString());
		}
	}

	private static Class[] _argumentsClazz = {InvocationHandler.class};
	private static ReferenceQueue _classLoaderReferenceQueue =
		new ReferenceQueue();
	private static ConcurrentMap
		,
			ConcurrentMap>>> _classReferences =
				new ConcurrentHashMap,
					ConcurrentMap>>>();
	private static ConcurrentMap
		>, Constructor> _constructors =
			new ConcurrentHashMap
				>, Constructor>();
	private static Field _invocationHandlerField;
	private static ReferenceQueue> _proxyClassReferenceQueue =
		new ReferenceQueue>();

	private static class LookupKey {

		public LookupKey(Class[] interfaces) {
			_interfaces = interfaces;

			_hashCode = 1;

			for (Class clazz : interfaces) {
				String name = clazz.getName();

				_hashCode = HashUtil.hash(_hashCode, name.hashCode());
			}
		}

		@Override
		public boolean equals(Object obj) {
			LookupKey lookupKey = (LookupKey)obj;

			if (_interfaces.length != lookupKey._interfaces.length) {
				return false;
			}

			for (int i = 0; i < _interfaces.length; i++) {
				if (_interfaces[i] != lookupKey._interfaces[i]) {
					return false;
				}
			}

			return true;
		}

		@Override
		public int hashCode() {
			return _hashCode;
		}

		private int _hashCode;
		private final Class[] _interfaces;

	}

	static {
		try {
			_invocationHandlerField = ReflectionUtil.getDeclaredField(
				Proxy.class, "h");
		}
		catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}

}