com.jpattern.orm.JPOrm Maven / Gradle / Ivy

Go to download
package com.jpattern.orm;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jpattern.orm.cache.CacheManager;
import com.jpattern.orm.cache.SimpleCacheManager;
import com.jpattern.orm.dialect.DBProfile;
import com.jpattern.orm.exception.OrmConfigurationException;
import com.jpattern.orm.mapper.IOrmClassTool;
import com.jpattern.orm.mapper.IOrmClassToolMap;
import com.jpattern.orm.mapper.NullOrmClassToolMap;
import com.jpattern.orm.mapper.OrmClassTool;
import com.jpattern.orm.mapper.OrmClassToolMap;
import com.jpattern.orm.mapper.clazz.ClassMapBuilder;
import com.jpattern.orm.mapper.clazz.IClassMap;
import com.jpattern.orm.persistor.OrmPersistor;
import com.jpattern.orm.persistor.PersistorGeneratorImpl;
import com.jpattern.orm.persistor.type.ExtendedTypeWrapper;
import com.jpattern.orm.persistor.type.TypeFactory;
import com.jpattern.orm.session.NullSessionProvider;
import com.jpattern.orm.session.OrmSession;
import com.jpattern.orm.session.Session;
import com.jpattern.orm.session.SessionProvider;
import com.jpattern.orm.validator.NullValidatorService;
import com.jpattern.orm.validator.ValidatorService;

/**
 * 
 * @author Francesco Cina'
 *
 * 26/ago/2011
 */
public class JPOrm implements JPO {

    private static Integer JPORM_INSTANCES_COUNT = Integer.valueOf(0);
    private SessionProvider sessionProvider;
    private IOrmClassToolMap ormClassToolMap = new OrmClassToolMap(this);
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    private final DBProfile dbProfile;
    private final Integer instanceCount;
    private ValidatorService validatorService = new NullValidatorService();
    private CacheManager cacheManager = new SimpleCacheManager();

    /**
     * Create a new instance of JPOrm.
     * 
     * @param sessionProvider
     */
    public JPOrm(final SessionProvider sessionProvider) {
        synchronized (JPORM_INSTANCES_COUNT) {
            instanceCount = JPORM_INSTANCES_COUNT++;
        }
        logger.info("Building new instance of JPO (instance [{}])", instanceCount); //$NON-NLS-1$
        this.sessionProvider = sessionProvider;
        dbProfile = sessionProvider.getDBType().getDBProfile();
    }

    @Override
    public final Session session() {
        return new OrmSession(getOrmClassToolMap(), sessionProvider.getSessionStrategy(), validatorService, cacheManager, dbProfile);
    }

    @Override
    public synchronized  void register(final Class clazz) throws OrmConfigurationException {
        try {
            if (!getOrmClassToolMap().containsTool(clazz)) {
                logger.debug("register new class: " + clazz.getName()); //$NON-NLS-1$
                final IClassMap classMap = new ClassMapBuilder(clazz, getOrmClassToolMap()).generate();
                final OrmPersistor ormPersistor =  new PersistorGeneratorImpl(getOrmClassToolMap(), classMap, getTypeFactory()).generate();
                final IOrmClassTool ormClassTool = new OrmClassTool(classMap, ormPersistor);
                getOrmClassToolMap().put(clazz, ormClassTool);
            }
        } catch (final Exception e) {
            throw new OrmConfigurationException(e);
        }
    }

    @Override
    public synchronized void destory() {
        sessionProvider = new NullSessionProvider();
        ormClassToolMap = new NullOrmClassToolMap();
    }

    @Override
    public synchronized void register(final List> classes) throws OrmConfigurationException {
        for (final Class clazz : classes) {
            this.register(clazz);
        }
    }

    public SessionProvider getSessionProvider() {
        return sessionProvider;
    }

    @Override
    public synchronized void register(final ExtendedTypeWrapper typeWrapper) throws OrmConfigurationException {
        getTypeFactory().addTypeWrapper(typeWrapper);
    }

    @Override
    public synchronized void setValidatorService(final ValidatorService validatorService) {
        if (validatorService!=null) {
            this.validatorService = validatorService;
        }
    }

    public TypeFactory getTypeFactory() {
        return getOrmClassToolMap().getTypeFactory();
    }

    public IOrmClassToolMap getOrmClassToolMap() {
        return ormClassToolMap;
    }

    @Override
    public void setCacheManager(final CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

}