public ClassInstanceAdvisor() { delegate = new InstanceAdvisorDelegate(null, this); delegate.initialize(); }
private Advisor getClassAdvisor() { return getAdvisor(); }
public SimpleMetaData getMetaData() { return delegate.getMetaData(); }
public void initialize() { initializeAspects(); initializeJoinpointAspects(); }
initializeJoinpointAspects(); return getJoinpointAspect(def, joinpoint); Object aspect = getJoinpointAspect(def, joinpoint); if (aspect == null) aspect = getJoinpointAspect(def, joinpoint); if (aspect != null) if (classAdvisor != null && getClassAdvisor() instanceof ClassAdvisor) ClassAdvisor cadvisor = (ClassAdvisor) getClassAdvisor(); cadvisor.addPerInstanceJoinpointAspect(joinpoint, def); aspect = def.getFactory().createPerJoinpoint(getClassAdvisor(), instanceAdvisor, joinpoint); WeakHashMap<AspectDefinition, ConcurrentHashMap<Joinpoint, Object>> copy = new WeakHashMap<AspectDefinition, ConcurrentHashMap<Joinpoint, Object>>(joinpointAspects); Map<Joinpoint, Object> map = copy.get(def);
public Object getPerInstanceAspect(String def) { return delegate.getPerInstanceAspect(def); }
private synchronized void initializeJoinpointAspects() if (getClassAdvisor() == null) return; if (joinpointAspects != null) return; // doublecheck I know, but I don't want to do synchronization if not needed if (instanceAdvisor instanceof Advisor) for (AspectDefinition def : instanceJpAspects.keySet()) initJoinpointAspect(def, instanceJpAspects); Set<Joinpoint> joinpoints = instanceJpAspects.get(def); ia.addPerInstanceJoinpointAspect(joinpoints, def); Map<AspectDefinition, Set<Joinpoint>> jpAspects = getClassAdvisor().getPerInstanceJoinpointAspectDefinitions(); if (jpAspects.size() > 0) for (AspectDefinition def : jpAspects.keySet()) initJoinpointAspect(def, jpAspects);
public Object getPerInstanceAspect(AspectDefinition def) { // aspects is a weak hash map of AspectDefinitions so that perinstance advices can be undeployed/redeployed if (aspects == null) { initializeAspects(); if (aspects != null) { return aspects.get(def); } } if (!aspects.containsKey(def)) { synchronized (this) // doublecheck, but I don't want to synchronize everywhere and dynamic aspects are rare { if (aspects.containsKey(def)) return aspects.get(def); if (classAdvisor != null && getClassAdvisor() instanceof ClassAdvisor) { ClassAdvisor cadvisor = (ClassAdvisor) getClassAdvisor(); cadvisor.getPerInstanceAspectDefinitions().add(def); Object aspect = def.getFactory().createPerInstance(null, null); WeakHashMap<AspectDefinition, Object> copy = new WeakHashMap<AspectDefinition, Object>(aspects); copy.put(def, aspect); aspects = copy; return aspect; } } } return aspects.get(def); }
public Object getPerInstanceJoinpointAspect(Joinpoint joinpoint, AspectDefinition def) { return delegate.getPerInstanceJoinpointAspect(joinpoint, def); }
private void initJoinpointAspect(AspectDefinition def, Map<AspectDefinition, Set<Joinpoint>> jpAspects) { ConcurrentHashMap<Joinpoint, Object> joins = new ConcurrentHashMap<Joinpoint, Object>(); joinpointAspects.put(def, joins); Set<Joinpoint> joinpoints = jpAspects.get(def); for (Joinpoint joinpoint : joinpoints) { Object aspect = def.getFactory().createPerJoinpoint(getClassAdvisor(), instanceAdvisor, joinpoint); if (aspect == null) { joins.put(joinpoint, NULL_ASPECT); } else { joins.put(joinpoint, aspect); } } }
public Object getPerInstanceAspect(AspectDefinition def) { return delegate.getPerInstanceAspect(def); }
public Object getPerInstanceJoinpointAspect(Joinpoint joinpoint, AspectDefinition def) { return delegate.getPerInstanceJoinpointAspect(joinpoint, def); }
private synchronized void initializeAspects() if (getClassAdvisor() == null) return; if (aspects != null) return; // doublecheck I know, but I don't want to do synchronization if not needed Object aspect = def.getFactory().createPerInstance(getClassAdvisor(), instanceAdvisor); aspects.put(def, aspect); Set<AspectDefinition> defs = getClassAdvisor().getPerInstanceAspectDefinitions(); if (defs.size() > 0) Object aspect = def.getFactory().createPerInstance(getClassAdvisor(), instanceAdvisor); aspects.put(def, aspect);
public GeneratedInstanceAdvisorMixin(Object instance, GeneratedClassAdvisor genadvisor) { this.instanceRef = new WeakReference<Object>(instance); delegate = new InstanceAdvisorDelegate(genadvisor, this); delegate.initialize(); this.interceptorChainObserver = ((ClassAdvisor) genadvisor).getInterceptorChainObserver(); }
public Object getPerInstanceAspect(AspectDefinition def) { return delegate.getPerInstanceAspect(def); }
public Object getPerInstanceJoinpointAspect(Joinpoint joinpoint, AspectDefinition def) { return delegate.getPerInstanceJoinpointAspect(joinpoint, def); }
public SimpleMetaData getMetaData() { return delegate.getMetaData(); }
/** * Added to notify interceptor chain observer of interceptor chain garbage collection. */ protected void finalize() { ClassLoader classLoader = delegate.getAdvisor().getClassLoader(); if (this.interceptorChainObserver == null || !AspectManager.getRegisteredCLs().containsKey(classLoader)) { return; } this.interceptorChainObserver.allInstanceInterceptorsRemoved(this); }
private void setAdvisorAndInitialise(Advisor advizor) { this.classAdvisorRef = new WeakReference<Advisor>(advizor); if (advizor instanceof ClassAdvisor) { delegate = new InstanceAdvisorDelegate(advizor, this); delegate.initialize(); this.interceptorChainObserver = ((ClassAdvisor) advizor).getInterceptorChainObserver(); } }
public Object getPerInstanceAspect(String aspectName) { return delegate.getPerInstanceAspect(aspectName); }