javax.persistence.Embedded Java Examples

/**
* Gets the source.
*
* @return the source
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "SOURCE_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "SOURCE_ID"))
  })
  public Source getSource() {
      return source;
  }
 

@Test
public void upLink() {
	assertAnnotationPresent(IdentifiedObject.class, "upLink",
			XmlTransient.class);
	assertAnnotationPresent(IdentifiedObject.class, "upLink",
			Embedded.class);
}
 

public static Field findField(Class<?> clazz, String columnName) {
    for (Field field : clazz.getDeclaredFields()) {
        if (field.getAnnotation(Embedded.class) != null || field.getAnnotation(EmbeddedId.class) != null) {
            findField(field.getClass(), columnName);
        } else {
            if (columnName.equals(DbUtil.getColumnName(field))) {
                return field;
            }
        }
    }
    return null;
}
 

/**
* Gets the lending type.
*
* @return the lending type
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "LENDING_TYPE_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "LENDING_TYPE_ID"))
  })
  public LendingType getLendingType() {
      return lendingType;
  }
 

/**
* Gets the income level.
*
* @return the income level
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "INCOME_LEVEL_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "INCOME_LEVEL_ID"))
  })
  public IncomeLevel getIncomeLevel() {
      return incomeLevel;
  }
 

/**
* Gets the adminregion.
*
* @return the adminregion
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "ADMINREGION_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "ADMINREGION_ID"))
  })
  public Adminregion getAdminregion() {
      return adminregion;
  }
 

/**
* Gets the region.
*
* @return the region
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "REGION_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "REGION_ID"))
  })
  public Region getRegion() {
      return region;
  }
 

/**
* Gets the country.
*
* @return the country
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "COUNTRY_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "COUNTRY_ID"))
  })
  public Country getCountry() {
      return country;
  }
 

/**
* Gets the indicator.
*
* @return the indicator
*/
  @Embedded
  @AttributeOverrides({
      @AttributeOverride(name = "value", column = @Column(name = "INDICATOR_VALUE")),
      @AttributeOverride(name = "id", column = @Column(name = "INDICATOR_ID"))
  })
  public Indicator getIndicator() {
      return indicator;
  }
 

private static boolean hasMethodAnnotatedWithEmbedded(Class<?> entityType) {
  boolean result = false;
  Class<?> parentType = entityType.getSuperclass();
  if (parentType != null && parentType.isAnnotationPresent(MappedSuperclass.class)) {
    result = hasMethodAnnotatedWithEmbedded(parentType);
  }
  for (Method method : entityType.getDeclaredMethods()) {
    if (method.isAnnotationPresent(Embedded.class)) {
      result = true;
      break;
    }
  }
  return result;
}
 

private Stream<Object> findEmbeddedProperties(Object object, Class<?> clazz) {
  return Arrays.stream(clazz.getDeclaredFields())
      .filter(field -> !field.isAnnotationPresent(Transient.class))
      .filter(
          field ->
              field.isAnnotationPresent(Embedded.class)
                  || field.getType().isAnnotationPresent(Embeddable.class))
      .filter(field -> !Modifier.isStatic(field.getModifiers()))
      .map(field -> getFieldObject(field, object))
      .filter(Objects::nonNull);
}
 

public static Field findField(final Class<?> clazz, final String columnName) {
    for (final Field field : clazz.getDeclaredFields()) {
        if (field.getAnnotation(Embedded.class) != null || field.getAnnotation(EmbeddedId.class) != null) {
            findField(field.getClass(), columnName);
        } else {
            if (columnName.equals(DbUtil.getColumnName(field))) {
                return field;
            }
        }
    }
    return null;
}
 

static Implementation wrap(
		TypeDescription managedCtClass,
		ByteBuddyEnhancementContext enhancementContext,
		FieldDescription persistentField,
		Implementation implementation) {
	if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) {

		if ( enhancementContext.isCompositeClass( managedCtClass ) ) {
			implementation = Advice.to( CodeTemplates.CompositeDirtyCheckingHandler.class ).wrap( implementation );
		}
		else if ( !EnhancerImpl.isAnnotationPresent( persistentField, Id.class )
				&& !EnhancerImpl.isAnnotationPresent( persistentField, EmbeddedId.class )
				&& !( persistentField.getType().asErasure().isAssignableTo( Collection.class )
				&& enhancementContext.isMappedCollection( persistentField ) ) ) {
			implementation = new InlineDirtyCheckingHandler( implementation, managedCtClass, persistentField.asDefined() );
		}

		if ( enhancementContext.isCompositeClass( persistentField.getType().asErasure() )
				&& EnhancerImpl.isAnnotationPresent( persistentField, Embedded.class ) ) {

			implementation = Advice.withCustomMapping()
					.bind( CodeTemplates.FieldValue.class, persistentField )
					.bind( CodeTemplates.FieldName.class, persistentField.getName() )
					.to( CodeTemplates.CompositeFieldDirtyCheckingHandler.class )
					.wrap( implementation );
		}
	}
	return implementation;
}
 

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
			)
	);
}
 

@Embedded
public Address getAddress() {
    return address;
}
 

@Column
@Embedded
public ProviderQosPersisted getProviderQosPersisted() {
    return providerQosPersisted;
}
 

@Test
   public void argument() {
	TestUtils.assertAnnotationPresent(ReadingType.class, "argument",
			Embedded.class);
}
 

@Test
public void interhamonic() {
    TestUtils.assertAnnotationPresent(ReadingType.class, "interharmonic", Embedded.class);
}
 

@Embedded
public Address getAddress() {
    return address;
}
 

@Embedded
public OwnerAddress getAddress() {
    return address;
}
 

@Embedded
public Name getName() {
    return name;
}
 

@Embedded
@AssociationOverride(name = "f"/*, joinColumns = { @JoinColumn(name = "E_F") }*/)
public E getE() {
	return e;
}
 

DynamicType.Builder<?> applyTo(DynamicType.Builder<?> builder, boolean accessor) {
	boolean compositeOwner = false;

	builder = builder.visit( new AsmVisitorWrapper.ForDeclaredMethods().method( not( nameStartsWith( "$$_hibernate_" ) ), this ) );
	for ( FieldDescription enhancedField : enhancedFields ) {
		builder = builder
				.defineMethod(
						EnhancerConstants.PERSISTENT_FIELD_READER_PREFIX + enhancedField.getName(),
						enhancedField.getType().asErasure(),
						Visibility.PUBLIC
				)
				.intercept(
						accessor
								? FieldAccessor.ofField( enhancedField.getName() ).in( enhancedField.getDeclaringType().asErasure() )
								: fieldReader( enhancedField )
				)
				.defineMethod(
						EnhancerConstants.PERSISTENT_FIELD_WRITER_PREFIX + enhancedField.getName(),
						TypeDescription.VOID,
						Visibility.PUBLIC
				)
				.withParameters( enhancedField.getType().asErasure() )
				.intercept( accessor
									? FieldAccessor.ofField( enhancedField.getName() ).in( enhancedField.getDeclaringType().asErasure() )
									: fieldWriter( enhancedField ) );

		if ( !compositeOwner
				&& !accessor
				&& EnhancerImpl.isAnnotationPresent( enhancedField, Embedded.class )
				&& enhancementContext.isCompositeClass( enhancedField.getType().asErasure() )
				&& enhancementContext.doDirtyCheckingInline( managedCtClass ) ) {
			compositeOwner = true;
		}
	}

	if ( compositeOwner ) {
		builder = builder.implement( CompositeOwner.class );

		if ( enhancementContext.isCompositeClass( managedCtClass ) ) {
			builder = builder.defineMethod( EnhancerConstants.TRACKER_CHANGER_NAME, void.class, Visibility.PUBLIC )
					.withParameters( String.class )
					.intercept( Advice.to( CodeTemplates.CompositeOwnerDirtyCheckingHandler.class ).wrap( StubMethod.INSTANCE ) );
		}
	}

	if ( enhancementContext.doExtendedEnhancement( managedCtClass ) ) {
		builder = applyExtended( builder );
	}

	return builder;
}
 

@Embedded
public GeoPoint getLocation() {
    return location;
}
 

@Override
@Embedded
public MCRCategoryID getId() {
    return super.getId();
}
 

@Embedded
public abstract Coordinate getCoordinate();
 

@Embedded
Coordinate getCoordinate();
 

@Embedded
EntityEmbedded getEntityEmbedded() {
  return new EntityEmbedded();
}
 

@Override
public boolean isEmbeddable() {
	return isAnnotationPresent(Embedded.class)
			|| hasActualTypeAnnotation(Embeddable.class);
}
 

/**
 * Gets the criteria.
 *
 * @return criteria
 */
@Embedded
public FilterCriteria getCriteria() {
    return criteria;
}