主键 外键

在关系型数据库中，主键（Primary Key）和外键（Foreign Key）是用于维护数据完整性和建立表之间关系的重要概念。

主键（Primary Key）

• 定义: 主键是一个或多个列的组合，其值能够唯一标识表中的每一行。
• 特性:
  • 唯一性: 主键的值必须是唯一的，不能重复。
  • 非空性: 主键列不能包含 NULL 值。
  • 单一性: 每个表只能有一个主键。
• 用途: 主键用于确保每一行数据的唯一性，并作为其他表引用的基础。

示例

假设有一个 users 表：

CREATE TABLE users (
    user_id INT PRIMARY KEY,
    username VARCHAR(50),
    email VARCHAR(100)
);

在这个例子中，user_id 是主键，它唯一标识每个用户。

外键（Foreign Key）

• 定义: 外键是一个或多个列的组合，其值引用另一个表中的主键。
• 特性:
  • 引用完整性: 外键值必须在被引用的表中存在（或为 NULL）。
  • 多对一关系: 外键通常用于建立表之间的多对一关系。
• 用途: 外键用于维护表之间的关系和引用完整性。

示例

假设有一个 orders 表，其中 user_id 是外键，引用 users 表的主键：

CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    order_date DATE,
    user_id INT,
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);

在这个例子中，user_id 是外键，它引用 users 表中的 user_id 主键。这确保了每个订单都与一个有效的用户相关联。

主键和外键的关系

• 主键: 定义在一个表中，用于唯一标识该表中的记录。
• 外键: 定义在一个表中，用于引用另一个表的主键，从而建立两个表之间的关系。

维护数据完整性

• 级联操作: 可以设置外键约束的级联操作，如 ON DELETE CASCADE，以便在删除或更新主表记录时自动更新或删除相关的外键记录。
• 约束检查: 数据库在插入或更新数据时会检查外键约束，以确保引用完整性。

通过使用主键和外键，你可以确保数据库中的数据完整性，并建立表之间的关系，从而更好地组织和管理数据。

主键 外键 mybatis

在使用 MyBatis 进行数据库操作时，主键和外键的概念依然适用，因为它们是数据库层面的约束和关系。MyBatis 是一个持久层框架，它通过 XML 或注解的方式将 SQL 语句与 Java 对象进行映射。以下是如何在 MyBatis 中处理主键和外键的基本方法：

主键处理

1. 自动生成主键

   在数据库中，主键通常是自动生成的（例如，自增 ID）。在 MyBatis 中，可以使用 useGeneratedKeys 和 keyProperty 来获取自动生成的主键值。

   <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="userId">
       INSERT INTO users (username, email) VALUES (#{username}, #{email})
   </insert>
   

   • useGeneratedKeys="true": 告诉 MyBatis 使用数据库生成的主键。
   • keyProperty="userId": 指定实体类中用于存储生成主键的属性。

2. 手动设置主键

   如果主键不是自动生成的，你需要在插入数据时手动设置主键值。

   <insert id="insertUser" parameterType="User">
       INSERT INTO users (user_id, username, email) VALUES (#{userId}, #{username}, #{email})
   </insert>
   

外键处理

外键关系通常在数据库设计时定义。在 MyBatis 中，处理外键关系主要涉及到如何查询和映射相关联的数据。

1. 一对多关系

   假设一个用户可以有多个订单，你可以在 MyBatis 中定义一个查询来获取用户及其订单列表。

   <select id="selectUserWithOrders" resultMap="UserOrderMap">
       SELECT u.user_id, u.username, o.order_id, o.order_date
       FROM users u
       LEFT JOIN orders o ON u.user_id = o.user_id
       WHERE u.user_id = #{userId}
   </select>
   
   <resultMap id="UserOrderMap" type="User">
       <id property="userId" column="user_id"/>
       <result property="username" column="username"/>
       <collection property="orders" ofType="Order">
           <id property="orderId" column="order_id"/>
           <result property="orderDate" column="order_date"/>
       </collection>
   </resultMap>
   

   • resultMap: 定义如何将查询结果映射到 Java 对象。
   • collection: 用于映射一对多关系，将多个订单映射到一个用户对象的 orders 属性。

2. 多对一关系

   如果一个订单属于一个用户，你可以在订单查询中包含用户信息。

   <select id="selectOrderWithUser" resultMap="OrderUserMap">
       SELECT o.order_id, o.order_date, u.user_id, u.username
       FROM orders o
       JOIN users u ON o.user_id = u.user_id
       WHERE o.order_id = #{orderId}
   </select>
   
   <resultMap id="OrderUserMap" type="Order">
       <id property="orderId" column="order_id"/>
       <result property="orderDate" column="order_date"/>
       <association property="user" javaType="User">
           <id property="userId" column="user_id"/>
           <result property="username" column="username"/>
       </association>
   </resultMap>
   

   • association: 用于映射多对一关系，将用户信息映射到订单对象的 user 属性。

总结

• 主键: 在 MyBatis 中，可以通过 useGeneratedKeys 和 keyProperty 来处理自动生成的主键。
• 外键: 通过 resultMap、collection 和 association 来处理表之间的关系和数据映射。

通过这些配置，你可以在 MyBatis 中有效地处理主键和外键关系，确保数据的完整性和一致性。

主键 外键 hibernate

在 Hibernate 中，主键和外键的概念同样适用，因为它们是关系型数据库的基本组成部分。Hibernate 是一个对象关系映射（ORM）框架，它将 Java 对象映射到数据库表中。以下是如何在 Hibernate 中处理主键和外键的基本方法：

主键处理

1. 简单主键

   在 Hibernate 中，简单主键通常使用 @Id 注解来标识。可以结合 @GeneratedValue 注解来自动生成主键值。

   import javax.persistence.Entity;
   import javax.persistence.GeneratedValue;
   import javax.persistence.GenerationType;
   import javax.persistence.Id;
   
   @Entity
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long userId;
   
       private String username;
       private String email;
   
       // Getters and setters
   }
   

   • @Id: 标识主键字段。
   • @GeneratedValue: 指定主键生成策略。GenerationType.IDENTITY 通常用于自增主键。

2. 复合主键

   对于复合主键，可以使用 @EmbeddedId 或 @IdClass 注解。

   import javax.persistence.Embeddable;
   import java.io.Serializable;
   
   @Embeddable
   public class OrderId implements Serializable {
       private Long orderId;
       private Long userId;
   
       // Getters, setters, equals, and hashCode
   }
   
   import javax.persistence.EmbeddedId;
   import javax.persistence.Entity;
   
   @Entity
   public class Order {
       @EmbeddedId
       private OrderId id;
   
       private String orderDate;
   
       // Getters and setters
   }
   

   • @Embeddable: 用于定义复合主键类。
   • @EmbeddedId: 用于在实体中嵌入复合主键。

外键处理

外键用于定义实体之间的关系。在 Hibernate 中，使用 @ManyToOne, @OneToMany, @OneToOne, 和 @ManyToMany 注解来定义这些关系。

1. 多对一关系

   在订单和用户之间的多对一关系中，订单表中的 userId 是外键。

   import javax.persistence.Entity;
   import javax.persistence.GeneratedValue;
   import javax.persistence.GenerationType;
   import javax.persistence.Id;
   import javax.persistence.ManyToOne;
   
   @Entity
   public class Order {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long orderId;
   
       private String orderDate;
   
       @ManyToOne
       private User user;
   
       // Getters and setters
   }
   

   • @ManyToOne: 定义多对一关系，通常在外键字段上使用。

2. 一对多关系

   在用户和订单之间的一对多关系中，用户表中的 userId 是主键，订单表中的 userId 是外键。

   import javax.persistence.Entity;
   import javax.persistence.GeneratedValue;
   import javax.persistence.GenerationType;
   import javax.persistence.Id;
   import javax.persistence.OneToMany;
   import java.util.List;
   
   @Entity
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long userId;
   
       private String username;
       private String email;
   
       @OneToMany(mappedBy = "user")
       private List<Order> orders;
   
       // Getters and setters
   }
   

   • @OneToMany: 定义一对多关系，mappedBy 属性指定关系的拥有方。

3. 一对一关系

   使用 @OneToOne 注解来定义一对一关系。

   import javax.persistence.Entity;
   import javax.persistence.GeneratedValue;
   import javax.persistence.GenerationType;
   import javax.persistence.Id;
   import javax.persistence.OneToOne;
   
   @Entity
   public class UserProfile {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long profileId;
   
       private String address;
   
       @OneToOne
       private User user;
   
       // Getters and setters
   }
   

   • @OneToOne: 定义一对一关系。

总结

• 主键: 使用 @Id 和 @GeneratedValue 来定义和生成主键。
• 外键: 使用关系注解（如 @ManyToOne, @OneToMany）来定义实体之间的关系。

通过这些注解和配置，你可以在 Hibernate 中有效地处理主键和外键关系，确保数据的完整性和一致性。

主键 外键 mybatis plus

MyBatis-Plus 是 MyBatis 的增强版，提供了许多便捷的功能来简化开发过程。在 MyBatis-Plus 中，主键和外键的处理与 MyBatis 类似，但它提供了一些额外的工具和注解来简化这些操作。

主键处理

1. 自动生成主键

   MyBatis-Plus 支持自动生成主键，通常通过数据库的自增字段实现。你可以使用 @TableId 注解来指定主键字段，并设置主键生成策略。

   import com.baomidou.mybatisplus.annotation.IdType;
   import com.baomidou.mybatisplus.annotation.TableId;
   import com.baomidou.mybatisplus.annotation.TableName;
   
   @TableName("users")
   public class User {
       @TableId(value = "user_id", type = IdType.AUTO)
       private Long userId;
   
       private String username;
       private String email;
   
       // Getters and setters
   }
   

   • @TableId: 用于标识主键字段。
   • IdType.AUTO: 指定主键生成策略为自增。

2. 手动设置主键

   如果主键不是自动生成的，你可以在插入数据时手动设置主键值。

   @TableId(value = "user_id", type = IdType.INPUT)
   private Long userId;
   

   • IdType.INPUT: 指定主键由用户输入。

外键处理

外键关系通常在数据库设计时定义。在 MyBatis-Plus 中，处理外键关系主要涉及到如何查询和映射相关联的数据。MyBatis-Plus 本身不直接处理外键关系，但你可以通过编写 SQL 查询和使用关联查询来实现。

1. 一对多关系

   假设一个用户可以有多个订单，你可以在 MyBatis-Plus 中定义一个查询来获取用户及其订单列表。

   @TableName("orders")
   public class Order {
       @TableId(value = "order_id", type = IdType.AUTO)
       private Long orderId;
   
       private String orderDate;
       private Long userId;
   
       // Getters and setters
   }
   

   你可以使用自定义 SQL 查询来获取用户及其订单：

   @Select("SELECT u.user_id, u.username, o.order_id, o.order_date FROM users u LEFT JOIN orders o ON u.user_id = o.user_id WHERE u.user_id = #{userId}")
   List<UserWithOrders> selectUserWithOrders(@Param("userId") Long userId);
   

2. 多对一关系

   如果一个订单属于一个用户，你可以在订单查询中包含用户信息。

   @Select("SELECT o.order_id, o.order_date, u.user_id, u.username FROM orders o JOIN users u ON o.user_id = u.user_id WHERE o.order_id = #{orderId}")
   OrderWithUser selectOrderWithUser(@Param("orderId") Long orderId);
   

总结

• 主键: 使用 @TableId 注解来定义主键字段，并指定主键生成策略。
• 外键: 通过自定义 SQL 查询和关联查询来处理表之间的关系。

MyBatis-Plus 提供了许多便捷的功能来简化数据库操作，但对于复杂的外键关系，仍然需要通过 SQL 查询来实现。通过这些配置和查询，你可以在 MyBatis-Plus 中有效地处理主键和外键关系，确保数据的完整性和一致性。