net.cassite.daf4j.ds.DataSource Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of daf4j-api Show documentation
A library provides facade api for data accessing.
The newest version!
package net.cassite.daf4j.ds;

import net.cassite.daf4j.*;

import java.util.List;
import java.util.Map;

/**
 * DataAccess数据源

 * 使用DataSource来简化DataAccess和避免DataAccess的开发中的失误
 *
 * @param       上下文
 * @param  基本元素
 */
public class DataSource implements DataAccess {
        private final AroundParser aroundParser;
        private final DS source;

        private final ParserPacket parserPacket;

        private final TxManager txManager;

        protected DataSource(ConditionParser conditionParser,
                             ExpressionParser expressionParser,
                             AndOrParser andOrParser,
                             AroundParser aroundParser,
                             QueryParameterParser queryParameterParser,
                             EntityDataParser entityDataParser,
                             UpdateEntryParser updateEntryParser,
                             TxManager txManager,
                             DS source) {
                this.aroundParser = aroundParser;
                this.txManager = txManager;
                this.source = source;

                ConditionResolver conditionResolver = new ConditionResolver(conditionParser);
                ExpressionResolver expressionResolver = new ExpressionResolver(expressionParser);

                parserPacket = new ParserPacket(andOrParser,
                        aroundParser, conditionParser, entityDataParser, expressionParser, queryParameterParser, updateEntryParser, txManager);

                aroundParser.setParserPacket(parserPacket);

                ObjectResolver objectResolver = new ObjectResolver(conditionResolver, expressionResolver, parserPacket);

                parserPacket.setResolvers(conditionResolver, expressionResolver, objectResolver);

                andOrParser.setObjectResolver(objectResolver);

                this.aroundParser.setObjectResolver(objectResolver);

                queryParameterParser.setObjectResolver(objectResolver);

                updateEntryParser.setObjectResolver(objectResolver);

                conditionParser.setObjectResolver(objectResolver);

                expressionParser.setObjectResolver(objectResolver);
        }

        @Override
        public  En find(Class entityClass, Object pkValue) {
                try {
                        return aroundParser.find(source, entityClass, pkValue);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }


        @SuppressWarnings("unchecked")
        @Override
        public  List list(En entity, Where whereClause, QueryParameter parameter) {
                try {
                        Context context = aroundParser.initiateList(source, entity, whereClause, parameter);
                        DSUtils.listGenerationProcess(context, whereClause, parameter, parserPacket);
                        return (List) aroundParser.executeList(context);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        @Override
        public List> projection(Object entity, Where whereClause, QueryParameterWithFocus parameter) {
                try {
                        Context context = aroundParser.initiateProjection(source, entity, whereClause, parameter);
                        DSUtils.projectionGenerationProcess(context, whereClause, parameter, parserPacket);
                        return aroundParser.executeProjection(context);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        @Override
        public void update(Object entity, Where whereClause, UpdateEntry[] entries) {
                try {
                        Context context = aroundParser.initiateUpdate(source, entity, whereClause, entries);
                        context = DSUtils.updateGenerationProcess(context, whereClause, entries, parserPacket);
                        aroundParser.executeUpdate(context);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        @Override
        public void remove(Object entity, Where whereClause) {
                try {
                        Context context = aroundParser.initiateRemove(source, entity, whereClause);
                        context = DSUtils.removeGenerationProcess(context, whereClause, parserPacket);
                        aroundParser.executeRemove(context);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        @Override
        public void save(Object[] entities) {
                try {
                        aroundParser.save(source, entities);
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        @Override
        public void txBegin() {
                txManager.txBegin();
        }

        @Override
        public void txCommit() {
                txManager.txCommit();
        }

        @Override
        public void txRollback() {
                txManager.txRollback();
        }

        @Override
        public void destroy() {
                aroundParser.destroy(source);
        }
}