Может кто-нибудь объяснить mappedBy в JPA и Hibernate?

Я новичок в спящем состоянии, и мне нужно использовать отношения один-ко-многим и многие-к-одному. Это двунаправленные отношения в моих объектах, так что я могу перемещаться в любом направлении. mappedByэто рекомендуемый способ, но я не мог этого понять. Может кто-нибудь объяснить:

• Каков рекомендуемый способ его использования?
• с какой целью это решает?

Ради моего примера, вот мои занятия с аннотациями:

• Airline СВОИХ МНОГО AirlineFlights
• Многие AirlineFlights принадлежат ОДНОМУ 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;
    }
}

AirlineFlights:

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

РЕДАКТИРОВАТЬ:

Схема базы данных:

У AirlineFlights есть idAirline как ForeignKey, а у Airline нет idAirlineFlights. Это делает AirlineFlights в качестве владельца / идентифицирующего лица?

Теоретически, я бы хотел, чтобы авиакомпания стала владельцем авиакомпании.

Указывая @JoinColumnна обе модели, вы не имеете двусторонних отношений. У вас есть два односторонних отношения и очень запутанное отображение этого. Вы говорите обеим моделям, что они "владеют" столбцом IDAIRLINE. На самом деле только один из них на самом деле должен! «Обычная» вещь состоит в том, @JoinColumnчтобы @OneToManyполностью убрать боковую сторону и вместо этого добавить mappedBy в @OneToMany.

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

Это говорит Hibernate: «Иди, посмотри на свойство bean, называемое« авиакомпания », на предмет, который у меня есть, чтобы найти конфигурацию».

MappedBy сигнализирует, что ключ для отношений находится на другой стороне.

Это означает, что, хотя вы связываете 2 таблицы вместе, только одна из этих таблиц имеет ограничение внешнего ключа для другой. MappedBy позволяет вам по-прежнему ссылаться из таблицы, не содержащей ограничения, на другую таблицу.

mappedbyговорит сам за себя, говорит hibernate не отображать это поле. это уже отображено этим полем [name = "field"].
поле находится в другом объекте (name of the variable in the class not the table in the database)..

Если вы этого не сделаете, Hibernate отобразит эти два отношения, поскольку это не то же самое отношение

поэтому мы должны сказать hibernate сделать отображение только в одну сторону и координировать их.

mappedby = «объект сущности того же класса, созданный в другом классе»

Примечание: -Карта может использоваться только в одном классе, потому что одна таблица должна содержать ограничение внешнего ключа. если сопоставление может быть применено к обеим сторонам, тогда он удаляет внешний ключ из обеих таблиц, и без внешнего ключа нет никакой связи между двумя таблицами.

Примечание: - его можно использовать для следующих аннотаций: - 1. @ OneTone 2. @ OneToMany 3. @ ManyToMany

Примечание --- Его нельзя использовать для следующей аннотации: - 1. @ ManyToOne

Один в один: - Выполните на любой стороне сопоставления, но выполните только на одной стороне. Это удалит дополнительный столбец ограничения внешнего ключа в таблице, к которому класс применяется.

Например, Если мы применим отображение в классе Employee к объекту employee, внешний ключ из таблицы Employee будет удален.

Отношение таблицы против отношения сущности

В системе реляционных баз данных связь между one-to-manyтаблицами выглядит следующим образом:

Обратите внимание, что связь основана на столбце внешнего ключа (например, post_id) в дочерней таблице.

Таким образом, существует единый источник правды, когда речь идет об управлении one-to-manyотношениями за столом.

Теперь, если вы берете двунаправленное отношение сущности, которое отображается в one-to-manyотношении таблицы, которое мы видели ранее:

Если вы посмотрите на диаграмму выше, вы увидите, что есть два способа управления этими отношениями.

В 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;

Поскольку существует два способа представления столбца «Внешний ключ», необходимо определить источник истины, когда дело доходит до перевода изменения состояния ассоциации в эквивалентную модификацию значения столбца «Внешний ключ».

MappedBy

mappedByАтрибут говорит о том , что @ManyToOneсторона отвечает за управление столбцом внешнего ключа, а коллекция используется только для извлечения дочерних объектов и каскадных родительской сущность изменений состояния детей (например, удаление родителя должен также удалить дочерние объекты).

Синхронизировать обе стороны двунаправленной ассоциации

Теперь, даже если вы определили mappedByатрибут и дочерняя сторона @ManyToOneуправляет столбцом внешнего ключа, вам все равно нужно синхронизировать обе стороны двунаправленной ассоциации.

Лучший способ сделать это - добавить эти два служебных метода:

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

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

addCommentИ removeCommentметоды обеспечения того , чтобы обе стороны синхронизированы. Таким образом, если мы добавляем дочернюю сущность, дочерняя сущность должна указывать на родителя, а родительская сущность должна иметь дочерний объект, содержащийся в дочерней коллекции.

Для получения дополнительной информации о наилучшем способе синхронизации всех типов двунаправленных ассоциаций сущностей ознакомьтесь с этой статьей .

Вы начали с сопоставления ManyToOne, а затем добавили сопоставление OneToMany для двунаправленного способа. Затем на стороне OneToMany (обычно это ваша родительская таблица / класс), вы должны упомянуть «mappedBy» (отображение выполняется и в дочерней таблице / классе), поэтому hibernate не будет создавать таблицу отображения EXTRA в БД (как TableName = parent_child).