| /* |
| * 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.util; |
| |
| import java.security.AccessController; |
| |
| import org.apache.openjpa.conf.Compatibility; |
| import org.apache.openjpa.kernel.DetachedStateManager; |
| import org.apache.openjpa.kernel.OpenJPAStateManager; |
| import org.apache.openjpa.lib.util.J2DoPrivHelper; |
| import org.apache.openjpa.lib.util.Localizer; |
| import org.apache.openjpa.meta.ClassMetaData; |
| |
| /** |
| * Utility methods for managing proxies. |
| * |
| * @author Abe White |
| */ |
| public class Proxies { |
| |
| private static final Localizer _loc = Localizer.forPackage(Proxies.class); |
| |
| /** |
| * Used by proxy types to check if the given owners and field names |
| * are equivalent. |
| */ |
| public static boolean isOwner(Proxy proxy, OpenJPAStateManager sm, |
| int field) { |
| return proxy.getOwner() == sm && proxy.getOwnerField() == field; |
| } |
| |
| /** |
| * Used by proxy types to check that an attempt to add a new value is legal. |
| */ |
| public static void assertAllowedType(Object value, Class allowed) { |
| if (value != null && allowed != null && !allowed.isInstance(value)) { |
| throw new UserException(_loc.get("bad-elem-type", new Object[]{ |
| AccessController.doPrivileged( |
| J2DoPrivHelper.getClassLoaderAction(allowed)), |
| allowed, |
| AccessController.doPrivileged( |
| J2DoPrivHelper.getClassLoaderAction(value.getClass())), |
| value.getClass() |
| })); |
| } |
| } |
| |
| /** |
| * Used by proxy types to dirty their owner. |
| */ |
| public static void dirty(Proxy proxy, boolean stopTracking) { |
| if (proxy.getOwner() != null) |
| proxy.getOwner().dirty(proxy.getOwnerField()); |
| if (stopTracking && proxy.getChangeTracker() != null) |
| proxy.getChangeTracker().stopTracking(); |
| } |
| |
| /** |
| * Used by proxy types to notify collection owner on element removal. |
| */ |
| public static void removed(Proxy proxy, Object removed, boolean key) { |
| if (proxy.getOwner() != null && removed != null) |
| proxy.getOwner().removed(proxy.getOwnerField(), removed, key); |
| } |
| |
| /** |
| * Used by proxy types to serialize non-proxy versions. |
| */ |
| public static Object writeReplace(Proxy proxy, boolean detachable) { |
| /* OPENJPA-1097 Remove $proxy classes during serialization based on: |
| * 1) No Proxy, then return as-is |
| * 2) Runtime created proxy (!detachable), then unproxy |
| * 3) No StateManager (DetachedStateField==false), then return as-is |
| * Get the new IgnoreDetachedStateFieldForProxySerialization |
| * Compatibility flag from either the metadata/configuration if |
| * this is a normal StateManager, otherwise use the new flag |
| * added to the DetachedStateManager |
| * 4) If new 2.0 behavior |
| * 4a) If ClassMetaData exists and DetachedStateField == TRUE |
| * then do not remove the proxy and return as-is |
| * 4b) Else, using DetachedStateField of transient(default) or |
| * false, so unproxy |
| * 5) If 1.0 app or requested old 1.0 behavior |
| * 5a) If detached, then do not unproxy and return as-is |
| * 5b) Else, unproxy |
| * |
| * Original code - |
| * 1) Runtime created proxy (!detachable), then unproxy |
| * 2) No Proxy, then return as-is |
| * 3) No StateManager (DetachedStateField==false), then return as-is |
| * 4) If detached, then return as-is <--- ERROR as EM.clear() marks |
| * entity as detached but doesn't remove any $proxy usage |
| * 5) Else, unproxy |
| * |
| * if (detachable && (proxy == null || proxy.getOwner() == null |
| * || proxy.getOwner().isDetached())) |
| * return proxy; |
| * |
| */ |
| if (proxy == null) { |
| return proxy; |
| } else if (!detachable) { |
| // OPENJPA-1571 - using our runtime generated proxies, so remove any $proxy |
| return proxy.copy(proxy); |
| } else if (proxy.getOwner() == null) { |
| // no StateManager (DetachedStateField==false), so no $proxy to remove |
| return proxy; |
| } else { |
| // using a StateManager, so determine what DetachedState is being used |
| OpenJPAStateManager sm = proxy.getOwner(); // null checked for above |
| ClassMetaData meta = null; // if null, no proxies? |
| boolean useDSFForUnproxy = false; // default to false for old 1.0 behavior |
| |
| // Don't rely on sm.isDetached() method because if we are serializing an attached Entity |
| // the sm will still be a StateManagerImpl, but isDetached() will return true. |
| |
| // Using a DetachedStateManager, so use the new flag since there is no context or |
| // metadata |
| if (sm instanceof DetachedStateManager) { |
| useDSFForUnproxy = ((DetachedStateManager) sm).getUseDSFForUnproxy(); |
| } else{ |
| // DetachedStateManager has no context or metadata, so we can't get configuration settings |
| Compatibility compat = null; |
| meta = sm.getMetaData(); |
| if (meta != null) { |
| compat = meta.getRepository().getConfiguration().getCompatibilityInstance(); |
| } else if (sm.getContext() != null && sm.getContext().getConfiguration() != null) { |
| compat = sm.getContext().getConfiguration().getCompatibilityInstance(); |
| } else { |
| // no-op - using a StateManager, but no Compatibility settings available |
| } |
| if (compat != null) { |
| // new 2.0 behavior of using DetachedStateField to determine unproxy during serialization |
| useDSFForUnproxy = !compat.getIgnoreDetachedStateFieldForProxySerialization(); |
| } |
| } |
| |
| if (useDSFForUnproxy) { |
| // use new 2.0 behavior |
| if ((meta != null) && (Boolean.TRUE.equals(meta.usesDetachedState()))) { |
| // configured to always use and serialize a StateManger, so keep any $proxy |
| return proxy; |
| } else { |
| // already detached or using DetachedStateField==false or transient, so remove any $proxy |
| return proxy.copy(proxy); |
| } |
| } else { |
| // use old 1.0 behavior |
| if (proxy.getOwner().isDetached()) |
| return proxy; |
| else |
| return proxy.copy(proxy); |
| } |
| } |
| } |
| } |
| |
