Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.openjpa.kernel; import java.util.ArrayList; import java.util.BitSet; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.collections.map.IdentityMap; import org.apache.openjpa.enhance.PersistenceCapable; import org.apache.openjpa.event.CallbackModes; import org.apache.openjpa.event.LifecycleEvent; import org.apache.openjpa.lib.util.Localizer; import org.apache.openjpa.meta.ClassMetaData; import org.apache.openjpa.meta.FieldMetaData; import org.apache.openjpa.meta.ValueMetaData; import org.apache.openjpa.util.CallbackException; import org.apache.openjpa.util.Exceptions; import org.apache.openjpa.util.ImplHelper; import org.apache.openjpa.util.OpenJPAException; import org.apache.openjpa.util.OptimisticException; import org.apache.openjpa.util.ProxyManager; import org.apache.openjpa.util.UserException; /** * Handles attaching instances. * * @author Marc Prud'hommeaux */ public class AttachManager { private static final Localizer _loc = Localizer.forPackage(AttachManager.class); private final BrokerImpl _broker; private final ProxyManager _proxy; private final OpCallbacks _call; private final boolean _copyNew; private final boolean _failFast; private final IdentityMap _attached = new IdentityMap(); private final Collection<StateManagerImpl> _visitedNodes = new ArrayList(); // reusable strategies private AttachStrategy _version; private AttachStrategy _detach; /** * Constructor. Supply broker attaching to. */ public AttachManager(BrokerImpl broker, boolean copyNew, OpCallbacks call) { _broker = broker; _proxy = broker.getConfiguration().getProxyManagerInstance(); _call = call; _copyNew = copyNew; _failFast = (broker.getConfiguration().getMetaDataRepositoryInstance().getMetaDataFactory().getDefaults() .getCallbackMode() & CallbackModes.CALLBACK_FAIL_FAST) != 0; } /** * Return the behavior supplied on construction. */ public OpCallbacks getBehavior() { return _call; } /** * Return whether to copy new instances being persisted. */ public boolean getCopyNew() { return _copyNew; } /** * Return an attached version of the given instance. */ public Object attach(Object pc) { if (pc == null) return null; CallbackException excep = null; try { return attach(pc, null, null, null, true); } catch (CallbackException ce) { excep = ce; return null; // won't be reached as the exceps will be rethrown } finally { List exceps = null; if (excep == null || !_failFast) exceps = invokeAfterAttach(null); else exceps = Collections.singletonList(excep); _attached.clear(); throwExceptions(exceps, null, false); } } /** * Return attached versions of the given instances. */ public Object[] attachAll(Collection instances) { Object[] attached = new Object[instances.size()]; List exceps = null; List failed = null; boolean opt = true; boolean failFast = false; try { int i = 0; for (Iterator itr = instances.iterator(); itr.hasNext(); i++) { try { attached[i] = attach(itr.next(), null, null, null, true); } catch (OpenJPAException ke) { // track exceptions and optimistic failed objects if (opt && !(ke instanceof OptimisticException)) opt = false; if (opt && ke.getFailedObject() != null) failed = add(failed, ke.getFailedObject()); exceps = add(exceps, ke); if (ke instanceof CallbackException && _failFast) { failFast = true; break; } } catch (RuntimeException re) { exceps = add(exceps, re); } } } finally { // invoke post callbacks unless all failed if (!failFast && (exceps == null || exceps.size() < instances.size())) exceps = invokeAfterAttach(exceps); _attached.clear(); } throwExceptions(exceps, failed, opt); return attached; } /** * Invoke postAttach() on any attached instances that implement * PostAttachCallback. This will be done after the entire graph has * been attached. */ private List invokeAfterAttach(List exceps) { Set entries = _attached.entrySet(); for (Iterator i = entries.iterator(); i.hasNext();) { Map.Entry entry = (Map.Entry) i.next(); Object attached = entry.getValue(); StateManagerImpl sm = _broker.getStateManagerImpl(attached, true); if (sm.isNew()) continue; try { _broker.fireLifecycleEvent(attached, entry.getKey(), sm.getMetaData(), LifecycleEvent.AFTER_ATTACH); } catch (RuntimeException re) { exceps = add(exceps, re); if (_failFast && re instanceof CallbackException) break; } } return exceps; } /** * Add an object to the list. */ private List add(List list, Object obj) { if (list == null) list = new LinkedList(); list.add(obj); return list; } /** * Throw exception for failures. */ private void throwExceptions(List exceps, List failed, boolean opt) { if (exceps == null) return; if (exceps.size() == 1) throw (RuntimeException) exceps.get(0); Throwable[] t = (Throwable[]) exceps.toArray(new Throwable[exceps.size()]); if (opt && failed != null) throw new OptimisticException(failed, t); if (opt) throw new OptimisticException(t); throw new UserException(_loc.get("nested-exceps")).setNestedThrowables(t); } /** * Attach. * * @param toAttach the detached object * @param into the instance we're attaching into * @param owner state manager for <code>into</code> * @param ownerMeta the field we traversed to find <code>toAttach</code> * @param explicit whether to make new instances explicitly persistent */ Object attach(Object toAttach, PersistenceCapable into, OpenJPAStateManager owner, ValueMetaData ownerMeta, boolean explicit) { if (toAttach == null) return null; // check if already attached Object attached = _attached.get(toAttach); if (attached != null) return attached; //### need to handle ACT_CASCADE int action = processArgument(toAttach); if ((action & OpCallbacks.ACT_RUN) == 0 && (action & OpCallbacks.ACT_CASCADE) != 0) { if (_visitedNodes.contains(_broker.getStateManager(toAttach))) return toAttach; return handleCascade(toAttach, owner); } if ((action & OpCallbacks.ACT_RUN) == 0) return toAttach; //### need to handle ACT_RUN without also ACT_CASCADE ClassMetaData meta = _broker.getConfiguration().getMetaDataRepositoryInstance() .getMetaData(ImplHelper.getManagedInstance(toAttach).getClass(), _broker.getClassLoader(), true); return getStrategy(toAttach).attach(this, toAttach, meta, into, owner, ownerMeta, explicit); } private Object handleCascade(Object toAttach, OpenJPAStateManager owner) { StateManagerImpl sm = _broker.getStateManagerImpl(toAttach, true); BitSet loaded = sm.getLoaded(); FieldMetaData[] fmds = sm.getMetaData().getDefinedFields(); for (FieldMetaData fmd : fmds) { if (fmd.getElement().getCascadeAttach() == ValueMetaData.CASCADE_IMMEDIATE) { FieldMetaData[] inverseFieldMappings = fmd.getInverseMetaDatas(); if (inverseFieldMappings.length != 0) { _visitedNodes.add(sm); // Only try to attach this field is it is loaded if (loaded.get(fmd.getIndex())) { getStrategy(toAttach).attachField(this, toAttach, sm, fmd, true); } } } } return toAttach; } /** * Determine the action to take on the given argument. */ private int processArgument(Object obj) { if (_call == null) return OpCallbacks.ACT_RUN; return _call.processArgument(OpCallbacks.OP_ATTACH, obj, _broker.getStateManager(obj)); } /** * Calculate proper attach strategy for instance. */ private AttachStrategy getStrategy(Object toAttach) { PersistenceCapable pc = ImplHelper.toPersistenceCapable(toAttach, getBroker().getConfiguration()); if (pc.pcGetStateManager() instanceof AttachStrategy) return (AttachStrategy) pc.pcGetStateManager(); Object obj = pc.pcGetDetachedState(); if (obj instanceof AttachStrategy) return (AttachStrategy) obj; if (obj == null || obj == PersistenceCapable.DESERIALIZED) { // new or detached without state if (_version == null) _version = new VersionAttachStrategy(); return _version; } // detached state if (_detach == null) _detach = new DetachedStateAttachStrategy(); return _detach; } /** * Owning broker. */ BrokerImpl getBroker() { return _broker; } /** * System proxy manager. */ ProxyManager getProxyManager() { return _proxy; } /** * If the passed in argument has already been attached, return * the (cached) attached copy. */ PersistenceCapable getAttachedCopy(Object pc) { return ImplHelper.toPersistenceCapable(_attached.get(pc), getBroker().getConfiguration()); } /** * Record the attached copy in the cache. */ void setAttachedCopy(Object from, PersistenceCapable into) { _attached.put(from, into); } /** * Fire before-attach event. */ void fireBeforeAttach(Object pc, ClassMetaData meta) { _broker.fireLifecycleEvent(pc, null, meta, LifecycleEvent.BEFORE_ATTACH); } /** * Return the detached oid of the given instance. */ Object getDetachedObjectId(Object pc) { if (pc == null) return null; return getStrategy(pc).getDetachedObjectId(this, pc); } /** * Throw an exception if the given object is not managed; otherwise * return its state manager. */ StateManagerImpl assertManaged(Object obj) { StateManagerImpl sm = _broker.getStateManagerImpl(obj, true); if (sm == null) throw new UserException(_loc.get("not-managed", Exceptions.toString(obj))).setFailedObject(obj); return sm; } }