org.sfm.jdbc.DynamicJdbcMapper Maven / Gradle / Ivy

Go to download
package org.sfm.jdbc;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

import org.sfm.map.FieldMapper;
import org.sfm.map.FieldMapperErrorHandler;
import org.sfm.map.MapperBuilderErrorHandler;
import org.sfm.map.MapperBuildingException;
import org.sfm.map.MappingException;
import org.sfm.reflect.ClassMeta;
import org.sfm.reflect.ReflectionService;
import org.sfm.utils.Handler;

public final class DynamicJdbcMapper implements JdbcMapper {

	private final ClassMeta classMeta;
	private final Class target;

	@SuppressWarnings("unchecked")
	private final AtomicReference[]> mapperCache = new AtomicReference[]>(new CacheEntry[0]);

	private final FieldMapperErrorHandler fieldMapperErrorHandler;

	private final  MapperBuilderErrorHandler mapperBuilderErrorHandler;
	private final Map aliases;
	private Map> customMappings = new HashMap<>();


	public DynamicJdbcMapper(final Class target, final ReflectionService reflectionService, 
			final FieldMapperErrorHandler fieldMapperErrorHandler, 
			final MapperBuilderErrorHandler mapperBuilderErrorHandler, 
			final Map aliases, 
			final Map> customMappings) {
		this.classMeta = new ClassMeta(target, reflectionService);
		this.target = target;
		this.fieldMapperErrorHandler = fieldMapperErrorHandler;
		this.mapperBuilderErrorHandler = mapperBuilderErrorHandler;
		this.aliases = aliases;
		this.customMappings = customMappings;
	}
	
	private static final class CacheEntry {
		final MapperKey key;
		final JdbcMapper mapper;
		public CacheEntry(final MapperKey key, final JdbcMapper mapper) {
			this.key = key;
			this.mapper = mapper;
		}
	}

	@Override
	public final T map(final ResultSet source) throws MappingException {
		try {
			final JdbcMapper mapper = buildMapper(source.getMetaData());
			return mapper.map(source);
		} catch(SQLException e) {
			throw new SQLMappingException(e.getMessage(), e);
		}
	}

	@Override
	public final > H forEach(final ResultSet rs, final H handle)
			throws SQLException, MappingException {
		final JdbcMappermapper = buildMapper(rs.getMetaData());
		return mapper.forEach(rs, handle);
	}

	private JdbcMapper buildMapper(final ResultSetMetaData metaData) throws MapperBuildingException, SQLException {
		
		final MapperKey key = MapperKey.valueOf(metaData);
		
		JdbcMapper mapper = getMapper(key);
		
		if (mapper == null) {
			final ResultSetMapperBuilder builder = new ResultSetMapperBuilderImpl(target, classMeta, aliases, customMappings);
			
			builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
			builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
			builder.addMapping(metaData);
			
			mapper = builder.mapper();
			
			addToMapperCache(new CacheEntry<>(key, mapper));
		}
		return mapper;
	}
	
	@SuppressWarnings("unchecked")
	private void addToMapperCache(final CacheEntry cacheEntry) {
		CacheEntry[] entries;
		CacheEntry[] newEntries;
		do {
			entries = mapperCache.get();
			
			for(int i = 0; i < entries.length; i++) {
				if (entries[0].key.equals(cacheEntry.key)) {
					// already added 
					return;
				}
			}
			
			newEntries = new CacheEntry[entries.length + 1];
			
			System.arraycopy(entries, 0, newEntries, 0, entries.length);
			newEntries[entries.length] = cacheEntry;
		
		} while(!mapperCache.compareAndSet(entries, newEntries));
	}

	protected JdbcMapper getMapper(MapperKey key) {
		final CacheEntry[] entries = mapperCache.get();
		for(int i = 0; i < entries.length; i++) {
			final CacheEntry entry = entries[i];
			if (entry.key.equals(key)) {
				return entry.mapper;
			}
		}
		return null;
	}
}