org.sfm.reflect.asm.AsmFactory Maven / Gradle / Ivy

Go to download
package org.sfm.reflect.asm;

import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;

import org.objectweb.asm.Opcodes;
import org.sfm.jdbc.JdbcMapper;
import org.sfm.map.FieldMapper;
import org.sfm.map.RowHandlerErrorHandler;
import org.sfm.reflect.Getter;
import org.sfm.reflect.Instantiator;
import org.sfm.reflect.Setter;

public class AsmFactory implements Opcodes {
	private final FactoryClassLoader factoryClassLoader;
	private final ConcurrentMap> setterCache = new ConcurrentHashMap>();
	private final ConcurrentMap> instantiatorCache = new ConcurrentHashMap>();
	
	public AsmFactory() {
		this(Thread.currentThread().getContextClassLoader());
	}
	
	public AsmFactory(ClassLoader cl) {
		factoryClassLoader = new FactoryClassLoader(cl);
	}
	
	@SuppressWarnings("unchecked")
	public  Setter createSetter(final Method m) throws Exception {
		Setter setter = (Setter) setterCache.get(m);
		if (setter == null) {
			final String className = generateClassName(m);
			final byte[] bytes = generateClassByteCodes(m, className);
			final Class type = factoryClassLoader.registerClass(className, bytes);
			setter = (Setter) type.newInstance();
			setterCache.putIfAbsent(m, setter);
		}
		return setter;
	}

	private byte[] generateClassByteCodes(final Method m, final String className) throws Exception {
		final Class propertyType = m.getParameterTypes()[0];
		if (AsmUtils.primitivesClassAndWrapper.contains(propertyType)) {
			return SetterBuilder.createPrimitiveSetter(className, m);
		} else {
			return SetterBuilder.createObjectSetter(className, m);
		}
	}
	
	@SuppressWarnings("unchecked")
	public  Instantiator createEmptyArgsInstatiantor(final Class source, final Class target) throws Exception {
		InstantiatorKey instantiatorKey = new InstantiatorKey(target, source);
		Instantiator instantiator = (Instantiator) instantiatorCache.get(instantiatorKey);
		if (instantiator == null) {
			final String className = generateInstantiatorClassName(instantiatorKey);
			final byte[] bytes = ConstructorBuilder.createEmptyConstructor(className, source, target);
			final Class type = factoryClassLoader.registerClass(className, bytes);
			instantiator = (Instantiator) type.newInstance();
			instantiatorCache.putIfAbsent(instantiatorKey, instantiator);
		}
		return instantiator;
	}
	
	@SuppressWarnings("unchecked")
	public  Instantiator createInstatiantor(final Class source, final ConstructorDefinition constructorDefinition,final Map> injections) throws Exception {
		InstantiatorKey instantiatorKey = new InstantiatorKey(constructorDefinition, injections.keySet(), source);
		Instantiator instantiator = (Instantiator) instantiatorCache.get(instantiatorKey);
		if (instantiator == null) {
			final String className = generateInstantiatorClassName(instantiatorKey);
			final byte[] bytes = InstantiatorBuilder.createInstantiator(className, source, constructorDefinition, injections);
			final Class type = factoryClassLoader.registerClass(className, bytes);
			
			Map> getterPerName = new HashMap>();
			for(Entry> e : injections.entrySet()) {
				getterPerName.put(e.getKey().getName(), e.getValue());
			}
			
			instantiator = (Instantiator) type.getConstructor(Map.class).newInstance(getterPerName);
			instantiatorCache.put(instantiatorKey, instantiator);
		}
		return instantiator;
	}
	
	@SuppressWarnings("unchecked")
	public  JdbcMapper createJdbcMapper(final FieldMapper[] mappers, final Instantiator instantiator, final Class target, RowHandlerErrorHandler errorHandler) throws Exception {
		final String className = generateClassName(mappers, ResultSet.class, target);
		final byte[] bytes = JdbcMapperAsmBuilder.dump(className, mappers, target);
		final Class type = factoryClassLoader.registerClass(className, bytes);
		return (JdbcMapper) type.getDeclaredConstructors()[0].newInstance(mappers, instantiator, errorHandler);
	}
	
	private final AtomicLong classNumber = new AtomicLong();
	
	private String generateInstantiatorClassName(final InstantiatorKey key) {
		StringBuilder sb = new StringBuilder();
		
		sb.append( "org.sfm.reflect.asm.")
		.append(key.getConstructor().getDeclaringClass().getPackage().getName())
		.append(".AsmInstantiator").append(key.getConstructor().getDeclaringClass().getSimpleName());
		String[] injectedParams = key.getInjectedParams();
		if (injectedParams != null) {
			for(String str : injectedParams) {
				sb.append(str.substring(0, Math.min(str.length(), 3)));
			}
		}
		sb.append(replaceArray(key.getSource().getSimpleName()));
		sb.append(Long.toHexString(classNumber.getAndIncrement()));
		return sb.toString();
	}

	private String replaceArray(String simpleName) {
		return simpleName.replace('[', '_').replace(']', '_');
	}

	private String generateClassName(final Method m) {
		return "org.sfm.reflect.asm." + m.getDeclaringClass().getPackage().getName() + 
					".AsmSetter" + m.getName()
					 + m.getDeclaringClass().getSimpleName()
					 + m.getParameterTypes()[0].getSimpleName()
					;
	}
	
	private  String generateClassName(final FieldMapper[] mappers, final Class source, final Class target) {
		return "org.sfm.reflect.asm." + target.getPackage().getName() + 
					".AsmMapper" + source.getSimpleName() + "2" +  target.getSimpleName() + mappers.length + "_" + classNumber.getAndIncrement(); 
	}
}