ObjectDB中Employee与Address关联生成emp_add中间表技术咨询

Hey there, let's figure out why your emp_add join table isn't being generated and fix it up. The most common issues here are incomplete or incorrect JPA annotations on your entities, so let's walk through each part step by step.

1. Verify Primary Key Annotations #

First, make sure your empid and addid fields are properly annotated with @Id—ObjectDB requires explicit primary key definitions for entities. Without these, the ORM might not recognize your classes as valid entities, which could prevent join table creation entirely.

2. Fix the @JoinTable Configuration on the Owning Side #

In your Employee class (the owning side of the many-to-many relationship, since it's where you define @JoinTable), you need to explicitly specify the join table name and the columns that link to each entity. Here's the corrected snippet:

@Entity
public class Employee {
    @Id // Don't forget this critical annotation!
    private int empid;
    private String empname;

    @ManyToMany(cascade = CascadeType.ALL) // Add cascade if you want operations to propagate to linked entities
    @JoinTable(
        name = "emp_add", // This explicitly names your desired join table
        joinColumns = @JoinColumn(name = "emp_id"), // Column linking to Employee's primary key
        inverseJoinColumns = @JoinColumn(name = "add_id") // Column linking to Address's primary key
    )
    private Set<Address> address = new HashSet<>(); // Initialize the set to avoid null issues

    // Constructor, getters and setters
    public Employee(int empid, String empname) {
        this.empid = empid;
        this.empname = empname;
    }

    // Getters and setters for all fields...
}

3. Correct the Inverse Side Association #

Your Address class's @ManyToMany annotation needs to correctly reference the owning side's association field (address in Employee). Also, ensure the primary key is properly annotated:

@Entity
public class Address {
    @Id // Required for ObjectDB to recognize this as an entity
    private int addid;
    private String city;
    private String houseno;

    @ManyToMany(mappedBy = "address") // "address" must match the field name in Employee
    private Set<Employee> employee = new HashSet<>(); // Initialize the set

    // Constructor, getters and setters
    public Address(int addid, String city, String houseno) {
        this.addid = addid;
        this.city = city;
        this.houseno = houseno;
    }

    // Getters and setters for all fields...
}

4. Maintain Bidirectional Association (Optional but Recommended) #

When persisting entities, it's good practice to maintain both sides of the relationship to keep your data consistent. In your main method, do something like this:

public class EmployyAdd {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("objectdb:my-db.odb");
        EntityManager em = emf.createEntityManager();

        em.getTransaction().begin();

        // Create entities
        Employee emp = new Employee(1, "John Doe");
        Address add = new Address(101, "New York", "123 Main St");

        // Link both sides of the relationship
        emp.getAddress().add(add);
        add.getEmployee().add(emp);

        // Persist (only need to persist the owning side if cascade is set, but persisting both works too)
        em.persist(emp);

        em.getTransaction().commit();
        em.close();
        emf.close();
    }
}

5. Confirm ObjectDB Persistence Configuration #

Double-check your persistence.xml (usually in src/main/resources/META-INF) to ensure it includes your entities and uses valid settings. ObjectDB automatically creates tables if they don't exist by default, but a basic configuration might look like:

<persistence-unit name="objectdb:my-db.odb" transaction-type="RESOURCE_LOCAL">
    <class>com.yourpackage.Employee</class>
    <class>com.yourpackage.Address</class>
    <properties>
        <property name="javax.persistence.jdbc.user" value="admin"/>
        <property name="javax.persistence.jdbc.password" value="admin"/>
    </properties>
</persistence-unit>

Final Notes #

• Always initialize your collection fields (like Set<Address> address = new HashSet<>()) to avoid NullPointerException when adding entities.
• Adjust the cascade type in @ManyToMany based on your needs—CascadeType.ALL ensures that persist/remove operations propagate to linked entities, but you can use more granular options if needed.

After making these changes, rerun your code—ObjectDB should now generate the emp_add join table with columns emp_id and add_id linking to your Employee and Address entities respectively.

内容的提问来源于stack exchange，提问作者Bimal Kumar Dalei