javax.persistence.OneToMany Java Examples

/**
 * Get the position entries for this object.
 */
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, orphanRemoval = true, mappedBy = "auftrag")
@IndexColumn(name = "number", base = 1)
public List<AuftragsPositionDO> getPositionen()
{
  return this.positionen;
}
 

/**
 * @return the configuration
 */
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumns({
		@JoinColumn(name = "clusterId", referencedColumnName = "clusterId"),
		@JoinColumn(name = "host", referencedColumnName = "publicIp") })
public List<Configuration> getConfiguration() {
	return configuration;
}
 

private CascadeType[] getCascadeTypes(AccessibleObject accessibleObject) {
    CascadeType[] cascadeTypes = null;
    if(accessibleObject.isAnnotationPresent(OneToMany.class)) {
        cascadeTypes = accessibleObject.getAnnotation(OneToMany.class).cascade();
    }else if(accessibleObject.isAnnotationPresent(ManyToOne.class)) {
        cascadeTypes = accessibleObject.getAnnotation(ManyToOne.class).cascade();
    }else if(accessibleObject.isAnnotationPresent(ManyToMany.class)) {
        cascadeTypes = accessibleObject.getAnnotation(ManyToMany.class).cascade();
    }
    return cascadeTypes;
}
 

@OneToMany(cascade = CascadeType.ALL)
public List<EItem> getEItems() {
	if (eItems == null) {
		eItems = new ArrayList<EItem>();
	}
	if (ItemUtils.shouldBeWrapped(e))
		e = ItemUtils.wrap(e, eItems, EItem.class);
	return this.eItems;
}
 

/**
 * @return the configuration
 */
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
@JoinColumns({
		@JoinColumn(name = "clusterId", referencedColumnName = "clusterId"),
		@JoinColumn(name = "host", referencedColumnName = "publicIp") })
public List<Event> getEvents() {
	return events;
}
 

@Cascade(CascadeType.ALL)
@OneToMany(fetch = FetchType.LAZY, mappedBy = "taskData")
@OnDelete(action = OnDeleteAction.CASCADE)
@OrderColumn(name = "SCRIPT_ORDER")
public List<SelectionScriptData> getSelectionScripts() {
    return selectionScripts;
}
 

/**
* Gets the document attachment list.
*
* @return the document attachment list
*/
  @OneToMany(targetEntity = DocumentAttachment.class, cascade = {
      CascadeType.ALL
  })
  @JoinColumn(name = "DOCUMENT_ATTACHMENT_LIST_DOC_0")
  public List<DocumentAttachment> getDocumentAttachmentList() {
      return this.documentAttachmentList;
  }
 

/**
* Gets the detail list.
*
* @return the detail list
*/
  @OneToMany(targetEntity = DetailData.class, cascade = {
      CascadeType.ALL
  })
  @JoinColumn(name = "DETAIL_LIST_PERSON_DETAIL_DA_0")
  public List<DetailData> getDetailList() {
      return this.detailList;
  }
 

@OneToMany(targetEntity = ControlMessage.class, fetch = FetchType.LAZY, cascade = CascadeType.ALL)
public List<ControlMessage> getControlMessage() {
        if (controlledMessage == null) {
                controlledMessage = new ArrayList<ControlMessage>();
        }
        return this.controlledMessage;
}
 

/**
 * 获取子类资源
 * 
 * @return List
 */
@OrderBy("sort ASC")
@OneToMany(mappedBy = "parent",fetch = FetchType.LAZY,cascade={CascadeType.ALL})
public List<Resource> getChildren() {
	return children;
}
 

@OneToMany(cascade={CascadeType.ALL},mappedBy="roleId")
public Set<UsersRoles> getUsersRoles() {
	return usersRoles;
}
 

/** @return . */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "ticketCatalog")
public Set<TicketInfo> getTicketInfos() {
    return this.ticketInfos;
}
 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "module")
public Set<Syslog> getSyslogs() {
	return this.syslogs;
}
 

@OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
public Set<Comment> getComments() {
    return this.comments;
}
 

/** @return . */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "ticketInfo")
public Set<TicketComment> getTicketComments() {
    return this.ticketComments;
}
 

/** @return . */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "userRepo")
public Set<UserBase> getUserBases() {
    return this.userBases;
}
 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "address")
@OrderBy
public List<AddressLine> getAddressLines() {
	return this.addressLines;
}
 

/** @return . */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "plmProject")
public Set<PlmIssue> getPlmIssues() {
    return this.plmIssues;
}
 

protected void bindOneToManySecondPass(
		Collection collection,
		Map persistentClasses,
		Ejb3JoinColumn[] fkJoinColumns,
		XClass collectionType,
		boolean cascadeDeleteEnabled,
		boolean ignoreNotFound,
		MetadataBuildingContext buildingContext,
		Map<XClass, InheritanceState> inheritanceStatePerClass) {

	final boolean debugEnabled = LOG.isDebugEnabled();
	if ( debugEnabled ) {
		LOG.debugf( "Binding a OneToMany: %s.%s through a foreign key", propertyHolder.getEntityName(), propertyName );
	}
	if ( buildingContext == null ) {
		throw new AssertionFailure(
				"CollectionSecondPass for oneToMany should not be called with null mappings"
		);
	}
	org.hibernate.mapping.OneToMany oneToMany = new org.hibernate.mapping.OneToMany( buildingContext, collection.getOwner() );
	collection.setElement( oneToMany );
	oneToMany.setReferencedEntityName( collectionType.getName() );
	oneToMany.setIgnoreNotFound( ignoreNotFound );

	String assocClass = oneToMany.getReferencedEntityName();
	PersistentClass associatedClass = (PersistentClass) persistentClasses.get( assocClass );
	if ( jpaOrderBy != null ) {
		final String orderByFragment = buildOrderByClauseFromHql(
				jpaOrderBy.value(),
				associatedClass,
				collection.getRole()
		);
		if ( StringHelper.isNotEmpty( orderByFragment ) ) {
			collection.setOrderBy( orderByFragment );
		}
	}
	Map<String, Join> joins = buildingContext.getMetadataCollector().getJoins( assocClass );
	if ( associatedClass == null ) {
		throw new MappingException(
				String.format("Association [%s] for entity [%s] references unmapped class [%s]",
						propertyName, propertyHolder.getClassName(), assocClass)
		);
	}
	oneToMany.setAssociatedClass( associatedClass );
	for (Ejb3JoinColumn column : fkJoinColumns) {
		column.setPersistentClass( associatedClass, joins, inheritanceStatePerClass );
		column.setJoins( joins );
		collection.setCollectionTable( column.getTable() );
	}
	if ( debugEnabled ) {
		LOG.debugf( "Mapping collection: %s -> %s", collection.getRole(), collection.getCollectionTable().getName() );
	}
	bindFilters( false );
	bindCollectionSecondPass( collection, null, fkJoinColumns, cascadeDeleteEnabled, property, propertyHolder, buildingContext );
	if ( !collection.isInverse()
			&& !collection.getKey().isNullable() ) {
		// for non-inverse one-to-many, with a not-null fk, add a backref!
		String entityName = oneToMany.getReferencedEntityName();
		PersistentClass referenced = buildingContext.getMetadataCollector().getEntityBinding( entityName );
		Backref prop = new Backref();
		prop.setName( '_' + fkJoinColumns[0].getPropertyName() + '_' + fkJoinColumns[0].getLogicalColumnName() + "Backref" );
		prop.setUpdateable( false );
		prop.setSelectable( false );
		prop.setCollectionRole( collection.getRole() );
		prop.setEntityName( collection.getOwner().getEntityName() );
		prop.setValue( collection.getKey() );
		referenced.addProperty( prop );
	}
}
 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "module")
public Set<RolePermission> getRolePermissions() {
	return this.rolePermissions;
}
 

@OneToMany(mappedBy="order",cascade={CascadeType.ALL})
public Set<OrderProductRecord> getProductRecords() {
	return productRecords;
}
 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "role")
public Set<RoleModule> getRoleModules() {
	return this.roleModules;
}
 

@OneToMany(mappedBy = "owner", cascade = CascadeType.ALL)
public Set<GameProfile> getProfiles() {
	return profiles;
}
 

/**
 * @return the repo digests
 */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "buildHistory", cascade = CascadeType.ALL)
public Set<ImageRepoDigest> getRepoDigests() {
    return repoDigests;
}
 

/**
 * @return the build history
 */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "imageInfo", cascade = CascadeType.ALL)
public Set<ImageBuildHistory> getBuildHistory() {
    return buildHistory;
}
 

/**
 * @return the packages
 */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "imageInfo")
public Set<ImagePackage> getPackages() {
    return packages;
}
 

/** @return . */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "userRepo")
public Set<UserSchema> getUserSchemas() {
    return this.userSchemas;
}
 

@OneToMany(fetch = FetchType.LAZY, mappedBy = "classes")
public Set<InstructorClasses> getClasseses() {
	return this.instructorClasses;
}
 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "module")
public Set<UserPermission> getUserPermissions() {
	return this.userPermissions;
}
 

@OneToMany(mappedBy="order",cascade={CascadeType.ALL})
public Set<PaymentPlan> getPaymentPlans() {
	return paymentPlans;
}