/** * 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 ManagedComposite interface managedCtClass.addInterface( loadCtClassFromClass( ManagedComposite.class ) ); addInterceptorHandling( managedCtClass ); if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { addInLineDirtyHandling( managedCtClass ); } super.enhance( managedCtClass ); }
if ( enhancementContext.isEntityClass( managedCtClass ) ) { log.debugf( "Enhancing [%s] as Entity", managedCtClass.getName() ); new EntityEnhancer( enhancementContext ).enhance( managedCtClass ); return true; else if ( enhancementContext.isCompositeClass( managedCtClass ) ) { log.debugf( "Enhancing [%s] as Composite", managedCtClass.getName() ); new CompositeEnhancer( enhancementContext ).enhance( managedCtClass ); return true; else if ( enhancementContext.isMappedSuperclassClass( managedCtClass ) ) { log.debugf( "Enhancing [%s] as MappedSuperclass", managedCtClass.getName() ); new MappedSuperclassEnhancer( enhancementContext ).enhance( managedCtClass ); return true; else if ( enhancementContext.doExtendedEnhancement( managedCtClass ) ) { log.debugf( "Extended enhancement of [%s]", managedCtClass.getName() ); new PersistentAttributesEnhancer( enhancementContext ).extendedEnhancement( managedCtClass );
private List<CtField> collectCollectionFields(CtClass managedCtClass) { List<CtField> collectionList = new ArrayList<>(); for ( CtField ctField : managedCtClass.getDeclaredFields() ) { // skip static fields and skip fields added by enhancement if ( Modifier.isStatic( ctField.getModifiers() ) || ctField.getName().startsWith( "$$_hibernate_" ) ) { continue; } if ( enhancementContext.isPersistentField( ctField ) && !enhancementContext.isMappedCollection( ctField ) ) { if ( PersistentAttributesHelper.isAssignable( ctField, Collection.class.getName() ) || PersistentAttributesHelper.isAssignable( ctField, Map.class.getName() ) ) { collectionList.add( ctField ); } } } // HHH-10646 Add fields inherited from @MappedSuperclass // HHH-10981 There is no need to do it for @MappedSuperclass if ( !enhancementContext.isMappedSuperclassClass( managedCtClass ) ) { collectionList.addAll( collectInheritCollectionFields( managedCtClass ) ); } return collectionList; }
if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) || !enhancementContext.isLazyLoadable( persistentField ) ) { writer = MethodWriter.write( managedCtClass, if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { if ( enhancementContext.isCompositeClass( managedCtClass ) ) { writer.insertBefore( String.format( if ( enhancementContext.doBiDirectionalAssociationManagement( persistentField ) ) { handleBiDirectionalAssociation( managedCtClass, persistentField, writer );
CtClass targetCtClass = classPool.getCtClass( fieldClassName ); if ( !enhancementContext.isEntityClass( targetCtClass ) && !enhancementContext.isCompositeClass( targetCtClass ) ) { continue; || !enhancementContext.isPersistentField( targetCtClass.getField( fieldName ) ) || PersistentAttributesHelper.hasAnnotation( targetCtClass, fieldName, Id.class ) || "this$0".equals( fieldName ) ) {
if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) || !enhancementContext.isLazyLoadable( persistentField ) ) { reader = MethodWriter.write( managedCtClass, "public %s %s() { return %s;%n}",
@Override public ClassLoader getClassLoader() { return enhancementContext.getLoadingClassLoader(); } };
private void addCompositeOwnerInterface(CtClass managedCtClass) throws NotFoundException, CannotCompileException { CtClass compositeOwnerCtClass = managedCtClass.getClassPool().get( CompositeOwner.class.getName() ); // HHH-10540 only add the interface once for ( CtClass i : managedCtClass.getInterfaces() ) { if ( i.subclassOf( compositeOwnerCtClass ) ) { return; } } managedCtClass.addInterface( compositeOwnerCtClass ); if ( enhancementContext.isCompositeClass( managedCtClass ) ) { // if a composite have a embedded field we need to implement the TRACKER_CHANGER_NAME method as well MethodWriter.write( managedCtClass, "public void %1$s(String name) {%n" + " if (%2$s != null) { %2$s.callOwner(\".\" + name); }%n}", EnhancerConstants.TRACKER_CHANGER_NAME, EnhancerConstants.TRACKER_COMPOSITE_FIELD_NAME ); } }
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 ); } }
public void enhance(CtClass managedCtClass) { final IdentityHashMap<String, PersistentAttributeAccessMethods> attrDescriptorMap = new IdentityHashMap<String, PersistentAttributeAccessMethods>(); for ( CtField persistentField : collectPersistentFields( managedCtClass ) ) { attrDescriptorMap.put( persistentField.getName(), enhancePersistentAttribute( managedCtClass, persistentField ) ); } // find all references to the transformed fields and replace with calls to the added reader/writer methods enhanceAttributesAccess( managedCtClass, attrDescriptorMap ); // same thing for direct access to fields of other entities if ( this.enhancementContext.doExtendedEnhancement( managedCtClass ) ) { extendedEnhancement( managedCtClass ); } }
if ( ctClass.getName().equals( Collection.class.getName() ) ) { if ( context.isMappedCollection( currentValue ) ) { return "";
if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) || !enhancementContext.isLazyLoadable( persistentField ) ) { writer = MethodWriter.write( managedCtClass, if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { if ( enhancementContext.isCompositeClass( managedCtClass ) ) { writer.insertBefore( String.format( if ( enhancementContext.doBiDirectionalAssociationManagement( persistentField ) ) { handleBiDirectionalAssociation( managedCtClass, persistentField, writer );
private Collection<CtField> collectInheritCollectionFields(CtClass managedCtClass) { if ( managedCtClass == null || Object.class.getName().equals( managedCtClass.getName() ) ) { return Collections.emptyList(); } try { CtClass managedCtSuperclass = managedCtClass.getSuperclass(); if ( !enhancementContext.isMappedSuperclassClass( managedCtSuperclass ) ) { return collectInheritCollectionFields( managedCtSuperclass ); } List<CtField> collectionList = new ArrayList<CtField>(); for ( CtField ctField : managedCtSuperclass.getDeclaredFields() ) { if ( !Modifier.isStatic( ctField.getModifiers() ) ) { if ( enhancementContext.isPersistentField( ctField ) && !enhancementContext.isMappedCollection( ctField ) ) { if ( PersistentAttributesHelper.isAssignable( ctField, Collection.class.getName() ) || PersistentAttributesHelper.isAssignable( ctField, Map.class.getName() ) ) { collectionList.add( ctField ); } } } } collectionList.addAll( collectInheritCollectionFields( managedCtSuperclass ) ); return collectionList; } catch ( NotFoundException nfe ) { return Collections.emptyList(); } }
CtClass targetCtClass = classPool.getCtClass( fieldClassName ); if ( !enhancementContext.isEntityClass( targetCtClass ) && !enhancementContext.isCompositeClass( targetCtClass ) ) { continue; || !enhancementContext.isPersistentField( targetCtClass.getField( fieldName ) ) || PersistentAttributesHelper.hasAnnotation( targetCtClass, fieldName, Id.class ) || "this$0".equals( fieldName ) ) {
if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) || !enhancementContext.isLazyLoadable( persistentField ) ) { reader = MethodWriter.write( managedCtClass, "public %s %s() { return %s;%n}",
private ClassPool buildClassPool(JavassistEnhancementContext enhancementContext) { ClassPool classPool = new ClassPool( false ) { @Override public ClassLoader getClassLoader() { return enhancementContext.getLoadingClassLoader(); } }; ClassLoader loadingClassLoader = enhancementContext.getLoadingClassLoader(); if ( loadingClassLoader != null ) { classPool.appendClassPath( new LoaderClassPath( loadingClassLoader ) ); } return classPool; }
private void handleCompositeField(CtClass managedCtClass, CtField persistentField, CtMethod fieldWriter) throws NotFoundException, CannotCompileException { if ( !enhancementContext.isCompositeClass( persistentField.getType() ) || !PersistentAttributesHelper.hasAnnotation( persistentField, Embedded.class ) ) { return; } // make sure to add the CompositeOwner interface addCompositeOwnerInterface( managedCtClass ); // cleanup previous owner fieldWriter.insertBefore( String.format( "if (%1$s != null) { ((%2$s) %1$s).%3$s(\"%1$s\"); }%n", persistentField.getName(), CompositeTracker.class.getName(), EnhancerConstants.TRACKER_COMPOSITE_CLEAR_OWNER ) ); // trigger track changes fieldWriter.insertAfter( String.format( "if (%1$s != null) { ((%2$s) %1$s).%4$s(\"%1$s\", (%3$s) this); }%n" + "%5$s(\"%1$s\");", persistentField.getName(), CompositeTracker.class.getName(), CompositeOwner.class.getName(), EnhancerConstants.TRACKER_COMPOSITE_SET_OWNER, EnhancerConstants.TRACKER_CHANGER_NAME ) ); }
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 ); } }
public void enhance(CtClass managedCtClass) { final IdentityHashMap<String, PersistentAttributeAccessMethods> attrDescriptorMap = new IdentityHashMap<String, PersistentAttributeAccessMethods>(); for ( CtField persistentField : collectPersistentFields( managedCtClass ) ) { attrDescriptorMap.put( persistentField.getName(), enhancePersistentAttribute( managedCtClass, persistentField ) ); } // find all references to the transformed fields and replace with calls to the added reader/writer methods enhanceAttributesAccess( managedCtClass, attrDescriptorMap ); // same thing for direct access to fields of other entities if ( this.enhancementContext.doExtendedEnhancement( managedCtClass ) ) { extendedEnhancement( managedCtClass ); } }