private MethodMetadata methodExists( JavaSymbolName methodName, List<AnnotatedJavaType> paramTypes) { // We have no access to method parameter information, so we scan by name alone and treat any // match as authoritative // We do not scan the superclass, as the caller is expected to know we'll only scan the current // class for (MethodMetadata method : governorTypeDetails.getDeclaredMethods()) { if (method.getMethodName().equals(methodName) && method.getParameterTypes().equals(paramTypes)) { // Found a method of the expected name; we won't check method parameters though return method; } } return null; }
private void doModification(final MethodMetadata method, final CustomData customData) { MemberHoldingTypeDetails memberHoldingTypeDetails = memberHoldingTypeDetailsMap.get(method.getDeclaredByMetadataId()); if (memberHoldingTypeDetails != null) { MethodMetadata matchedMethod = memberHoldingTypeDetails.getMethod( method.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(method.getParameterTypes())); if (matchedMethod != null && !matchedMethod.getCustomData().keySet().containsAll(customData.keySet())) { TypeDetailsBuilder typeDetailsBuilder = getTypeDetailsBuilder(memberHoldingTypeDetails); typeDetailsBuilder.addDataToMethod(method, customData); changed = true; } } }
public void addDataToMethod(final MethodMetadata replacement, final CustomData customData) { // If the MIDs don't match then the proposed can't be a replacement if (!replacement.getDeclaredByMetadataId().equals(getDeclaredByMetadataId())) { return; } for (MethodMetadataBuilder existingMethod : getDeclaredMethods()) { if (existingMethod.getMethodName().equals(replacement.getMethodName())) { if (AnnotatedJavaType.convertFromAnnotatedJavaTypes(existingMethod.getParameterTypes()) .equals( AnnotatedJavaType.convertFromAnnotatedJavaTypes( replacement.getParameterTypes()))) { for (Object key : customData.keySet()) { existingMethod.putCustomData(key, customData.get(key)); } break; } } } }
/** * @return the static utility entityManager() method used by other methods to obtain entity * manager and available as a utility for user code (never returns nulls) */ public MethodMetadata getEntityManagerMethod() { if (parent != null) { // The parent is required to guarantee this is available return parent.getEntityManagerMethod(); } // Method definition to find or build final JavaSymbolName methodName = new JavaSymbolName(ENTITY_MANAGER_METHOD_NAME); final JavaType[] parameterTypes = {}; final JavaType returnType = ENTITY_MANAGER; // Locate user-defined method final MethodMetadata userMethod = getGovernorMethod(methodName, parameterTypes); if (userMethod != null) { Assert.isTrue( userMethod.getReturnType().equals(returnType), "Method '" + methodName + "' on '" + destination + "' must return '" + returnType.getNameIncludingTypeParameters() + "'"); return userMethod; } // Create method final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); if (Modifier.isAbstract(governorTypeDetails.getModifier())) { // Create an anonymous inner class that extends the abstract class (no-arg constructor is // available as this is a JPA entity) bodyBuilder.appendFormalLine( ENTITY_MANAGER.getNameIncludingTypeParameters( false, builder.getImportRegistrationResolver()) + " em = new " + destination.getSimpleTypeName() + "() {"); // Handle any abstract methods in this class bodyBuilder.indent(); for (final MethodMetadata method : governorTypeDetails.getMethods()) { if (Modifier.isAbstract(method.getModifier())) { final StringBuilder params = new StringBuilder(); int i = -1; final List<AnnotatedJavaType> types = method.getParameterTypes(); for (final JavaSymbolName name : method.getParameterNames()) { i++; if (i > 0) { params.append(", "); } final AnnotatedJavaType type = types.get(i); params.append(type.toString()).append(" ").append(name); } final int newModifier = method.getModifier() - Modifier.ABSTRACT; bodyBuilder.appendFormalLine( Modifier.toString(newModifier) + " " + method.getReturnType().getNameIncludingTypeParameters() + " " + method.getMethodName().getSymbolName() + "(" + params.toString() + ") {"); bodyBuilder.indent(); bodyBuilder.appendFormalLine("throw new UnsupportedOperationException();"); bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine("}"); } } bodyBuilder.indentRemove(); bodyBuilder.appendFormalLine( "}." + getEntityManagerField().getFieldName().getSymbolName() + ";"); } else { // Instantiate using the no-argument constructor (we know this is available as the entity must // comply with the JPA no-arg constructor requirement) bodyBuilder.appendFormalLine( ENTITY_MANAGER.getNameIncludingTypeParameters( false, builder.getImportRegistrationResolver()) + " em = new " + destination.getSimpleTypeName() + "()." + getEntityManagerField().getFieldName().getSymbolName() + ";"); } bodyBuilder.appendFormalLine( "if (em == null) throw new IllegalStateException(\"Entity manager has not been injected (is the Spring Aspects JAR configured as an AJC/AJDT aspects library?)\");"); bodyBuilder.appendFormalLine("return em;"); final int modifier = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL; final MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder( getId(), modifier, methodName, returnType, AnnotatedJavaType.convertFromJavaTypes(parameterTypes), new ArrayList<JavaSymbolName>(), bodyBuilder); return methodBuilder.build(); }