Ruhezustand Verbinden Sie zwei nicht miteinander verknüpfte Tabellen, wenn beide über den zusammengesetzten Primärschlüssel verfügen

Ändern Sie die Beziehung von @OneToOne in @OneToMany und verwenden Sie fetch anstelle von join. Es wird nur eine Abfrage ausgeführt, und hoffentlich funktioniert es.

 Join<Transaction, ResponseCode> join =
        (Join<Transaction,ResponseCode>)transaction.fetch("rc",JoinType.LEFT);

und Sie können es auch mit @OneToOne versuchen.

Sie müssen Ihre Zuordnung ändern. rcCode kann kein Bezeichner sein, da Datensätze nicht eindeutig identifiziert werden. Ich denke, das bringt viele Probleme mit sich. ResponseCode muss einen anderen Bezeichner haben.

@OneToOne bedeutet eins zu eins. Sie haben eine Transaktion, einen Antwortcode, aber viele Sprachen.

Sie können eine Verbindung zwischen einer Transaction und einer ResponseCodemit einer bestimmten Sprache zuordnen (@OneToOne) (über einen composite key ).

Sie können @OneToMany verwenden, aber in diesem Fall sollte der Verweis von der ResponseCode-Tabelle auf die Transaction-Tabelle verweisen.

Möglicherweise benötigen Sie jedoch 3 Tabellen: Transaktionen, Antwortcodes (mit dem Code selbst und seinen allgemeinen Informationen), Antwortcode-Lokalisierungen (mit Nachrichten in verschiedenen Sprachen). Transaktionen Eins-zu-Eins-Antwortkodes, Antwortkodes Eins-zu-Viele-RC-Lokalisierungen.

Oder Sie benötigen möglicherweise keine Hibernate-Beziehung zwischen Transaction und ResponseCode.

public class Transaction implements Java.io.Serializable {
...
    @Column(name="rc")
    private String rc;
...
}

Sie können die erforderliche ResponseCode nach Code und Sprache auswählen. Zwei Auswahlmöglichkeiten: 1 - Wählen Sie Transaction (mit String RC-Code); 2 - Wählen Sie ResponseCode (mit der erforderlichen Sprache) per RC-Code aus Transaction.

Ihre Zuordnung beider Entitäten ist falsch. 

Beginnen wir mit der Entität ResponseCode. Ihr Tabellenmodell zeigt einen zusammengesetzten Primärschlüssel, der aus den Spalten RcCode und Lang besteht. Ihre Entitätszuordnung deklariert jedoch nur das Attribut rcCode als Primärschlüssel. Sie müssen dem rcLang-Attribut der ResponseCode-Entität eine zusätzliche @Id-Anmerkung hinzufügen.

Dies sollte die feste Zuordnung der ResponseCode-Entität sein:

@Entity
@Table(name = "response_codes")
public class ResponseCode implements Java.io.Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "response_code")
    private String rcCode;

    @Column(name = "rc_status")
    private String rcStatus;

    @Column(name = "rc_description")
    private String rcDesc;

    @Id
    @Column(name = "rc_lang")
    private String rcLang;

    // Contructors and getters/setters
}

Nach dem Festlegen des Primärschlüssels Ihrer ReponseCode-Entität müssen Sie beide Attribute/Spalten in der Zuordnungszuordnung Ihrer Transaction-Entität referenzieren. Mit Hibernate 5.2 können Sie dies mit zwei @JoinColumn-Anmerkungen von Hibernate machen. Ältere Hibernate-Versionen und der JPA-Standard in Version 2.1 müssen diese Annotationen in eine zusätzliche @JoinColumns-Annotation einschließen.

Hier ist die feste Zuordnung Ihrer Transaction-Entität:

@Entity
@Table(name = "transactions")
public class Transaction implements Java.io.Serializable {
    private static final long serialVersionUID = 1L;

    @Column(name = "merchant_id", nullable = true)
    private String merchantID;

    @Column(name = "tran_amount", nullable = true)
    private String tranAmount;

    @Id
    @Column(name = "tran_type", nullable = true)
    private String tranType;

    @Column(name = "auth_request_date", nullable = true)
    @Temporal(TemporalType.TIMESTAMP)
    private Date authRequestDate;

    @Id
    @Column(name = "tran_id", nullable = true)
    private String tranID;

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name="rc_id", referencedColumnName = "id")
    @JoinColumn(name="rc_lang", referencedColumnName = "lang")
    private ResponseCode rc;

    // Contructos and getters/setters

Sie haben eine einzelne ResponseCode-Entität in Transaction zugeordnet, die falsch ist. Der Antwortcode ist nicht ein PK. Er identifiziert eine ResponseCode-Entität für eine bestimmte Transaktionsentität nicht eindeutig. Z.B. Für eine Transaktion mit dem Antwortcode 000 gibt es 2 ResponseCode-Entitäten (mit 'en' und 'ge' langs).

Ich empfehle Ihnen stattdessen, eine Sammlung abzubilden. 

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name="rc")
private List<ResponseCode> rcList;

Da Ihre Abfrage WHERE-Bedingungen nur für die Transaktion gelten, können Sie die Transaktionsentitäten einfach abfragen. Im Hibernate-Cache werden eventuell erforderliche Unterabfragen für jeden Antwortcode optimiert (eine Abfrage nach '000', eine nach '116' usw.).