您当前的位置:首页 > 电脑百科 > 程序开发 > 编程百科

想用好 DDD 必须先过 Spring Data 这关

时间:2023-02-06 15:25:11  来源:今日头条  作者: 后端技术分享

1. 面向对象设计是 DDD 的核心

DDD 着重于将业务领域中的概念和对象映射到对象中,使对象模型能够更好地反映业务的真实情况,从而使设计更具可理解性和可维护性。

 

DDD 是一种领域驱动的设计方法,旨在通过建立对领域模型的清晰理解来解决业务问题。和事务脚本不同,DDD 使用面向对象设计来应对复杂的业务场景。

简单来说,DDD 是由领域对象承载业务逻辑,所有的业务操作均在模型对象上完成,同一对象上不同的业务操作构成了对象的生命周期。

我们以订单为例,如下图所示:


 

 

  1. 首先,用户操作下单,使用提交数据为其创建一个 Order 对象,版本 V1;
  2. 随后,用户进行改地址操作,调用 Order 对象的 modifyAddress 方法,Order 从原来的 V1 变成 V2;
  3. 用户完成支付后,调用 Order 对象的 paySuccess 方法,Order 从 V2 变成 V3;

 

从图上可见,在 DDD 设计中,所有的业务逻辑均由业务对象完成,所以面向对象是 DDD 设计的核心。

2. 为什么需要 Repository?

假设,有一台非常牛逼的计算机,计算资源无限、内存大小无限、永不掉电、永不宕机,那最简单高效的方式便是将模型对象全部放在内存中。

但,现实不存在这样的机器,我们不得不将内存对象写入磁盘,下次使用时,在将其从磁盘读入到内存。

整体结构如下图所示:


 

和上图相比,具有如下特点:

 

  1. 业务操作没变,仍旧依次完成 下单、改地址、支付等操作
  2. 引入持久化存储(MySQL),可以将 Order 对象存储于关系数据库
  3. 配合 Order 的生命周期,操作中增加 save、load 和 update 等操作
    1. 用户下单创建 Order 对象,通过 save 方法将 Order 对象持久化到 DB
    2. 接收到业务操作,需执行load,从 DB 加载数据到内存 并对 Order 对象的状态进行恢复
    3. 在业务操作完成后,需执行update,将 Order 对象的最新状态同步的 DB

 

相对全内存版本确实增加了不小的复杂性,为了更好的对这些复杂性进行管理,引入 Repository 模式。

 

在领域驱动设计(DDD)中,Repository 是一种设计模式,它是用来存储领域对象的容器。它提供了一种统一的方式来查询和存储领域对象。Repository提供了对底层数据存储的抽象,允许应用程序在没有直接与数据存储技术交互的情况下访问数据,同时该抽象允许在不修改应用程序代码的情况下更改数据存储技术。
3. 什么才是好的 Repository ?

 

好的 Repository 应该在满足业务需求的前提下,具备以下特性:

 

  1. 高内聚:好的 Repository 应该满足单一职责原则,每个 Repository 只关注一种领域对象的存储;
  2. 松耦合:好的 Repository 应该通过抽象接口与其他层进行交互,保证它们之间的耦合度低;
  3. 简单易用:好的 Repository 应该提供一组易于使用的方法,方便开发人员使用;
  4. 可维护性:好的 Repository 应该易于维护,维护人员不需要长时间阅读代码才能了解它的工作原理;

 

说的太官方了,用人话就是:

 

  1. 需要一个统一的 Repository 接口,用于对易用方法save、load、update进行管理
  2. 为每个聚合根创建一个 Repository 接口,继承自 统一Repository,只关注该聚合根的存储
  3. Repository 的实现尽可能的简单,最好不用实现(人都是懒的)
4. 初始 Spring Data
Spring Data是一个框架,旨在简化数据访问层的开发。它通过抽象和模板化方法,使得与各种数据存储(如关系型数据库,文档数据库,图形数据库,缓存等)的交互变得更加简单和标准化。

 

Spring Data 通过提供简单的、通用的数据访问接口(如Repository)和自动生成实现代码,使得开发人员不必编写重复的数据访问代码。这样,开发人员可以专注于业务逻辑,而无需关注数据存储和访问的细节。

总的来说,Spring Data的主要解决的问题是:简化数据访问层的开发,提高代码复用性,降低开发复杂度。

Spring Data 对多种数据存储提供了支持,本文以 Spring Data Jpa 为例,快速实现应用程序与关系数据库的交互。

4.1. 引入 Spring Data JPA

Spring Data jpa 是 Spring Data 家族的重要成员,主要解决 JAVA 应用程序使用 Jpa 完成对数据库的访问问题。它提供了一种简单而灵活的方法来访问和管理数据,并且可以消除重复代码和提高开发效率。

 

首先,需要在pom中 引入 spring-data-jpa-starter,具体如下:

org.springframework.boot spring-boot-starter-data-jpa

其次,引入 mysql 驱动,具体如下:

com.mySQL mysql-connector-j runtime

Spring Data Jpa 默认实现是 Hibernate,而 Hibernate 是目前最流行且功能最强大的 JPA 实现,它提供了强大的映射、查询和事务管理能力。
4.2. 完成配置

 

Application.yml 增加 DB 和 Jpa 相关配置,具体如下:

spring: application: name: Spring-Data-for-DDD-demo datasource: # 数据库配置信息 driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/books username: root password: root jpa: # 打印 sql show-sql: true

在启动类上启用 Spring Data Jpa。

@SpringBootApplication // 开启 Spring Data Jpa, basePackages 是 Repository 接口存放的包路径 @EnableJpaRepositories(basePackages = "com.geekhalo.springdata4ddd.order.repository") public class Application { public static void mAIn(String[] args) { SpringApplication.run(Application.class, args); } } 4.3. 使用 Repository

一切就绪,接下来就可以为模型创建专属 Repository,具体如下:

public interface OrderCommandRepository extends JpaRepository { }

至此,Order 的专属 Repository 就开发完成。

不知道你是否存在疑问:

 

  1. 说好的统一的易用方法在哪里?
  2. 为什么没有看到实现代码?

 

一般情况下,JpaRepository 接口中的方法就能满足大部分需求,典型方法包括:

方法

含义

save、saveAll

保存或更新,如果数据库没有则执行 insert 操作,数据库有则执行 update 操作

findById

根据主键查询实体

findAllById

根据主键批量获取实体

count

查询数量

delete、deleteById

删除数据

findAll

分页或排序

5. 实战--订单

为了体现 Spring Data Jpa的强大功能,以最常见的订单为例,业务模型如下图所示:


 

 

  1. 一笔下单对应一个订单(Order)
  2. 一个订单可以有一个收获地址(OrderAddress)
  3. 一个订单可以关联多个订单项(OrderItem)

 

对应到领域模型如下:


 

核心代码如下:

@Data @Entity @Table(name = "tb_order") @Setter(AccessLevel.private) public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "user_id") private Long userId; @Column(name = "status") @Enumerated(EnumType.STRING) private OrderStatus status; @Column(name = "price") private int price; // 收货地址 @.NEToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "user_address_id") private OrderAddress address; // 订单项 @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL) @JoinColumn(name = "order_id") private List items = new ArrayList<>(); } 5.1. 生单

先简单看下生单的核心代码,具体如下:

@Transactional(readOnly = false) public Order createOrder(CreateOrderCommand command){ // 创建内存对象 Order order = Order.create(command); // 保存到数据库 this.repository.save(order); return order; } // Order 实体上的 create 方法 public static Order create(CreateOrderCommand command) { // 创建内存对象 Order order = new Order(); order.setUserId(command.getUserId()); String userAddress = command.getUserAddress(); if (!StringUtils.hasText(userAddress)){ // 设置收获地址 OrderAddress orderAddress = new OrderAddress(); orderAddress.setDetail(userAddress); order.setAddress(orderAddress); } // 添加订单项 List productForBuys = command.getProducts(); productForBuys.stream() .map(productForBuy -> OrderItem.create(productForBuy)) .forEach(orderItem -> order.addOrderItem(orderItem)); order.init(); return order; }

单元测试,具体如下:

@Test void createOrder() { // 创订单,将整个 Order 聚合根全部保存到数据库,包括 // 1. order // 2. orderItem // 3. orderAddress CreateOrderCommand command = createOrderCommand(10L); Order order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); }

运行单元测试,打印以下 SQL:

// createOrder 方法中 repository.save(order) 产生的 SQL: // 插入 收货地址 Hibernate: insert into tb_order_address (detail) values (?) // 插入 order Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) // 插入 orderItem Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) // 将 order item 与 order 进行绑定(这步存在性能损耗,但是目前没有更好的解决方案) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=?

是否发现 Spring Data Jpa 的强大之处:核心逻辑全部内聚在 Order 类,在没有写任何数据层访问代码的前提下,一个 save 方法便可以将这组高内聚的对象保存到 DB。

5.2. 修改地址

修改地址核心代码如下:

@Transactional(readOnly = false) public void modifyAddress(Long orderId, String address){ Optional orderOptional = repository.findById(orderId); if (orderOptional.isPresent()){ Order order = orderOptional.get(); order.modifyAddress(address); this.repository.save(order); } } // Order 实体上的方法 public void modifyAddress(String address){ if (this.address == null){ this.address = new OrderAddress(); } this.address.modify(address); } // OrderAddress 实体上的方法 public void modify(String address) { setDetail(address); }

首先,看一个添加地址的场景,生单时没有提供收货地址,生单后修改地址:

@Test void modifyAddress_add() { // 新订单不存储地址信息(没有 userAddress) Order order = null; { CreateOrderCommand command = createOrderCommand(20L); // 将收获地址设置为 null command.setUserAddress(null); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } // 修改时,直接创建地址(插入新数据) String address = "新增地址"; // Lazy 加载,只加载 orderAddress // 修改后,只更新 OrderAddress this.applicationService.modifyAddress(order.getId(), address); Order orderInDB = this.repository.findById(order.getId()).get(); Assertions.assertEquals(address, orderInDB.getAddress().getDetail() ); }

运行单测可,控制台输出以下信息:

// createOrder 方法中 repository.save(order) 产生的 SQL: // 生单时没有地址,所以没有向 tb_order_address 插入数据 Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // modifyAddress 方法中 repository.findById(orderId) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // modifyAddress 方法中 this.repository.save(order) 产生的 SQL // 为 Order 对象添加 orderAddress 后,自动向数据库添加数据 Hibernate: insert into tb_order_address (detail) values (?) // 更新 Order 的 user_address,完成数据绑定 Hibernate: update tb_order set user_address_id=?, price=?, status=?, user_id=? where id=? // repository.findById(order.getId()) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象,进行结果检测 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

看一个更新地址的场景,生单时设置收货地址,然后操作修改地址:

@Test void modifyAddress_update() { // 新订单部存在地址信息(没有 userAddress) Order order = null; { CreateOrderCommand command = createOrderCommand(30L); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } // Lazy 加载,只加载 orderAddress // 修改后,只更新 OrderAddress String address = "修改地址"; this.applicationService.modifyAddress(order.getId(), address); Order orderInDB = this.repository.findById(order.getId()).get(); Assertions.assertEquals(address, orderInDB.getAddress().getDetail() ); }

运行测试用例,输出如下信息:

// createOrder 方法中 repository.save(order) 产生的 SQL: // 创建带有地址的订单 Hibernate: insert into tb_order_address (detail) values (?) Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // modifyAddress 方法中 repository.findById(orderId) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // 在对 order.address 进行访问时,进行自动加载 Hibernate: select orderaddre0_.id as id1_1_0_, orderaddre0_.detail as detail2_1_0_ from tb_order_address orderaddre0_ where orderaddre0_.id=? // modifyAddress 方法中 this.repository.save(order) 产生的 SQL // OrderAddress 信息发生变化,将变更更新到数据库 Hibernate: update tb_order_address set detail=? where id=? // repository.findById(order.getId()) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象,进行结果检测 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

从该用例可看出,Jpa 具有:

 

  1. 懒加载能力,只有在访问到关联数据时才对数据进行加载
  2. 自动同步能力,新增对象通过 insert 将其插入数据库,修改对象通过 update 对数据库数据进行更新
5.3. 支付

 

修改地址是简单的一对一,那对于较复杂的一对多,Jpa 是否也具有 懒加载 和 自动同步能力呢?

支付核心代码如下:

@Transactional(readOnly = false) public void paySuccess(PaySuccessCommand command){ Optional orderOptional = repository.findById(command.getOrderId()); if (orderOptional.isPresent()){ Order order = orderOptional.get(); order.paySuccess(command); this.repository.save(order); } } // Order 实体上的 paySuccess 方法 public void paySuccess(PaySuccessCommand paySuccessCommand){ this.setStatus(OrderStatus.PAID); this.items.forEach(OrderItem::paySuccess); } // OrderItem 上的 paySuccess 方法 public void paySuccess() { setStatus(OrderItemStatus.PAID); }

单元测试如下:

@Test void paySuccess() { Order order = null; { CreateOrderCommand command = createOrderCommand(50L); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } PaySuccessCommand paySuccessCommand = new PaySuccessCommand(); paySuccessCommand.setOrderId(order.getId()); paySuccessCommand.setPrice(1000L); paySuccessCommand.setChanel("微信支付"); // Lazy 加载,只加载 orderItem // 修改后,更新 order 和 OrderItem this.applicationService.paySuccess(paySuccessCommand); Order orderInDB = this.repository.findById(order.getId()).get(); Assertions.assertEquals(OrderStatus.PAID, orderInDB.getStatus()); orderInDB.getItems().forEach(orderItem -> { Assertions.assertEquals(OrderItemStatus.PAID, orderItem.getStatus()); }); }

运行单元测试,控制台出现信息如下:

// createOrder 方法中 repository.save(order) 产生的 SQL: // 创建带有地址的订单 Hibernate: insert into tb_order_address (detail) values (?) Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // paySuccess 方法中 repository.findById(orderId) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // 访问 order.items,触发自动加载 Hibernate: select items0_.order_id as order_id7_2_0_, items0_.id as id1_2_0_, items0_.id as id1_2_1_, items0_.amount as amount2_2_1_, items0_.price as price3_2_1_, items0_.product_id as product_4_2_1_, items0_.product_name as product_5_2_1_, items0_.status as status6_2_1_ from tb_order_item items0_ where items0_.order_id=? // paySuccess 方法中 this.repository.save(order) 产生的 SQL // 将 Order 变更更新到数据库 Hibernate: update tb_order set user_address_id=?, price=?, status=?, user_id=? where id=? // 将 OrderItem 变更更新到数据库 Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? // repository.findById(order.getId()) 产生的 SQL // 从 DB 中加载数据,构建内存的 Order 对象,进行结果检测 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

从 SQL 中可见,在复杂的 一对多 场景,懒加载 和 自动同步能力 仍旧有效。

 

从代码上可以清晰得出:在 Spring Data Jpa 的助力下,无需编写任何数据层访问代码,便可以完成领域对象的管理。
6. 小结

 

DDD 和 Jpa 都是面向对象设计的巅峰之作,两者结合威力巨大。

结合使用 DDD 和 JPA 可以有效地将领域模型与数据库持久化技术相结合。开发人员可以使用领域驱动的方法管理数据,并通过 JPA 将数据存储在数据库中,从而避免冗长的数据持久化代码。

此外,使用 DDD 和 JPA 还有其他优势:

提高代码可读性:领域驱动的设计方法可以帮助开发人员更清晰地了解领域模型,使代码更易于阅读和维护。

减少代码量:使用 JPA 可以减少代码量,因为开发人员不需要编写手动的数据持久化代码。

提高代码的可重用性:通过使用领域模型,开发人员可以创建一组可重用的实体,并在多个地方使用它们。

提高代码的可扩展性:使用 DDD 和 JPA 可以使代码更易于扩展,因为它们遵循领域驱动的设计方法。

总之,使用 DDD 和 JPA 可以帮助开发人员更有效地解决业务问题,提高代码的可读性,可重用性和可扩展性,并减少代码量。



Tags:Spring Data   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系,我们将及时更正、删除。
▌相关推荐
分享Spring Data JPA的一些技巧和最佳实践
在现代软件开发中,Spring Boot已成为构建稳健和可扩展应用程序的主要框架。当涉及到与数据库的交互时,Java持久化API(JPA)提供了一种方便高效的方式来管理关系型数据。为了确保...【详细内容】
2023-10-04  Search: Spring Data  点击:(386)  评论:(0)  加入收藏
Spring Data JPA 和 MyBatis 谁更强?
我无法明确的告诉你JPA和MyBatis在国内哪个会更流行,我本人更喜欢JPA,但是我本人日常开发用MyBatis多。但是我的回答绝对不是在划水,而是我多年来自己的一点小小的思考。MyBati...【详细内容】
2023-08-22  Search: Spring Data  点击:(336)  评论:(0)  加入收藏
知乎高赞:Spring Data JPA 和 MyBatis 谁更强?
我无法明确的告诉你JPA和MyBatis在国内哪个会更流行,我本人更喜欢JPA,但是我本人日常开发用MyBatis多。但是我的回答绝对不是在划水,而是我多年来自己的一点小小的思考。MyBati...【详细内容】
2023-07-29  Search: Spring Data  点击:(260)  评论:(0)  加入收藏
想用好 DDD 必须先过 Spring Data 这关
1. 面向对象设计是 DDD 的核心DDD 着重于将业务领域中的概念和对象映射到对象中,使对象模型能够更好地反映业务的真实情况,从而使设计更具可理解性和可维护性。 DDD 是一种领...【详细内容】
2023-02-06  Search: Spring Data  点击:(182)  评论:(0)  加入收藏
二次封装 Spring Data JPA/MongoDB,打造更易用的数据访问层
最近我在做一个新项目,由于我们项目组一直使用的是 MongoDB 数据库,所以新项目我就打算上 Spring Data MongoDB 尝试一下,虽然我早就用过了 Spring Data JPA,对 Spring Data 的...【详细内容】
2022-11-22  Search: Spring Data  点击:(337)  评论:(0)  加入收藏
程序员应知应会之Spring Data Jpa为什么不用写@Repository注解?
大家知道,在Springboot+Spring Data Jpa的项目里,dao层只需要继承JpaRepository接口,就可以实现Mybatis中@Repository+mapper的效果,不需要任何多余的配置,就可以将dao层注入bean...【详细内容】
2022-10-17  Search: Spring Data  点击:(383)  评论:(0)  加入收藏
▌简易百科推荐
Netflix 是如何管理 2.38 亿会员的
作者 | Surabhi Diwan译者 | 明知山策划 | TinaNetflix 高级软件工程师 Surabhi Diwan 在 2023 年旧金山 QCon 大会上发表了题为管理 Netflix 的 2.38 亿会员 的演讲。她在...【详细内容】
2024-04-08    InfoQ  Tags:Netflix   点击:(3)  评论:(0)  加入收藏
即将过时的 5 种软件开发技能!
作者 | Eran Yahav编译 | 言征出品 | 51CTO技术栈(微信号:blog51cto) 时至今日,AI编码工具已经进化到足够强大了吗?这未必好回答,但从2023 年 Stack Overflow 上的调查数据来看,44%...【详细内容】
2024-04-03    51CTO  Tags:软件开发   点击:(8)  评论:(0)  加入收藏
跳转链接代码怎么写?
在网页开发中,跳转链接是一项常见的功能。然而,对于非技术人员来说,编写跳转链接代码可能会显得有些困难。不用担心!我们可以借助外链平台来简化操作,即使没有编程经验,也能轻松实...【详细内容】
2024-03-27  蓝色天纪    Tags:跳转链接   点击:(15)  评论:(0)  加入收藏
中台亡了,问题到底出在哪里?
曾几何时,中台一度被当做“变革灵药”,嫁接在“前台作战单元”和“后台资源部门”之间,实现企业各业务线的“打通”和全域业务能力集成,提高开发和服务效率。但在中台如火如荼之...【详细内容】
2024-03-27  dbaplus社群    Tags:中台   点击:(11)  评论:(0)  加入收藏
员工写了个比删库更可怕的Bug!
想必大家都听说过删库跑路吧,我之前一直把它当一个段子来看。可万万没想到,就在昨天,我们公司的某位员工,竟然写了一个比删库更可怕的 Bug!给大家分享一下(不是公开处刑),希望朋友们...【详细内容】
2024-03-26  dbaplus社群    Tags:Bug   点击:(8)  评论:(0)  加入收藏
我们一起聊聊什么是正向代理和反向代理
从字面意思上看,代理就是代替处理的意思,一个对象有能力代替另一个对象处理某一件事。代理,这个词在我们的日常生活中也不陌生,比如在购物、旅游等场景中,我们经常会委托别人代替...【详细内容】
2024-03-26  萤火架构  微信公众号  Tags:正向代理   点击:(14)  评论:(0)  加入收藏
看一遍就理解:IO模型详解
前言大家好,我是程序员田螺。今天我们一起来学习IO模型。在本文开始前呢,先问问大家几个问题哈~什么是IO呢?什么是阻塞非阻塞IO?什么是同步异步IO?什么是IO多路复用?select/epoll...【详细内容】
2024-03-26  捡田螺的小男孩  微信公众号  Tags:IO模型   点击:(10)  评论:(0)  加入收藏
为什么都说 HashMap 是线程不安全的?
做Java开发的人,应该都用过 HashMap 这种集合。今天就和大家来聊聊,为什么 HashMap 是线程不安全的。1.HashMap 数据结构简单来说,HashMap 基于哈希表实现。它使用键的哈希码来...【详细内容】
2024-03-22  Java技术指北  微信公众号  Tags:HashMap   点击:(12)  评论:(0)  加入收藏
如何从头开始编写LoRA代码,这有一份教程
选自 lightning.ai作者:Sebastian Raschka机器之心编译编辑:陈萍作者表示:在各种有效的 LLM 微调方法中,LoRA 仍然是他的首选。LoRA(Low-Rank Adaptation)作为一种用于微调 LLM(大...【详细内容】
2024-03-21  机器之心Pro    Tags:LoRA   点击:(13)  评论:(0)  加入收藏
这样搭建日志中心,传统的ELK就扔了吧!
最近客户有个新需求,就是想查看网站的访问情况。由于网站没有做google的统计和百度的统计,所以访问情况,只能通过日志查看,通过脚本的形式给客户导出也不太实际,给客户写个简单的...【详细内容】
2024-03-20  dbaplus社群    Tags:日志   点击:(6)  评论:(0)  加入收藏
相关文章
    无相关信息
站内最新
站内热门
站内头条