• Home
• net.sf.tsl2nano
• tsl2.nano.serviceaccess
• 2.5.3
• source code
• GenericServiceBean.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

de.tsl2.nano.service.util.GenericServiceBean Maven / Gradle / Ivy

/*
 * File: $HeadURL$
 * Id  : $Id$
 * 
 * created by: TS, Thomas Schneider
 * created on: Jan 11, 2010
 * 
 * Copyright: (c) Thomas Schneider 2010, all rights reserved
 */
package de.tsl2.nano.service.util;

import static de.tsl2.nano.service.util.ServiceUtil.*;
import static de.tsl2.nano.service.util.ServiceUtil.createBetweenStatement;
import static de.tsl2.nano.service.util.ServiceUtil.createExampleStatement;
import static de.tsl2.nano.service.util.ServiceUtil.createStatement;
import static de.tsl2.nano.service.util.ServiceUtil.getId;
import static de.tsl2.nano.service.util.ServiceUtil.getIdName;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.Query;
import javax.security.auth.Subject;

import de.tsl2.nano.bean.BeanFindParameters;
import de.tsl2.nano.bean.def.Diff;
import de.tsl2.nano.core.ManagedException;
import de.tsl2.nano.core.cls.BeanAttribute;
import de.tsl2.nano.core.cls.BeanClass;
import de.tsl2.nano.core.util.MapUtil;
import de.tsl2.nano.core.util.StringUtil;
import de.tsl2.nano.service.util.batch.Part;
import de.tsl2.nano.service.util.finder.AbstractFinder;
import de.tsl2.nano.service.util.finder.Finder;
import de.tsl2.nano.serviceaccess.aas.principal.UserPrincipal;

/**
 * provides some common and batch service access methods to work with beans.
 * 

 * Five base services are used by all others:

 * {@link #findByQuery(String, boolean, int, int, Object[], Map, Class...)}

 * {@link #findById(Class, Object, Class...)}

 * {@link #instantiateLazyRelationship(Class, Object, String[], List)}

 * {@link #persistNoTransaction(Object, boolean, boolean, Class...)}

 * {@link #remove(Object)}

 * {@link #executeQuery(String, boolean, Object[])}

 * 

 * pro
 * 
 * @author TS
 * 
 */
@Stateless
@SuppressWarnings({ "rawtypes", "unchecked" })
public class GenericServiceBean extends NamedQueryServiceBean implements IGenericService, IGenericLocalService {

//    private Map, Object> beanIdCache = new Hashtable, Object>();

    /** {@inheritDoc} */
    @Override
    public  Collection findAll(Class beanType, Class... lazyRelations) {
        return findAll(new BeanFindParameters(beanType, 0, -1, null, null, lazyRelations));
    }

    @Override
    public  Collection findAll(Class beanType, int startIndex, int maxResult, Class... lazyRelations) {
        return findAll(new BeanFindParameters(beanType, startIndex, maxResult, lazyRelations));
    }

    /** {@inheritDoc} */
    @Override
    public  Collection findAll(BeanFindParameters p) {
        checkContextSecurity();
        Class beanType = p.getBeanType();
        if (isVirtualEntity(beanType)) {
            if (isNamedQuery(beanType)) {
                return findByNamedQuery(beanType, getNamedQueryByArguments(beanType), p.getMaxResult());
            }
        }
        final StringBuffer qStr = createStatement(beanType);
        qStr.append(addOrderBy(p.getOrderBy()));
        Map hints = MapUtil.asMap("org.hibernate.cacheable",
            Boolean.TRUE,
            "org.hibernate.readOnly",
            Boolean.TRUE);
        if (p.getHints() != null) {
            hints.putAll(p.getHints());
        }
        //a findAll should only be done on 'configuration' tables
        //QUESTION: why does the query perform poor on activated cache????
        return (Collection) findByQuery(qStr.toString(), false, p.getStartIndex(), p.getMaxResult(), null, hints, p.getLazyRelations());
    }

    /** {@inheritDoc} */
    @Override
    public  Collection findMembers(H holder, Class beanType, String attributeName, Class... lazyRelations) {
        checkContextSecurity();
        final StringBuffer qStr = createStatement(beanType);
        addMemberExpression(qStr, holder, beanType, attributeName);
        return (Collection) findByQuery(qStr.toString(),
            false,
            0,
            -1,
            new Object[] { getId(holder) },
            null,
            lazyRelations);
    }

    /** {@inheritDoc} */
    @Override
    public  Collection findHolders(T member, Class holderType, String attributeName, Class... lazyRelations) {
        checkContextSecurity();
        final StringBuffer qStr = createStatement(holderType);
        final String idAttribute = getIdName(member);
        qStr.append(", " + member.getClass().getSimpleName()
            + " t1\n where t1."
            + idAttribute
            + " = ? and t1 member of t."
            + attributeName);
        return (Collection) findByQuery(qStr.toString(),
            false,
            0,
            -1,
            new Object[] { idAttribute },
            null,
            lazyRelations);
    }

    /** {@inheritDoc} */
    @Override
    public  T findById(Class beanType, Object id, Class... lazyRelations) {
        checkContextSecurity();
        if (isVirtualEntity(beanType)) {
            if (isNamedQuery(beanType)) {
                final Collection result = findByNamedQuery(beanType, getNamedQueryByArguments(beanType, id), -1, id);
                if (result.size() > 1) {
                    LOG.warn("findById (" + beanType
                        + ", "
                        + id
                        + ") found more than one unbound entity:"
                        + StringUtil.toString(result, 100));
                }
                return result.size() > 0 ? result.iterator().next() : null;
            }
        }
        final T bean = connection().find(beanType, id);

        if (bean == null) {
            return null;
        }
        return fillTree(Arrays.asList(bean), lazyRelations).iterator().next();
    }

    /**
     * helper for all finders
     * 
     * @param  bean type
     * @param result instance
     * @param lazyRelations relation types to fill
     * @return perhaps filled object tree
     */
    protected final  Collection fillTree(Collection result, Class... lazyRelations) {
        if (lazyRelations != null && lazyRelations.length > 0) {
            List relations = Arrays.asList(lazyRelations);
            for (T bean : result) {
                //if an object array is returned we do it for all objects
                Object[] b = (Object[]) (bean instanceof Object[] ? bean : new Object[] { bean });
                for (int i = 0; i < b.length; i++) {
                    resetTreeVars(b[i]);
                    fillTree(b[i], null, relations);
                    finishTree(b[i], lazyRelations);
                }
            }
        }
        return result;
    }

    /**
     * because fillTree() is recursive, we use this method by every caller to clean the data.
     * 
     * @param bean entity
     * @param lazyRelations relations to be filled
     */
    private final void finishTree(Object bean, Class... lazyRelations) {
        if (recurseLevel > 0 || instantiatedEntities.size() > 0) {
            LOG.debug("==> fillTree finished on bean:" + bean
                + ", recursionLevel="
                + recurseLevel
                + ", instantiated entities:"
                + instantiatedEntities.size());
        }
//        recurseLevel = 0;
//        instantiatedEntities.clear();
    }

    /**
     * fills recursive all given attribute-relations of type fillType.
     * 
     * @param bean bean, that must not already be serialized.
     * @param attributes relations. if null, all attributes will be filled
     * @param fillTypes (optional) relation types to fill. if null, all types will be filled.
     */
    private int recurseLevel = 0;
    private final int MAX_RECURSLEVEL = 10;
    private final Collection accessedBeanAttributes = new LinkedHashSet();
    private final Collection