JPA와 최대 절전 모드로 mapBy를 설명할 수 있는 사람?

JPA와 최대 절전 모드로 mapBy를 설명할 수 있는 사람?

나는 동면하는 것이 처음이어서 일대다와 다대일 관계를 사용해야 한다.이것은 내 객체에서 양방향 관계이기 때문에 어느 방향에서든 이동할 수 있습니다. mappedBy추천할 만한 방법인데 이해할 수 없었어요.가가 설명 ?? ???

• 그것을 사용하는 권장 방법은 무엇입니까?
• 그것은 어떤 목적을 해결합니까?

이 예시를 위해 주석이 있는 클래스는 다음과 같습니다.

• Airline 다수의 소유 AirlineFlights
• ★★★★ AirlineFlightsONE의 소유이다 Airline

항공사:

@Entity 
@Table(name="Airline")
public class Airline {
    private Integer idAirline;
    private String name;

    private String code;

    private String aliasName;
    private Set<AirlineFlight> airlineFlights = new HashSet<AirlineFlight>(0);

    public Airline(){}

    public Airline(String name, String code, String aliasName, Set<AirlineFlight> flights) {
        setName(name);
        setCode(code);
        setAliasName(aliasName);
        setAirlineFlights(flights);
    }

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="IDAIRLINE", nullable=false)
    public Integer getIdAirline() {
        return idAirline;
    }

    private void setIdAirline(Integer idAirline) {
        this.idAirline = idAirline;
    }

    @Column(name="NAME", nullable=false)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = DAOUtil.convertToDBString(name);
    }

    @Column(name="CODE", nullable=false, length=3)
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = DAOUtil.convertToDBString(code);
    }

    @Column(name="ALIAS", nullable=true)
    public String getAliasName() {
        return aliasName;
    }
    public void setAliasName(String aliasName) {
        if(aliasName != null)
            this.aliasName = DAOUtil.convertToDBString(aliasName);
    }

    @OneToMany(fetch=FetchType.LAZY, cascade = {CascadeType.ALL})
    @JoinColumn(name="IDAIRLINE")
    public Set<AirlineFlight> getAirlineFlights() {
        return airlineFlights;
    }

    public void setAirlineFlights(Set<AirlineFlight> flights) {
        this.airlineFlights = flights;
    }
}

항공사 항공편:

@Entity
@Table(name="AirlineFlight")
public class AirlineFlight {
    private Integer idAirlineFlight;
    private Airline airline;
    private String flightNumber;

    public AirlineFlight(){}

    public AirlineFlight(Airline airline, String flightNumber) {
        setAirline(airline);
        setFlightNumber(flightNumber);
    }

    @Id
    @GeneratedValue(generator="identity")
    @GenericGenerator(name="identity", strategy="identity")
    @Column(name="IDAIRLINEFLIGHT", nullable=false)
    public Integer getIdAirlineFlight() {
        return idAirlineFlight;
    }
    private void setIdAirlineFlight(Integer idAirlineFlight) {
        this.idAirlineFlight = idAirlineFlight;
    }

    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="IDAIRLINE", nullable=false)
    public Airline getAirline() {
        return airline;
    }
    public void setAirline(Airline airline) {
        this.airline = airline;
    }

    @Column(name="FLIGHTNUMBER", nullable=false)
    public String getFlightNumber() {
        return flightNumber;
    }
    public void setFlightNumber(String flightNumber) {
        this.flightNumber = DAOUtil.convertToDBString(flightNumber);
    }
}

편집:

데이터베이스 스키마:

Airline Flights는 ForeignKey로 idAirline을 가지며 항공사에는 idAirlineFlights가 없습니다.그러면 Airline Flights가 소유자/식별 기관으로 지정됩니까?

이론적으로 항공사가 항공사의 소유주가 되었으면 합니다.

MappedBy는 관계의 키가 다른 쪽에 있음을 최대 절전 모드로 시그널링합니다.

즉, 2개의 테이블을 링크해도 이들 테이블 중1개만 다른 테이블에 대한 외부 키 제약이 있습니다.MappedBy를 사용하면 제약조건을 포함하지 않는 테이블에서 다른 테이블로 계속 링크할 수 있습니다.

「」를 .@JoinColumn두 모델 모두 쌍방향 관계가 없습니다.두 가지 단방향 관계가 있습니다.그것은 매우 혼란스러운 매핑입니다.IDAIRLINE의 "IdAIRLINE"입니다.!!!!!!! !!! 。은 '보통'을 예요.@JoinColumn the off @OneToMany mappedBy 옆에 합니다.@OneToMany.

@OneToMany(cascade = CascadeType.ALL, mappedBy="airline")
public Set<AirlineFlight> getAirlineFlights() {
    return airlineFlights;
}

이는 Hibernate에게 "내 컬렉션이 있는 'airline'이라는 이름의 콩 속성을 검토하여 구성을 찾으십시오."라고 말합니다.

테이블 관계 대 엔티티 관계

'''는one-to-many테이블 관계는 다음과 같습니다.

는 []컬럼 [Foreign Key])에.★★★★★★★★★★★★★★★★★★★post_id를 참조해 주세요를 참조해 주세요.

.one-to-many테이블 관계

「」에 되고 엔티티 , 「」는 「2」입니다.one-to-many"CHANGE: "CHANGE: " 。

위의 그림을 보면 이 관계를 관리하는 방법은 두 가지가 있음을 알 수 있습니다.

서서 Post엔티티, 「」가 .comments★★★★

@OneToMany(
    mappedBy = "post",
    cascade = CascadeType.ALL,
    orphanRemoval = true
)
private List<PostComment> comments = new ArrayList<>();

★★★★★★★★★★★★★★★★★★.PostComment , . . . . . . . .post어소시에이션은 다음과 같이 매핑됩니다.

@ManyToOne(
    fetch = FetchType.LAZY
)
@JoinColumn(name = "post_id")
private Post post;

[외부 키(Foreign Key)]컬럼을 표시하는 방법에는 2가지가 있기 때문에 어소시에이션스테이트 변경을 동등한 [외부 키(Foreign Key)]컬럼 값 변경으로 변환할 때 어느 것이 진실의 소스인지 정의해야 합니다.

매핑 기준

mappedBy는 Atribute가 ""를 .@ManyToOneside는 Foreign Key 컬럼 관리를 담당하며 컬렉션은 하위 엔티티를 가져오고 상위 엔티티 상태 변경을 하위 엔티티에 계단식으로 전달하는 데만 사용됩니다(예를 들어, 상위 엔티티를 제거하면 하위 엔티티도 제거됩니다).

쌍방향 어소시에이션의 양쪽을 동기화합니다.

', ', '를 mappedBy 및 아트리뷰트 " " "@ManyToOne은 [컬럼을 어소시에이션의 .([Foreign Key])럼을 관리하지만 쌍방향 어소시에이션의 양쪽을 동기화할 필요가 있습니다.

가장 좋은 방법은 다음 두 가지 유틸리티 방법을 추가하는 것입니다.

public void addComment(PostComment comment) {
    comments.add(comment);
    comment.setPost(this);
}

public void removeComment(PostComment comment) {
    comments.remove(comment);
    comment.setPost(null);
}

addComment ★★★★★★★★★★★★★★★★★」removeComment메서드는 양쪽이 동기화됨을 보증합니다.따라서 하위 엔티티를 추가할 경우 하위 엔티티는 상위 엔티티를 가리키고 상위 엔티티는 하위 컬렉션에 하위 엔티티를 포함해야 합니다.

mappedby [field"]에 이미 밭[이름="field"]으로 하다
엔티티에 .(name of the variable in the class not the table in the database)

그렇게 하지 않으면 hibernate는 동일한 관계가 아니기 때문에 이 두 관계를 매핑합니다.

그래서 우리는 동면기에 한쪽에서만 지도를 만들고 그들 사이를 조정하라고 말해야 합니다.

mappby="다른 클래스에 생성된 동일한 클래스의 엔티티 개체"

주의:-매핑된 기준 테이블은 외부 키 제약 조건을 포함해야 하므로 하나의 클래스에서만 사용할 수 있습니다.에 의해 매핑된 기준 테이블이 양쪽에 적용될 수 있는 경우 양쪽 테이블에서 외부 키가 삭제되고 외부 키가 없으면 두 테이블은 관계가 없습니다.

참고:- 주석:- 1에 사용할 수 있습니다.@OneTone 2.@One To Many 3.@ManyToMany

주--- 주석:- 1에는 사용할 수 없습니다.@ManyToOne

In one to one :- 매핑의 임의의 측면에서 수행하지만 한쪽에서만 수행합니다.적용된 테이블에서 외부 키 제약 조건의 추가 열이 제거됩니다.

예: Employee 클래스의 mapped by를 직원 객체에 적용하면 Employee 테이블의 외부 키가 제거됩니다.

mappedBy Atribut은 쌍방향 어소시에이션의 특성을 나타내며 부모측에서 설정해야 합니다.즉, 양방향 @OneToMany 어소시에이션의 경우 부모측에서 mappedBy를 @OneToMany로 설정하고 mappedBy에서 참조하는 자녀측에서 @ManyToOne을 추가합니다.mappedBy를 통해 양방향 @OneToMany 어소시에이션은 @ManyToMany의 자녀측 매핑을 미러링합니다.

ManyToOne 매핑에서 시작하여 양방향 방식으로 OneToOne 매핑도 넣었습니다.그런 다음 OneToMany 측(일반적으로 상위 테이블/클래스)에서 "mappedBy"를 언급해야 합니다(하위 테이블/클래스에서 수행되며 하위 테이블/클래스에서 수행됨). 따라서 휴지 상태에서는 DB에 EXTRA 매핑 테이블이 생성되지 않습니다(예: TableName = parent_child).

언급URL : https://stackoverflow.com/questions/9108224/can-someone-explain-mappedby-in-jpa-and-hibernate