private void addLinkedNextHandling(CtClass managedCtClass) { FieldWriter.addFieldWithGetterAndSetter( managedCtClass, loadCtClassFromClass( ManagedEntity.class ), EnhancerConstants.NEXT_FIELD_NAME, EnhancerConstants.NEXT_GETTER_NAME, EnhancerConstants.NEXT_SETTER_NAME ); }
/** * Add enhancement field with getter and setter */ public static void addFieldWithGetterAndSetter(CtClass target, CtClass type, String field, String getter, String setter) { addPrivateTransient( target, type, field ); MethodWriter.addGetter( target, field, getter ); MethodWriter.addSetter( target, field, setter ); }
/** * Constructs the Enhancer, using the given context. * * @param enhancementContext Describes the context in which enhancement will occur so as to give access * to contextual/environmental information. */ public EnhancerImpl(EnhancementContext enhancementContext) { this.enhancementContext = new JavassistEnhancementContext( enhancementContext ); this.classPool = buildClassPool( this.enhancementContext ); }
public void enhance(CtClass managedCtClass) { // add the ManagedEntity interface managedCtClass.addInterface( loadCtClassFromClass( ManagedEntity.class ) ); addEntityInstanceHandling( managedCtClass ); addEntityEntryHandling( managedCtClass ); addLinkedPreviousHandling( managedCtClass ); addLinkedNextHandling( managedCtClass ); addInterceptorHandling( managedCtClass ); if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { addInLineDirtyHandling( managedCtClass ); } super.enhance( managedCtClass ); }
public void enhance(CtClass managedCtClass) { // add the ManagedComposite interface managedCtClass.addInterface( loadCtClassFromClass( ManagedComposite.class ) ); addInterceptorHandling( managedCtClass ); if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { addInLineDirtyHandling( managedCtClass ); } super.enhance( managedCtClass ); }
public static <T extends Annotation> T getAnnotation(CtClass ctClass, String attributeName, Class<T> annotation) { AccessType classAccessType = getAccessTypeOrNull( ctClass ); CtField field = findFieldOrNull( ctClass, attributeName ); CtMethod getter = findGetterOrNull( ctClass, attributeName ); if ( classAccessType == AccessType.FIELD || ( field != null && getAccessTypeOrNull( field ) == AccessType.FIELD ) ) { return field == null ? null : getAnnotationOrNull( field, annotation ); } if ( classAccessType == AccessType.PROPERTY || ( getter != null && getAccessTypeOrNull( getter ) == AccessType.PROPERTY ) ) { return getter == null ? null : getAnnotationOrNull( getter, annotation ); } T found = ( getter == null ? null : getAnnotationOrNull( getter, annotation ) ); if ( found == null && field != null ) { return getAnnotationOrNull( field, annotation ); } return found; }
protected void addInterceptorHandling(CtClass managedCtClass) { // interceptor handling is only needed if class has lazy-loadable attributes if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) ) { return; } log.debugf( "Weaving in PersistentAttributeInterceptable implementation on [%s]", managedCtClass.getName() ); managedCtClass.addInterface( loadCtClassFromClass( PersistentAttributeInterceptable.class ) ); FieldWriter.addFieldWithGetterAndSetter( managedCtClass, loadCtClassFromClass( PersistentAttributeInterceptor.class ), EnhancerConstants.INTERCEPTOR_FIELD_NAME, EnhancerConstants.INTERCEPTOR_GETTER_NAME, EnhancerConstants.INTERCEPTOR_SETTER_NAME ); } }
private void addInLineDirtyHandling(CtClass managedCtClass) { managedCtClass.addInterface( loadCtClassFromClass( CompositeTracker.class ) ); final CtClass compositeCtType = loadCtClassFromClass( CompositeOwnerTracker.class ); FieldWriter.addField( managedCtClass, compositeCtType, EnhancerConstants.TRACKER_COMPOSITE_FIELD_NAME ); createCompositeTrackerMethod( managedCtClass ); }
public void enhance(CtClass managedCtClass) { // Add the Managed interface managedCtClass.addInterface( loadCtClassFromClass( ManagedMappedSuperclass.class ) ); super.enhance( managedCtClass ); }
@Override // change visibility protected -> public public CtClass loadCtClassFromClass(Class<?> aClass) { return super.loadCtClassFromClass( aClass ); } }
public static boolean hasAnnotation(CtField attribute, Class<? extends Annotation> annotation) { return getAnnotation( attribute, annotation ) != null; }
@Override public ClassLoader getClassLoader() { return enhancementContext.getLoadingClassLoader(); } };
@Override public Enhancer getEnhancer(EnhancementContext enhancementContext) { return new EnhancerImpl( enhancementContext ); } }
public static boolean isPossibleBiDirectionalAssociation(CtField persistentField) { return PersistentAttributesHelper.hasAnnotation( persistentField, OneToOne.class ) || PersistentAttributesHelper.hasAnnotation( persistentField, OneToMany.class ) || PersistentAttributesHelper.hasAnnotation( persistentField, ManyToOne.class ) || PersistentAttributesHelper.hasAnnotation( persistentField, ManyToMany.class ); }
/** * Add enhancement field */ public static void addField(CtClass target, CtClass type, String field) { addPrivateTransient( target, type, field ); }
EnhancerImpl(JavassistEnhancementContext enhancementContext) { this.enhancementContext = enhancementContext; this.classPool = buildClassPool( enhancementContext ); }
public CtField[] order(CtField[] persistentFields) { UnloadedField[] unloadedFields = new UnloadedField[persistentFields.length]; for ( int i = 0; i < unloadedFields.length; i++ ) { unloadedFields[i] = new UnloadedCtField( persistentFields[i] ); } UnloadedField[] ordered = enhancementContext.order( unloadedFields ); CtField[] orderedFields = new CtField[persistentFields.length]; for ( int i = 0; i < orderedFields.length; i++ ) { orderedFields[i] = ( (UnloadedCtField) ordered[i] ).ctField; } return orderedFields; }
private void addLinkedPreviousHandling(CtClass managedCtClass) { FieldWriter.addFieldWithGetterAndSetter( managedCtClass, loadCtClassFromClass( ManagedEntity.class ), EnhancerConstants.PREVIOUS_FIELD_NAME, EnhancerConstants.PREVIOUS_GETTER_NAME, EnhancerConstants.PREVIOUS_SETTER_NAME ); }
public static boolean hasAnnotation(CtClass ctClass, String attributeName, Class<? extends Annotation> annotation) { return getAnnotation( ctClass, attributeName, annotation ) != null; }
private void addEntityEntryHandling(CtClass managedCtClass) { FieldWriter.addFieldWithGetterAndSetter( managedCtClass, loadCtClassFromClass( EntityEntry.class ), EnhancerConstants.ENTITY_ENTRY_FIELD_NAME, EnhancerConstants.ENTITY_ENTRY_GETTER_NAME, EnhancerConstants.ENTITY_ENTRY_SETTER_NAME ); }