领域驱动设计vs面向数据库编程

最新推荐文章于 2023-04-12 22:50:05 发布
最新推荐文章于 2023-04-12 22:50:05 发布
阅读量741 收藏 1
点赞数
分类专栏： Java语言 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carson0408/article/details/116893375
版权

      对于现在的大多数场景下，面向数据库编程对于实现功能来说是十分方便的，门槛比较低。主要三把斧，建表，orm框架生成dao方法，然后service层对dao进行复杂操作。最后可以封装接口提供给下游服务使用。但是对于一个复杂的场景来说，对于每张表进行各自的增删改查，这样的模型是松散的。以下介绍一个订单的简单例子。对于订单，在订单上下文中属于聚合根，根据领域驱动设计的命令事件法，命令是下订单，返回的事件是订单已生成。因此，我们此文通过对订单这个聚合根的讲解，来突出聚合对于整个业务逻辑的好处。

      一般我们在电商网站下单，需要付钱，需要填写地址等。因此，订单肯定有订单号、费用以及用户的收件地址，对于事件来说会存在一个状态。比如下单后会存在待付款、已付款、运送中等多个状态。对于一个订单我们可能会买多个物品，因此在订单中有多个条目。存在一对多的关系，因此item(条目)可以单独成表，与订单表是多对一的关系。至于订单聚合根中地址状态可以与订单同一个状态，也可以分开。与订单形成一对一的关系。本文中讲解的例子是分开。以下是本文讲解订单案例的数据库ER图。

上述数据库关联的sql语句如下:

use order_s;
create table order_table(

`id` int NOT NULL AUTO_INCREMENT COMMENT '主键id',
`order_name` varchar(64) NULL DEFAULT NULL COMMENT '订单名称' ,
 primary key(`id`)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

create table order_item (
`product_id` varchar(64) NULL DEFAULT NULL COMMENT '产品id' ,
`qty` int(11) NULL DEFAULT 0 COMMENT "金额" ,
`order_table` int(11) NULL DEFAULT 0 COMMENT '订单id' ,
`order_table_key` int NOT NULL AUTO_INCREMENT COMMENT '主键id',
 primary key(`order_table_key`),
 CONSTRAINT `order_item_ibfk` FOREIGN KEY(`order_table`) REFERENCES `order_table` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
 )ENGINE=InnoDB DEFAULT CHARSET=utf8;

create table address (
`street` varchar(64) NULL DEFAULT NULL COMMENT '街道',
`zip` varchar(64) NULL DEFAULT NULL COMMENT '位置' ,
`order_table` int(11) NULL DEFAULT 0 COMMENT '订单id' ,
`id` int NOT NULL AUTO_INCREMENT COMMENT '主键id',
 PRIMARY KEY (`id`),
 CONSTRAINT `address_ibfk` FOREIGN KEY(`order_table`) REFERENCES `order_table` (`id`) ON DELETE CASCADE ON UPDATE CASCADE)ENGINE=InnoDB DEFAULT CHARSET=utf8;

create table order_status (
`state` int(11) NULL DEFAULT 0 COMMENT '状态' ,
`order_table` int(11) NULL DEFAULT 0 COMMENT '订单id' ,
 `id` int NOT NULL AUTO_INCREMENT COMMENT '主键id',
 PRIMARY KEY (`id`),
 CONSTRAINT `status_ibfk` FOREIGN KEY(`order_table`) REFERENCES `order_table` (`id`) ON DELETE CASCADE ON UPDATE CASCADE)ENGINE=InnoDB DEFAULT CHARSET=utf8;

      

     根据数据库模型给出demo。

order类代码:

      根据Order类可以看出Order这个聚合根与OrderItem是一对多的关系，与Address和OrderStatus都是一对一的关系。除了通过@OneToOne和@OneToMany注释建立关联。同时需要在被关联对象中建立与维护端的关系，如下列代码中的代码片段在address赋值之后，同时需要将当前order对象赋值给Address对象中关联的order属性。这样两者便相互建立了关系。

private Order(Address address, Collection<OrderItem> items,String name) {
        this.m_Address = address;
        this.m_OrderStatus = new Placed();
        this.name = name;
        //需要与维持方建立关系，这里订单与地址一对一的关系，地址需要与订单建立关系
        m_Address.setOrder(this);
        this.items = items.stream().map(r->{
            r.setOrder(this);
            return r;}).collect(Collectors.toList());
        m_OrderStatus.setOrder(this);
    }
/**
 * ClassName Order
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
@Table(name = "order_table")
@Entity
@Proxy(lazy = false)
public class Order {



    @OneToOne(mappedBy = "order",fetch=FetchType.LAZY,cascade = CascadeType.ALL)
    //@JsonBackReference
    private Address m_Address;

    @OneToOne(mappedBy = "order",fetch=FetchType.LAZY,cascade = CascadeType.ALL)
    private OrderStatus m_OrderStatus;





    @OneToMany(mappedBy = "order",cascade = CascadeType.ALL,fetch = FetchType.LAZY)
    //@JsonBackReference
    private Collection<OrderItem> items;
    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "order_name")
    private String name;

    public Order() {
        items = new ArrayList<>();
        m_OrderStatus = new Placed();
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void addItem(OrderItem item) {
        items.add(item);
    }

    public Collection<OrderItem> getItems() {
        return items;
    }

    public void setItems(Collection<OrderItem> items) {
        this.items = items;
    }

    public Address getM_Address() {
        return m_Address;
    }

    public void setM_Address(Address m_Address) {
        this.m_Address = m_Address;
    }

    public OrderStatus getM_OrderStatus() {
        return m_OrderStatus;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean setM_OrderStatus(OrderStatus m_OrderStatus) {
        if(m_OrderStatus==null){
            return false;
        }
        OrderStatus status = getM_OrderStatus();
        if(status==null){
            return false;
        }
        OrderStatus orderStatusN = status.next();
        if (orderStatusN.getState() == m_OrderStatus.getState()) {
            this.m_OrderStatus = orderStatusN;
            return true;
        } else
            return false;
    }


    private Order(Address address, Collection<OrderItem> items,String name) {
        this.m_Address = address;
        this.m_OrderStatus = new Placed();
        this.name = name;
        //需要与维持方建立关系，这里订单与地址一对一的关系，地址需要与订单建立关系
        m_Address.setOrder(this);
        this.items = items.stream().map(r->{
            r.setOrder(this);
            return r;}).collect(Collectors.toList());
        m_OrderStatus.setOrder(this);
    }

    public static OrderVOBuilder builder() {
        return new OrderVOBuilder();
    }

    public static class OrderVOBuilder{
        private Address address;
        private Collection<OrderItem> items;

        private String name;
        public OrderVOBuilder withAddress(Address address) {
            this.address = address;
            return this;
        }
        public OrderVOBuilder withItems(Collection<OrderItem> items) {
            this.items = items;
            return this;
        }

        public OrderVOBuilder withName(String name){
            this.name = name;
            return this;
        }
        public Order build() {
            return new Order(address, items,name);
        }
    }
}

OrderItem:

/**
 * ClassName OrderItem
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
@Entity
@Table(name = "order_item")
@Proxy(lazy = false)
public class OrderItem {

    @Column(name = "product_id")
    private String productId;
    private int qty;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "order_table_key")
    private int order_table_key;



    //JoinColumn中name是表中的外键名，referencedColumnName代表关联表的字段
    @ManyToOne
    @JoinColumn(name = "order_table",referencedColumnName = "id")
    @JsonBackReference
    private Order order;






    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public int getQty() {
        return qty;
    }

    public void setQty(int qty) {
        this.qty = qty;
    }

    public int getOrder_table_key() {
        return order_table_key;
    }

    public void setOrder_table_key(int order_table_key) {
        this.order_table_key = order_table_key;
    }



    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }


}

Address:

       JPA自带的注释@OneToOne，同时@JoinColumn注释来将外键与关联表的主键关联起来。

/**
 * ClassName Address
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
@Table(name = "address")
@Entity
@Proxy(lazy = false)
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "street")
    private String street;
    @Column(name = "zip")
    private String zip;

    @OneToOne(targetEntity = Order.class)
    @JoinColumn(name = "order_table",referencedColumnName = "id")
    @JsonBackReference
    private Order order;

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }
    public Address() {

    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getZip() {
        return zip;
    }

    public void setZip(String zip) {
        this.zip = zip;
    }
}

OrderStatus:

/**
 * ClassName OrderStatus
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
@Table(name = "order_status")
@Entity
@Proxy(lazy = false)
@ToString
public class OrderStatus {

    protected int state = -1;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @OneToOne(targetEntity = Order.class)
    @JoinColumn(name = "order_table",referencedColumnName = "id")
    @JsonBackReference
    private Order order;


    public OrderStatus(){

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }

    public OrderStatus(int state) {
        this.state = state;
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    //切换的时候记得把其他的都要copy过来，仅有状态发生改变
    public OrderStatus next() {
        OrderStatus orderStatus = null;
        if (state == 0) {
            state = state+1;
        }
        else if (state == 1) {
            state = state+1;
        } else {
            state = -1;
        }
        return this;
    }
}

OrderStatus有三个子类

Payment:

/**
 * ClassName Payment
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
public class Payment extends OrderStatus {

    public Payment() {
        super(1);//表示已支付
    }

    public OrderStatus next() {
        return new Delivery();
    }
}

Placed:

/**
 * ClassName Placed
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
public class Placed extends OrderStatus {
    public Placed() {
        super(0);
    }

    @Override
    public OrderStatus next() {
        return new Payment();
    }
}

Delivery:

/**
 * ClassName Delivery
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
public class Delivery extends OrderStatus {

    public Delivery() {
        super(2);//已发货

    }

    @Override
    public OrderStatus next() {
        return null;
    }
}

仓储层:

/**
 * ClassName OrderRepository
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
public interface OrderRepository extends CrudRepository<Order,Integer> {
}

接口层:

/**
 * ClassName OrderController
 *
 * @author carson
 * @description
 * @Version V1.0
 * @createTime
 */
@RestController
@Transactional(rollbackFor = Exception.class)
public class OrderController {


    @Resource
    private OrderRepository orderRepo;

    @PostMapping("/orders")
    public Order placeOrder(@RequestBody OrderItem orderItem,
                            @RequestParam String name,
                            @RequestParam String street,
                            @RequestParam String zip) {
        Collection<OrderItem> orderItems = new ArrayList<>();
        ((ArrayList<OrderItem>) orderItems).add(orderItem);
        Order order = Order.builder().withName(name).withAddress(createAddress(street,zip)).withItems(orderItems).build();
        System.out.println("order:"+order);
        return orderRepo.save(order);
    }


    @PutMapping("/orders/updateAddress")
    public Order updateAddress(@RequestParam String street,@RequestParam Integer orderId,@RequestParam String zip){
        Order order = orderRepo.findById(orderId).orElse(new Order());
        Address address = order.getM_Address();
        if(Objects.isNull(address)){
            address = createAddress(street, zip);
        }else {
            address.setZip(zip);
            address.setStreet(street);
        }
        order.setM_Address(address);
        return orderRepo.save(order);
    }


    @PostMapping("/orders/payment")
    public Order payment(@RequestParam Integer orderId) {
        Order orderSaved2 = orderRepo.findById(orderId).orElse(new Order());
        if (orderSaved2.setM_OrderStatus(new Payment()))
            orderRepo.save(orderSaved2);
        return orderSaved2;
    }

    @PostMapping("/orders/delivery")
    public Order delivery(@RequestParam Integer orderId) {
        Order orderSaved2 = orderRepo.findById(orderId).orElse(new Order());
        if (orderSaved2.setM_OrderStatus(new Delivery()))
            orderRepo.save(orderSaved2);
        return orderSaved2;
    }




    private Address createAddress(String street,String zip){

        Address address = new Address();
        address.setStreet(street);
        address.setZip(zip);
        return address;


    }

}

注意点:

 1.一对多和一对一都需要在被维护端的实例中建立与维护端的相互关系

  2.注意@Id注释不要引错包，org.springframework.data.annotation.Id;会带来实体转换的错误，切记要引用javax.persistence.Id;

 

具体代码可以在github上下载，地址:https://github.com/carson0408/order

carson0408
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-9-数据库编程.zip
06-01
了解了Python的数据库编程基础后，你将能够构建数据库驱动的应用，实现数据的高效管理和处理。通过实践和学习更多关于特定数据库系统的知识，如SQL语法和数据库设计原则，你将成为一名出色的Python数据库开发者。
面向数据编程 Data-Oriented Programming [1]
unity尧明的博客
06-17 4960
面向数据的编程原则 0.1 简介
面向数据编程 Data-Oriented Programming [22]
unity尧明的博客
06-20 294
高度可扩展的并发控制 5.1 简介   在上一章中，我们已经说明了状态管理的多版本方法，其中突变被分成两个不同的阶段：只处理计算的计算阶段和向前移动状态引用的提交阶段。   通常，在生产系统中，突变同时发生。像我们在上一章中所做的那样天真地推进状态是不合适的。在本章中，我们将学习如何处理并发突变。   在DO中，只有提交阶段的代码是有状态的，这一事实允许我们利用不涉及任何锁定机制的乐观并发控制策略。因此，读写吞吐量很高。   对代码的修改不是微不足道的，因为我们必须实现一个协调并发突变之间的算法。但是修改只
面向数据编程 Data-Oriented Programming [11]
unity尧明的博客
06-19 965
通过将代码与数据分离来降低系统复杂性 2.1简介   正如我们在第0章中提到的，面向数据编程(DO)的最大洞察力在于，我们可以通过将代码与数据分开来降低系统的复杂性。事实上，当代码与数据分离时，我们的系统由两个可以分开考虑的主要部分组成：数据实体和代码模块。   本章深入探讨了面向数据编程的第一个原则： NOTE 原则#1：以代码驻留在函数中的方式将代码与数据分开，这些函数的行为不依赖于以某种方式封装在函数上下文中的数据。   我们在第1章介绍的图书馆管理系统的上下文中说明了代码和数据的分离，并揭示了这
Java面向数据库编程——初始MySQL
Chen_NC的博客
10-14 215
常用基础语法大全： mysql常用基础语法大全 - 知乎 (zhihu.com) MySQL的优势： 运行速度快。体积小，命令执行的速度快。 使用成本低。开源的，且提供免费版本。 容易使用。与其他大型数据库的设置和管理相比，其复杂程度较低，易于使用。 可移植性强。能够运用于多种系统平台上。【Windows、Linux、UNIX】等。 适用更多用户。支持最常用的数据管理功能，适用于中小型企业甚至大型网站应用。 命令行方式操作MySQL数据库 数据库类型 系统数据库： information
Java面向数据库编程——数据库设计
最新发布
weixin_68107783的博客
04-12 423
Java面向数据库编程——数据库设计
领域驱动设计与模式实战
08-09
1.3.2 领域驱动设计 1.3.3 测试驱动开发 1.3.4 重构 1.3.5 选择一种还是选择组合 1.4 持续集成 1.4.1 解决方案（或至少是正确方向上的一大步） 1.4.2 从我的组织汲取的教训 1.4.3 更多信息 1.5 不要忘记运行机制 ...
数据库编程课件数据库编程课件.ppt
06-05
数据库编程是IT领域中至关重要的一个分支，它涉及到如何有效地存储、管理和检索数据。本课件主要涵盖了数据库系统的基础知识，以及Delphi环境下数据库编程的关键组件。以下是对这些知识点的详细解释： 首先，数据库...
VC数据库编程VC数据库编程.ppt
06-03
【VC++数据库编程】在IT领域，VC++作为一款强大的C++开发工具，不仅支持桌面应用的构建，还可以用于数据库应用程序的开发。本篇主要探讨的是VC++在数据库编程中的运用，包括其优势和提供的数据库访问技术。 首先，...
S2使用Java实现数据库编程
10-09
在IT行业中，数据库编程是至关重要的技能之一，尤其是在Java开发领域。本教程将重点讨论如何使用Java语言来实现对MySQL数据库的编程操作。通过提供的压缩包"使用Java实现数据库编程-1488176910082"，我们可以深入...
数据库编程面向对象版
05-11
数据库编程 面向对象版2018，学生考务管理系统 某学院需要一个简易选课系统，学生可以选修多门课程；每门课程可以有多个学生选修，并限定选课人数上限。 系统功能如下： 需具有选课、登记成绩等基本功能；  每学期末学院可查看各学生平均成绩、各课程平均成绩、不及格学生名单及门数  能自动统计某门课程的考试人数、最高分、最低分、平均分、100-90分段百分比、90-80分段百分比、80-70分段百分比、70-60分段百分比、60-0分段百分比  能自动统计某学生每学期平均成绩的变化曲线  对成绩修改进行严格管理，每次调高成绩都应有记录
面向数据编程
weixin_38051797的博客
10-08 2380
面向对象编程层层抽象造成臃肿，导致运行效率降低，而这是性能要求高的游戏编程领域不想看到的。 面向过程：建立解决问题所需的各个步骤（函数）。 面向对象：建立解决问题所需的各个模型（类）。 面向数据：考虑数据的存取及布局（数据）。 值得一说的是，面向过程和面向对象都是解决问题的一种方法，而面向数据只是一种优化的设计思想，而非解决问题的方法。 冷数据/热数据分割 我们希望CPU缓存存储的是经常使用的数据，而不是那些少用的数据。这就引入了冷数据/热数据分割的概念了。 热数据：经常要操作使用的数据，我们一般可
面向sql编程的探索之路
weixin_33827731的博客
07-06 159
前言 在我们JavaWeb开发过程中，或多或少会有些只是几行sql语句的service方法或是http请求，总是要反复写Controller层、service层、dao层。于是，我做了一个大胆的尝试，对于此类方法，封装出一个公共方法，不需要写java代码，写几行sql语句就能出各种接口及方法。 表设计 id description SQL creator creattime updateti...
Java：面向数据库编程
weixin_43812991的博客
11-23 552
1：数据库连接 *package com.Jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import org.apache.log4j.Logger...
面向考试数据库—数据库编程（Ⅰ）
徐思孟的博客
05-02 2052
数据库的编程部分，主要为存储过程与相关函数的使用
面向对象的数据库编程 O/R Mapping
lee576的专栏
09-23 2296
1.2.1   什么是O/R Mapping如果我们采用面向对象的思想进行系统的分析设计，那么数据库采用关系型数据库就会存在对象模型和关系模型两者之间“不匹配”这个不容忽视的问题。面向对象设计和关系型数据库设计存在很大的不同。对象模型基于软件工程的一些原理，面向对象设计的理论包括封装、关联、聚合、继承、多态，而关系模型主要针对数据的存储。我们希望通过面向对象的设计方式来完成业务流程，这一点可以实现
一篇非常经典的文章（面向接口编程）（转载）
iteye_7450的博客
03-23 2237
面向对象设计里有一点大家已基本形成共识，就是面向接口编程，我想大多数人对这个是没有什么觉得需要怀疑的。 问题是在实际的项目开发中我们是怎么体现的呢？ 难道就是每一个实现都提供一个接口就了事了？反过来说，你有时候有没有觉得接口是多余的事？ 又或者，你仅仅是觉得现在类似spring这样的框架已习惯用接口这种方式而心存当然。 设计模式解析里提到了面向对象...
面向过程的代码书写、用来操作数据库
weixin_45213847的博客
06-22 285
#面向过程的代码书写、用来操作数据库 const express = require( 'express' ); const router = new express.Router(); // database 操作 --start // 1. 安装mongoose cnpm i mongoose -S/-D // 2. 引入mongoose const mongoos...
实践领域驱动设计：从理论到实现
"本文深入探讨了领域驱动设计（DDD）的实践应用，旨在提供技术主管和架构师在实现领域模型时所需的知识和工具。内容涵盖了领域建模的关键元素，如实体、值对象、服务，以及Bounded Context和Anti-Corruption Layer等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值