private FieldInfo[] mergeFieldInfos(FieldInfo[] advisedInfos, boolean read) { FieldInfo[] newInfos = new FieldInfo[advisedFields.length]; int nextIndex = 0; int advisedInfosLength = advisedInfos == null? 0: advisedInfos.length; for (int i = 0 ; i < advisedFields.length ; i++) { if (nextIndex < advisedInfosLength && advisedInfos[nextIndex].getIndex() == i) { if (super.initialized) { advisedInfos[nextIndex].clear(); } newInfos[i] = advisedInfos[nextIndex]; nextIndex++; } else { FieldInfo info = new FieldInfo(this, read); info.setAdvisedField(advisedFields[i]); info.setIndex(i); newInfos[i] = info; } } return newInfos; }
/** * To be called by initialiseInfosForInstance() in the generated instance advisors */ protected FieldInfo copyInfoFromClassAdvisor(FieldInfo info) { FieldInfo copy = (FieldInfo)info.copy(); copy.setAdvisor(this); // TODO Flavia // if (copy.isRead()) // { // addFieldReadInfo(copy); // } // else // { // addFieldWriteInfo(copy); // } return copy; }
protected FieldInvocation(FieldInfo info, Interceptor[] interceptors) { this(info.getField(), info.getIndex(), interceptors); this.advisor = info.getAdvisor(); }
for (int i = 0; i < advisedFields.length; i++) FieldInfo info = new FieldInfo(); info.setAdvisedField(advisedFields[i]); info.setAdvisor(this); info.setIndex(i); info.setWrapper(clazz.getDeclaredMethod( FieldAccessTransformer.fieldRead(advisedFields[i].getName()), new Class[] {Object.class}));
protected void updateFieldPointcutAfterRemove(FieldInfo[] fieldInfos, AdviceBinding binding, boolean write) { ClassifiedBindingAndPointcutCollection bindingCol = manager.getBindingCollection(); Collection<AdviceBinding> bindings = write? bindingCol.getFieldWriteBindings(): bindingCol.getFieldReadBindings(); for (int i = 0; i < fieldInfos.length; i++) { Field field = fieldInfos[i].getField(); fieldInfos[i].resetInterceptors(); if ((!write && binding.getPointcut().matchesGet(this, field)) || (write && binding.getPointcut().matchesSet(this, field))) { if (AspectManager.verbose) logger.debug("Removing field, matched " + ((write) ? "write" : "read") + " binding: " + field); fieldInfos[i].clear(); for(AdviceBinding ab : bindings) { if ((!write && ab.getPointcut().matchesGet(this, field)) || (write && ab.getPointcut().matchesSet(this, field))) { ab.addAdvisor(this); pointcutResolved(fieldInfos[i], ab, new FieldJoinpoint(field)); } } this.updateFieldPointcutAfterRemove(fieldInfos[i], i, write); } } }
public FieldJoinPointGenerator(GeneratedClassAdvisor advisor, JoinPointInfo info) { super(advisor, info, getParameters((FieldInfo) info), ((FieldInfo) info).isRead()? 0: 1, ((FieldInfo) info).isRead()); if (((FieldInfo)info).isRead()) { read = true; returnClassType = new WeakReference<Class<?>>(((FieldInfo)info).getField().getType()); returnType = new WeakReference<Type>(((FieldInfo)info).getField().getGenericType()); } hasTargetObject = !Modifier.isStatic(((FieldInfo)info).getField().getModifiers()); }
public FieldJoinPointGenerator getJoinPointGenerator(FieldInfo info) if (info.isRead()) FieldJoinPointGenerator generator = fieldReadJoinPoinGenerators.get(info.getJoinpoint()); if (generator == null) FieldJoinPointGenerator existing = fieldReadJoinPoinGenerators.putIfAbsent(info.getJoinpoint(), generator); if (existing != null) FieldJoinPointGenerator generator = (FieldJoinPointGenerator)joinPointGenerators.get(info.getJoinpoint()); if (generator == null) FieldJoinPointGenerator existing = (FieldJoinPointGenerator)joinPointGenerators.putIfAbsent(info.getJoinpoint(), generator); if (existing != null)
@Override protected void updateFieldPointcutAfterRemove(FieldInfo fieldInfo, int i, boolean write) { if (AspectManager.maintainAdvisorMethodInterceptors) { if (write) { this.fieldWriteInterceptors[i] = fieldInfo.getInterceptors(); } else { this.fieldReadInterceptors[i] = fieldInfo.getInterceptors(); } } }
protected void resolveFieldPointcut(FieldInfo[] newFieldInfos, Interceptor[][] interceptors, AdviceBinding binding, boolean write) { for (int i = 0; i < newFieldInfos.length; i++) { Field field = newFieldInfos[i].getField(); if ((!write && binding.getPointcut().matchesGet(this, field)) || (write && binding.getPointcut().matchesSet(this, field))) { if (AspectManager.verbose) logger.debug("field matched " + ((write) ? "write" : "read") + " binding: " + field); adviceBindings.add(binding); binding.addAdvisor(this); pointcutResolved(newFieldInfos[i], binding, new FieldJoinpoint(field)); if (AspectManager.maintainAdvisorMethodInterceptors && this.initialized) { interceptors[i] = newFieldInfos[i].getInterceptors(); } } } }
private String fieldName(FieldInfo info) { return info.getField().getName(); }
/** * Attempt to invoke the original interceptor chain attached to the * field read in the target class. * For now we don't bother attempting to use optimized invocations since we * are using reflection anyway */ private Object invokeOriginalChainIfExists(Invocation invocation, Field field, Object targetObject) throws Throwable { //Don't attach to caller chain, since we don't have caller interception for fields //Try to attach to chain on target object ClassAdvisor advisor = AspectManager.instance().getAdvisor(field.getDeclaringClass()); Class<?> calledClass = field.getDeclaringClass(); if (isAdvised(calledClass)) { if (advisor != null && advisor.hasAspects()) { int index = advisor.getFieldIndex(field); if (index >= 0) { FieldInfo jp = advisor.getFieldReadInfos()[index]; return jp.getWrapper().invoke(null, new Object[] {targetObject}); } } } return invocation.invokeNext(); }
public JoinPointInfo copy() { return new FieldInfo(this); }
public <T extends Annotation> T resolveAnnotation(Class<T> annotation) { T val = super.resolveAnnotation(annotation); if (val != null) return val; if (getAdvisor() != null) { val = getAdvisor().resolveTypedAnnotation(advisedField, annotation); if (val != null) return val; } return null; }
private void easyFinalizeFieldChainForInstance(Map<Joinpoint, Interceptor[]> oldFieldInfos, FieldInfo[] classFieldInfos, FieldInfo[] newFieldInfos, OldInfoMaps oldInfoMapInstance) { //We are an instance advisor with no own data influencing the chains, copy these from the parent advisor for (int i = 0; i < newFieldInfos.length; i++) { FieldInfo myInfo = newFieldInfos[i]; myInfo.cloneChains(classFieldInfos[i]); if (updateOldInfo(oldFieldInfos, myInfo, oldInfoMapInstance)) { FieldJoinPointGenerator generator = getJoinPointGenerator(myInfo); generator.rebindJoinpoint(myInfo); } } }
for (int i = 0; i < advisedFields.length; i++) FieldInfo info = new FieldInfo(); info.setAdvisedField(advisedFields[i]); info.setAdvisor(this); info.setIndex(i); info.setWrapper(clazz.getDeclaredMethod( FieldAccessTransformer.fieldWrite(advisedFields[i].getName()), new Class[] {Object.class, advisedFields[i].getType()}));
for (int i = 0 ; i < fieldReadInfos.length ; i++) fieldReadInterceptors[i] = fieldReadInfos[i].getInterceptors(); fieldWriteInterceptors[i] = fieldWriteInfos[i].getInterceptors();
private static JoinPointParameters getParameters(FieldInfo info) { if (Modifier.isStatic(info.getField().getModifiers())) { return JoinPointParameters.ONLY_ARGS; } return JoinPointParameters.TARGET_ARGS; }
/** * Attempt to invoke the original interceptor chain attached to the * field write in the target class. * For now we don't bother attempting to use optimized invocations since we * are using reflection anyway */ private Object invokeOriginalChainIfExists(Invocation invocation, Field field, Object targetObject, Object value) throws Throwable { //Don't attach to caller chain, since we don't have caller interception for fields //Try to attach to chain on target object ClassAdvisor advisor = AspectManager.instance().getAdvisor(field.getDeclaringClass()); Class<?> calledClass = field.getDeclaringClass(); if (isAdvised(calledClass)) { if (advisor != null && advisor.hasAspects()) { int index = advisor.getFieldIndex(field); if (index >= 0) { FieldInfo jp = advisor.getFieldWriteInfos()[index]; return jp.getWrapper().invoke(null, new Object[] {targetObject, value}); } } } return invocation.invokeNext(); }
/** * Invokes interceptor chain. * This is the beginning */ public Object invokeRead(Object target, int index) throws Throwable { Interceptor[] aspects = fieldReadInfos[index].getInterceptors(); if (aspects == null) aspects = new Interceptor[0]; FieldReadInvocation invocation; if (target != null) { InstanceAdvised advised = (InstanceAdvised) target; InstanceAdvisor advisor = advised._getInstanceAdvisor(); if (advisor != null && advisor.hasInterceptors()) { aspects = advisor.getInterceptors(aspects); } } invocation = new FieldReadInvocation(advisedFields[index], index, aspects); invocation.setAdvisor(this); invocation.setTargetObject(target); return invocation.invokeNext(); }
public void makeAccessibleField(FieldInfo fi) { //If we do dynamic invokes the field will need to be accessible via reflection SecurityActions.setAccessible(fi.getField()); }