余亦真情感专家 發表於 2025-7-18 10:00:00

springboot~关系数据库索引和外键

<h1 id="外键">外键</h1>
<ul>
<li>同时更新，现时删除</li>
<li>约束更新，约束删除</li>
</ul>
<h1 id="索引">索引</h1>
<ul>
<li>优化查询</li>
<li>添加外键后，自动为这个字段添加上索引</li>
</ul>
<p><img src="https://images.cnblogs.com/cnblogs_com/lori/2430318/o_250717091840_mysql_forign.png" alt="" loading="lazy"></p>
<h1 id="举例">举例</h1>
<ul>
<li>用户主表user_info</li>
<li>用户扩展信息user_extension</li>
<li>项目表    project_info</li>
</ul>
<p><img src="https://images.cnblogs.com/cnblogs_com/lori/2430318/o_250717092144_oneToMany.png" alt="" loading="lazy"></p>
<h1 id="理解表与表的关系">理解表与表的关系</h1>
<ul>
<li>一对一</li>
<li>一对多</li>
<li>多对一</li>
<li>多对多</li>
</ul>
<p>在关系数据库中，实体间的关联关系通过外键实现，JPA（Java Persistence API）提供了简洁的注解来映射这些关系。下面通过具体示例说明三种关系：</p>
<hr>
<h3 id="一一对一关系-one-to-one">一、一对一关系 (One-to-One)</h3>
<p><strong>场景</strong>：用户(User) 和 身份证(IDCard)，一个用户只能有一个身份证，一个身份证也只属于一个用户。</p>
<h4 id="数据库表结构">数据库表结构：</h4>
<pre><code class="language-sql">CREATE TABLE user (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE id_card (
    id BIGINT PRIMARY KEY,
    number VARCHAR(20),
    user_id BIGINT UNIQUE,-- 唯一约束保证一对一
    FOREIGN KEY (user_id) REFERENCES user(id)
);
</code></pre>
<h4 id="jpa-实体映射">JPA 实体映射：</h4>
<pre><code class="language-java">// 用户实体
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
   
    private String name;
   
    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private IDCard idCard;// 用户持有身份证对象
}

// 身份证实体
@Entity
public class IDCard {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
   
    private String number;
   
    @OneToOne
    @JoinColumn(name = "user_id")// 指定外键列
    private User user;// 身份证持有用户对象
}
</code></pre>
<p><strong>使用示例</strong>：</p>
<pre><code class="language-java">User user = new User("张三");
IDCard card = new IDCard("110101202301011234");
user.setIdCard(card);
card.setUser(user);

userRepository.save(user);// 级联保存身份证
</code></pre>
<hr>
<h3 id="二一对多关系-one-to-many">二、一对多关系 (One-to-Many)</h3>
<p><strong>场景</strong>：部门(Department) 和 员工(Employee)，一个部门有多个员工，一个员工只属于一个部门。</p>
<h4 id="数据库表结构-1">数据库表结构：</h4>
<pre><code class="language-sql">CREATE TABLE department (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE employee (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50),
    department_id BIGINT,-- 外键指向部门
    FOREIGN KEY (department_id) REFERENCES department(id)
);
</code></pre>
<h4 id="jpa-实体映射-1">JPA 实体映射：</h4>
<pre><code class="language-java">// 部门实体
@Entity
public class Department {
    @Id
    @GeneratedValue
    private Long id;
   
    private String name;
   
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List&lt;Employee&gt; employees = new ArrayList&lt;&gt;();// 部门持有员工集合
}

// 员工实体
@Entity
public class Employee {
    @Id
    @GeneratedValue
    private Long id;
   
    private String name;
   
    @ManyToOne
    @JoinColumn(name = "department_id")// 指定外键列
    private Department department;// 员工持有部门对象
}
</code></pre>
<p><strong>使用示例</strong>：</p>
<pre><code class="language-java">Department dept = new Department("研发部");
Employee emp1 = new Employee("张三");
Employee emp2 = new Employee("李四");

dept.getEmployees().add(emp1);
dept.getEmployees().add(emp2);
emp1.setDepartment(dept);
emp2.setDepartment(dept);

departmentRepository.save(dept);// 级联保存员工
</code></pre>
<hr>
<h3 id="三多对多关系-many-to-many">三、多对多关系 (Many-to-Many)</h3>
<p><strong>场景</strong>：学生(Student) 和 课程(Course)，一个学生可选修多门课程，一门课程也可被多个学生选修。</p>
<h4 id="数据库表结构-2">数据库表结构：</h4>
<pre><code class="language-sql">CREATE TABLE student (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE course (
    id BIGINT PRIMARY KEY,
    name VARCHAR(50)
);

-- 中间表
CREATE TABLE student_course (
    student_id BIGINT,
    course_id BIGINT,
    PRIMARY KEY (student_id, course_id),
    FOREIGN KEY (student_id) REFERENCES student(id),
    FOREIGN KEY (course_id) REFERENCES course(id)
);
</code></pre>
<h4 id="jpa-实体映射-2">JPA 实体映射：</h4>
<pre><code class="language-java">// 学生实体
@Entity
public class Student {
    @Id
    @GeneratedValue
    private Long id;
   
    private String name;
   
    @ManyToMany
    @JoinTable(
      name = "student_course",// 中间表名
      joinColumns = @JoinColumn(name = "student_id"),// 当前实体外键
      inverseJoinColumns = @JoinColumn(name = "course_id") // 对方实体外键
    )
    private Set&lt;Course&gt; courses = new HashSet&lt;&gt;();// 学生持有课程集合
}

// 课程实体
@Entity
public class Course {
    @Id
    @GeneratedValue
    private Long id;
   
    private String name;
   
    @ManyToMany(mappedBy = "courses")// 由Student端维护关系
    private Set&lt;Student&gt; students = new HashSet&lt;&gt;();// 课程持有学生集合
}
</code></pre>
<p><strong>使用示例</strong>：</p>
<pre><code class="language-java">Student s1 = new Student("小明");
Student s2 = new Student("小红");

Course math = new Course("数学");
Course english = new Course("英语");

s1.getCourses().add(math);
s1.getCourses().add(english);
s2.getCourses().add(math);

math.getStudents().add(s1);
math.getStudents().add(s2);
english.getStudents().add(s1);

studentRepository.save(s1);
studentRepository.save(s2);// 自动维护中间表
</code></pre>
<hr>
<h3 id="核心注解总结">核心注解总结：</h3>
<table>
<thead>
<tr>
<th>关系类型</th>
<th>主要注解</th>
<th>作用说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>一对一</td>
<td><code>@OneToOne</code></td>
<td>声明一对一关系，常用<code>mappedBy</code>指定关系维护方</td>
</tr>
<tr>
<td>一对多</td>
<td><code>@OneToMany</code></td>
<td>声明"一"方，通常与<code>@ManyToOne</code>配对使用</td>
</tr>
<tr>
<td>多对一</td>
<td><code>@ManyToOne</code></td>
<td>声明"多"方，需指定<code>@JoinColumn</code>定义外键</td>
</tr>
<tr>
<td>多对多</td>
<td><code>@ManyToMany</code></td>
<td>双方均可使用，需通过<code>@JoinTable</code>配置中间表</td>
</tr>
<tr>
<td>外键配置</td>
<td><code>@JoinColumn</code></td>
<td>指定外键列名（用于一对一、多对一）</td>
</tr>
<tr>
<td>中间表配置</td>
<td><code>@JoinTable</code></td>
<td>配置多对多关系的中间表（name/joinColumns/inverseJoinColumns）</td>
</tr>
<tr>
<td>级联操作</td>
<td><code>cascade</code></td>
<td>设置级联操作类型（如<code>CascadeType.PERSIST</code>保存时级联）</td>
</tr>
<tr>
<td>加载策略</td>
<td><code>fetch</code></td>
<td>设置加载策略（<code>FetchType.LAZY</code>懒加载，<code>FetchType.EAGER</code>立即加载）</td>
</tr>
</tbody>
</table>
<hr>
<h3 id="最佳实践建议">最佳实践建议：</h3>
<ol>
<li>
<p><strong>关系维护方</strong>：</p>
<ul>
<li>一对多/多对一中：<strong>多的一方维护关系</strong>（外键在多方表中）</li>
<li>多对多中：<strong>选择一方作为维护方</strong>（通过<code>@JoinTable</code>配置）</li>
</ul>
</li>
<li>
<p><strong>级联操作</strong>：</p>
<pre><code class="language-java">@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
</code></pre>
<ul>
<li><code>orphanRemoval=true</code> 自动删除不再关联的子实体</li>
</ul>
</li>
<li>
<p><strong>懒加载优化</strong>：</p>
<pre><code class="language-java">@ManyToOne(fetch = FetchType.LAZY)// 推荐默认使用懒加载
</code></pre>
</li>
<li>
<p><strong>双向关系同步</strong>：</p>
<pre><code class="language-java">// 添加辅助方法保持双向同步
public void addCourse(Course course) {
    courses.add(course);
    course.getStudents().add(this);
}
</code></pre>
</li>
<li>
<p><strong>避免循环引用</strong>：<br>
在JSON序列化时使用<code>@JsonIgnore</code>避免无限递归：</p>
<pre><code class="language-java">@ManyToOne
@JsonIgnore// 在返回JSON时忽略此属性
private Department department;
</code></pre>
</li>
</ol>
<p>通过合理使用JPA的关系映射，可以高效地处理数据库中的关联关系，同时保持代码的清晰性和可维护性。</p>
<h1 id="外键的利弊">外键的利弊</h1>
<p>在大型项目中使用外键约束是一个需要<strong>权衡利弊</strong>的问题，没有绝对的“好”或“坏”。最终决策取决于项目的<strong>具体需求、架构、性能要求和团队规范</strong>。</p>
<p>以下是关键利弊分析，帮助你做出判断：</p>
<h2 id="外键约束的主要优点">外键约束的主要优点</h2>
<ol>
<li>
<p><strong>数据完整性（核心价值）：</strong></p>
<ul>
<li><strong>强制引用完整性：</strong> 这是外键存在的根本原因。它能保证子表（如 <code>订单详情表</code>）中的外键值（如 <code>订单ID</code>）必须在父表（如 <code>订单表</code>）的主键（或唯一键）中存在对应的值。</li>
<li><strong>防止“孤儿”记录：</strong> 避免子表记录指向不存在的父表记录（例如，订单详情指向一个不存在的订单）。</li>
<li><strong>级联操作：</strong> 可以定义 <code>ON DELETE CASCADE</code> 或 <code>ON UPDATE CASCADE</code> 等规则，自动处理关联数据的删除或更新（如删除订单时自动删除其所有订单详情），简化应用逻辑并确保一致性。</li>
</ul>
</li>
<li>
<p><strong>清晰的数据关系：</strong></p>
<ul>
<li><strong>自文档化：</strong> 数据库模式本身清晰地表明了表之间的关系，方便开发者理解数据模型。ER图工具也能更好地利用这些约束。</li>
</ul>
</li>
<li>
<p><strong>简化应用逻辑：</strong></p>
<ul>
<li>数据库本身承担了维护关联一致性的工作，减少了应用层代码中需要编写的检查和维护逻辑。这可以降低开发复杂性并减少潜在错误。</li>
</ul>
</li>
<li>
<p><strong>优化器提示（有时）：</strong></p>
<ul>
<li>在某些情况下，查询优化器可以利用外键关系信息来优化连接查询的执行计划（例如，知道 <code>A JOIN B ON A.fk = B.pk</code> 中 <code>B.pk</code> 是唯一的，可以影响连接算法选择）。但这并非所有数据库都擅长利用，且效果可能不如预期。</li>
</ul>
</li>
</ol>
<h2 id="外键约束在大型项目中可能带来的挑战和缺点">外键约束在大型项目中可能带来的挑战和缺点</h2>
<ol>
<li>
<p><strong>性能开销（主要顾虑）：</strong></p>
<ul>
<li><strong>插入/更新/删除操作：</strong> 执行涉及外键的操作时，数据库需要检查约束（检查父表是否存在对应记录）。在高并发、高频写入的场景下，这会带来显著的性能开销和锁竞争。</li>
<li><strong>锁争用：</strong> 检查约束和级联操作通常需要锁定父表和子表的行（甚至表）。在大型、高并发的系统中，这可能成为严重的瓶颈，降低吞吐量和响应速度。</li>
<li><strong>死锁风险增加：</strong> 跨表操作的锁依赖关系更容易导致死锁。</li>
</ul>
</li>
<li>
<p><strong>数据库扩展性的限制：</strong></p>
<ul>
<li><strong>分库分表（Sharding）：</strong> 在分布式数据库架构中，如果数据被分片存储在不同的物理节点上，跨分片的外键约束通常<strong>无法实现</strong>或实现起来非常复杂且低效。大型项目常常需要水平扩展，这是外键的一个硬伤。</li>
<li><strong>读写分离：</strong> 在读写分离架构下，如果写主库后存在复制延迟，在从库上立即查询可能因为外键约束检查失败（新数据还未复制到从库）。</li>
</ul>
</li>
<li>
<p><strong>DDL 操作（模式变更）更复杂：</strong></p>
<ul>
<li><strong>添加/修改约束：</strong> 在已有大量数据的表上添加外键约束可能是一个耗时且需要锁表的操作（取决于数据库实现），影响线上服务。</li>
<li><strong>删除父表记录/修改主键：</strong> 如果存在子表引用，删除父表记录或修改父表主键需要格外小心，可能需要先处理子表数据或依赖级联规则。这增加了模式变更的复杂性和风险。</li>
</ul>
</li>
<li>
<p><strong>级联操作的潜在危险：</strong></p>
<ul>
<li><code>ON DELETE CASCADE</code> 虽然方便，但也可能导致<strong>意外的大范围数据删除</strong>。如果误删父表一条记录，可能连带删除大量关联的子表数据，造成严重事故。需要非常谨慎地设计和执行。</li>
</ul>
</li>
<li>
<p><strong>微服务架构的挑战：</strong></p>
<ul>
<li>在微服务架构下，数据所有权分散在不同的服务中。一个服务通常不应该直接操作另一个服务拥有的数据库表。跨服务边界的强外键约束通常<strong>不适用</strong>，甚至违背了微服务解耦的原则。服务间数据一致性需要通过 API 调用、事件驱动、最终一致性等模式来保证，而不是数据库级别的外键。</li>
</ul>
</li>
</ol>
<h2 id="大型项目中是否使用外键的建议策略">大型项目中是否使用外键的建议策略</h2>
<ol>
<li>
<p><strong>评估核心需求：</strong></p>
<ul>
<li><strong>数据一致性要求有多高？</strong> 金融、交易系统等对一致性要求极高的场景，外键的强制完整性价值更大。</li>
<li><strong>性能要求有多高？</strong> 超高并发、低延迟写入场景（如秒杀、高频交易）通常难以承受外键开销。</li>
<li><strong>架构是什么？</strong> 是否采用分库分表？是否是微服务？这些架构决策直接影响外键的可行性。</li>
</ul>
</li>
<li>
<p><strong>权衡利弊，选择性使用：</strong></p>
<ul>
<li><strong>核心、强关联、数据量可控的关系：</strong> 对于系统核心实体之间、数据量不是特别巨大、且关系非常紧密的表（如 <code>用户</code> 和 <code>用户配置</code>），可以考虑使用外键，利用其数据完整性保障。</li>
<li><strong>非核心、高并发、海量数据或分布式场景：</strong> 对于日志表、审计表、缓存表、需要分片的大表、或跨越服务边界的关系，<strong>避免使用外键</strong>。依赖应用层逻辑、定期批处理校验、或最终一致性模式来维护数据关联性。</li>
<li><strong>考虑“软删除”：</strong> 使用 <code>is_deleted</code> 标志位代替物理删除，可以避免 <code>ON DELETE</code> 级联的问题，同时保留外键约束。</li>
</ul>
</li>
<li>
<p><strong>应用层逻辑作为替代方案：</strong></p>
<ul>
<li>如果决定不使用数据库外键，<strong>必须在应用层严格实现相应的引用完整性检查和维护逻辑</strong>。</li>
<li>这包括在插入/更新子表前检查父表记录是否存在，在删除父表记录前检查或处理子表记录（或提供清晰的错误提示）。</li>
<li>需要良好的代码规范、测试覆盖和代码审查来确保应用层逻辑的正确性和一致性。</li>
</ul>
</li>
<li>
<p><strong>数据库选型和版本：</strong></p>
<ul>
<li>不同数据库（MySQL, PostgreSQL, SQL Server, Oracle）对外键的实现细节和性能优化程度不同。较新的数据库版本可能在外键性能方面有改进（如更细粒度的锁）。</li>
<li>了解你所用数据库的具体行为。</li>
</ul>
</li>
<li>
<p><strong>监控与调优：</strong></p>
<ul>
<li>如果使用了外键，务必密切监控相关操作的性能指标（锁等待、I/O、执行时间）。根据监控结果进行索引优化（确保外键列有高效索引！）、调整隔离级别（如果可能且安全）或重新评估设计。</li>
</ul>
</li>
</ol>
<h2 id="结论">结论</h2>
<p>在大型项目中：</p>
<ul>
<li><strong>外键约束不再是默认必选项。</strong> 其带来的性能开销、对扩展性（尤其是分布式）和架构（微服务）的限制是主要的顾虑点。</li>
<li><strong>数据完整性至关重要，但维护方式可以多样化。</strong> 不能因为不用外键就放弃数据一致性。应用层逻辑是必须的替代方案，需要严格设计和实现。</li>
<li><strong>决策应基于具体场景权衡：</strong>
<ul>
<li><strong>优先考虑性能、扩展性和架构解耦时：</strong> 倾向于避免外键，强化应用层逻辑和校验机制。</li>
<li><strong>优先考虑强数据一致性和简化核心关联逻辑时：</strong> 可以在核心、可控的关系上谨慎使用外键，并充分评估性能影响和做好监控调优。</li>
</ul>
</li>
<li><strong>混合策略常见：</strong> 在一个项目中，部分关键关系使用外键，大部分关系（特别是涉及性能瓶颈、分布式、微服务边界）不使用外键，是一种务实的选择。</li>
</ul>
<p><strong>最终建议：</strong> 在大型项目中，除非有非常强的理由（如对核心数据绝对一致性要求极高，且能承受性能代价），<strong>通常更倾向于在应用层维护引用完整性，避免使用数据库外键约束</strong>，尤其是在涉及分片、微服务或极高并发写入的场景下。务必确保应用层有完善的机制来替代外键的功能。</p>


</div>
<div id="MySignature" role="contentinfo">
    <p></p>
<div class="navgood">
<p>作者：仓储大叔，张占岭，<br>
荣誉：微软MVP<br>QQ：853066980</p>

<p><strong>支付宝扫一扫，为大叔打赏!</strong>
<br><img src="https://images.cnblogs.com/cnblogs_com/lori/237884/o_IMG_7144.JPG"></p>
</div><br><br>
来源：https://www.cnblogs.com/lori/p/18990981
頁: [1]
查看完整版本: springboot~关系数据库索引和外键