MySQL多表查询表结构设计01_mysql表中查看各表之间的架构设计

例如 规格模块的设计

1. 规格模块的表结构设计如下：
   规格表：
   

实体类设计：

public class TbSpecification implements Serializable {
    private Long id;

    private String specName;
1
2
3
4

规格项表：

实体类设计：

public class TbSpecificationOption implements Serializable {
    private Long id;

    private String optionName;

    private Long specId;

    private Integer orders;
1
2
3
4
5
6
7

  **规格表 --> 规格项表，两张表是一对多的关联关系（注意：表结构中没有设置主外键关联，对于数据库的所有外键的每次插入、更新和删除后，进行完整性检查是一个耗费时间和资源的过程，它可能影响性能）。**
1

2. 为了方便解决上述实体类的问题，可以新编写组合类，用于封装规格实体类和规格选项实体类，代码如下

 * 规格和规格项组合类
 */
public class Specification implements Serializable {
​
    // 规格
    private TbSpecification tbSpecification;
    // 多个规格项
    private List<TbSpecificationOption> tbSpecificationOptionList;
1
2
3
4
5
6
7
8

• 保存数据：

  * 保存
     * @param specification
     */
    @Override
    public void save(Specification specification) {
        // 先保存规格
        TbSpecification tbSpecification = specification.getTbSpecification();
        tbSpecificationMapper.insert(tbSpecification);
​
        // 获取到规格生成的主键值，给规格项添加进去
        Long id = tbSpecification.getId();
​
        // 再保存规格项
        List<TbSpecificationOption> list = specification.getTbSpecificationOptionList();
        // 遍历，保存
        for (TbSpecificationOption tbSpecificationOption : list) {
            // 设置外键值
            tbSpecificationOption.setSpecId(id);
            // 保存
            tbSpecificationOptionMapper.insert(tbSpecificationOption);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<selectKey keyProperty="id" resultType="long" keyColumn="id">
      select last_insert_id()
  </selectKey>
  mapper接口需要添加这一段，把id返回给对象
1
2
3
4

• 通过主键查询

  * 逻辑：返回的是组合数据，先查规格，再查规格项
     */
    @Override
    public Specification findOne(Long id) {
        // 先查规格
        TbSpecification tbSpecification = tbSpecificationMapper.selectByPrimaryKey(id);
        // 再查规格项
        // 创建查询条件
        TbSpecificationOptionExample example = new TbSpecificationOptionExample();
        TbSpecificationOptionExample.Criteria criteria = example.createCriteria();
        // 按外键查询
        criteria.andSpecIdEqualTo(id);
        // 查询数据
        List<TbSpecificationOption> list = tbSpecificationOptionMapper.selectByExample(example);
        // 封装数据
        Specification specification = new Specification();
        specification.setTbSpecification(tbSpecification);
        specification.setTbSpecificationOptionList(list);
​
        return specification;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 修改

 * 逻辑：修改规格数据，规格项：先删除，再添加
     */
    @Override
    public void update(Specification specification) {
        // 修改规格数据
        tbSpecificationMapper.updateByPrimaryKey(specification.getTbSpecification());
​
        // 删除规格项
        TbSpecificationOptionExample example = new TbSpecificationOptionExample();
        example.createCriteria().andSpecIdEqualTo(specification.getTbSpecification().getId());
        tbSpecificationOptionMapper.deleteByExample(example);
​
        // 添加规格项
        List<TbSpecificationOption> list = specification.getTbSpecificationOptionList();
        // 遍历，添加
        for (TbSpecificationOption tbSpecificationOption : list) {
            tbSpecificationOption.setSpecId(specification.getTbSpecification().getId());
            // 保存
            tbSpecificationOptionMapper.insert(tbSpecificationOption);
        }
​
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 批量删除

  * 逻辑：先删除规格，再删除规格项
     */
    @Override
    public void delete(Long[] ids) {
        // 遍历删除
        for (Long id : ids) {
            // 删除规格
            tbSpecificationMapper.deleteByPrimaryKey(id);
​
            // 再删除规格项
            TbSpecificationOptionExample example = new TbSpecificationOptionExample();
            example.createCriteria().andSpecIdEqualTo(id);
            tbSpecificationOptionMapper.deleteByExample(example);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 总结：不用在表的结构中添加主外键约束，通过代码维护。