nest，java对比 - 技术栈

同一个查询用户列表接口

左边：Nest.js 写法
右边：Java (SpringBoot + RuoYi 风格) 写法每层结构完全对应，你一眼就能看懂两套架构。

先给你终极结论（背会）

Nest 架构 ↔ SpringBoot (Java) 架构

Controller ↔ Controller
Service ↔ Service
Repository ↔ Mapper
Entity ↔ Domain
DTO ↔ DTO

层数一模一样、思想一模一样、只是语法不一样！

一、Nest.js 完整查询接口

1. DTO（接收前端参数）

user.dto.ts

复制代码

export class UserListDto {
  username: string;
  page: number;
  size: number;
}

2. Entity（对应数据库表）

user.entity.ts

复制代码

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  password: string;
}

3. Repository（数据库操作）

复制代码

@Injectable()
export class UserRepository extends Repository<User> {}

4. Service（业务逻辑）

复制代码

@Injectable()
export class UserService {
  constructor(private userRepository: UserRepository) {}

  async list(dto: UserListDto) {
    // 查询数据库
    return this.userRepository.find({
      where: { username: dto.username }
    });
  }
}

5. Controller（接口入口）

复制代码

@Controller('user')
export class UserController {
  constructor(private userService: UserService) {}

  @Get('list')
  list(@Query() dto: UserListDto) {
    return this.userService.list(dto);
  }
}

二、Java (SpringBoot) 完整查询接口

1. DTO（接收前端参数）

SysUserDto.java

复制代码

public class SysUserDto {
    private String username;
    private Integer page;
    private Integer size;
    // get set
}

2. Domain（对应数据库表）

SysUser.java

复制代码

public class SysUser {
    private Long id;
    private String username;
    private String password;
    // get set
}

3. Mapper（数据库操作）

SysUserMapper.java

复制代码

public interface SysUserMapper {
    List<SysUser> selectUserList(SysUserDto dto);
}

4. Service（业务逻辑）

SysUserServiceImpl.java

复制代码

@Service
public class SysUserServiceImpl implements SysUserService {

    @Autowired
    private SysUserMapper userMapper;

    @Override
    public List<SysUser> list(SysUserDto dto) {
        return userMapper.selectUserList(dto);
    }
}

5. Controller（接口入口）

SysUserController.java

复制代码

@RestController
@RequestMapping("/user")
public class SysUserController {

    @Autowired
    private SysUserService userService;

    @GetMapping("/list")
    public List<SysUser> list(SysUserDto dto) {
        return userService.list(dto);
    }
}

三、最清晰的分层对比表（一看就懂）

表格

层级	Nest.js	Java (SpringBoot)	作用
接口层	Controller	Controller	接收请求、返回结果
业务层	Service	Service	写业务逻辑、调数据库
数据层	Repository	Mapper	执行 SQL、操作数据库
实体层	Entity	Domain	对应表结构、装数据
参数层	DTO	DTO	接收前端参数

四、一句话总结

Nest 和 SpringBoot 架构完全一样！

都是 Controller → Service → 数据操作 → 数据库
都是 分层架构
都是 面向对象 + 依赖注入
只有语法不一样，思想 100% 相同

而且对应关系非常精准，我给你用最直白的方式对应一遍，你马上就能彻底打通 Java（RuoYi）和 Nest.js 的思维！

终极对应关系（1:1 完全匹配）

Java（RuoYi） ↔ Nest.js

Domain（实体） ↔ Entity（实体） Mapper（数据操作） ↔ Repository（仓库）

那你说的 DTO 对应什么？

你提到的 DTO 在 Nest 里是前端传参校验它在 RuoYi/Java 里对应的是：

Vo / Dto（前端入参对象）

不是 Domain！不是 Domain！

我给你画一张最清晰对照表

1. Domain = Entity

作用一模一样：

对应数据库表
定义字段结构
用来存数据库数据

// Java Domain
public class SysUser {
private Long id;
private String username;
}

// Nest Entity
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
复制代码
```
@Column()
username: string;
```
}

✅ 完全一样：数据库映射对象

2. Mapper = Repository

作用一模一样：

操作数据库
增删改查
把数据存入 Entity / Domain

// Java Mapper
public interface SysUserMapper {
List<SysUser> selectList();
}

// Nest Repository
@Injectable()
export class UserService {
constructor(
@InjectRepository(User)
private userRepository: Repository<User>,
) {}
复制代码
```
findAll() {
  return this.userRepository.find();
}
```
}

✅ 完全一样：数据库操作工具

3. DTO（Nest）= Java 中的 DTO/VO

DTO 不对应 Domain，也不对应 Mapper DTO 是前端传进来的参数，只做校验、接收参数。

复制代码

// Nest DTO
export class CreateUserDto {
  @IsString()
  username: string;
}

// Java DTO（RuoYi 里也大量用）
public class SysUserDto {
    private String username;
}

✅ 作用一模一样：接收前端参数 + 校验

最终终极总结（背会就通了）

Java（RuoYi） ↔ Nest.js

Domain = Entity（数据库表结构）
Mapper = Repository（操作数据库）
DTO/VO = DTO（接收前端参数）

一句话秒懂

Domain/Entity：管数据长啥样
Mapper/Repository：管怎么存、怎么取
DTO：管前端传什么参数