@controller/@service @autowired java中

@injectabled constructor nest中

一、Java SpringBoot 依赖注入示例

用到注解：@Controller、@Service、@Autowired、构造器注入

1. Mapper / 底层依赖

import org.springframework.stereotype.Repository;

@Repository
public class UserMapper {
    public String getUserInfo() {
        return "用户数据";
    }
}

2. Service 层

import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;

@Service
public class UserService {
    private final UserMapper userMapper;

    // 构造器注入，多构造器时可加@Autowired，单构造器可省略
    @Autowired
    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    public String getUser() {
        return userMapper.getUserInfo();
    }
}

3. Controller 层

import org.springframework.stereotype.Controller;
import org.springframework.beans.factory.annotation.Autowired;

@Controller
public class UserController {
    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void hello() {
        System.out.println(userService.getUser());
    }
}

✅ 原理@Service/@Controller 将类交给 Spring IoC 容器管理 → 启动扫描生成 Bean → @Autowired 构造器自动注入依赖。💡 推荐写法：使用 final 修饰依赖，单构造器可省略 @Autowired。

---

二、NestJS 依赖注入示例

用到注解：@Controller()、@Injectable()、constructor⚠️ Nest 没有 @Autowired，只靠构造器注入

1. 服务 Service

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  getUserInfo(): string {
    return 'Nest 用户数据';
  }
}

2. 控制器 Controller

import { Controller } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  // 构造器直接注入，无需任何额外注解
  constructor(private readonly userService: UserService) {}

  getUser() {
    return this.userService.getUserInfo();
  }
}

3. 模块关联（必要，Nest 需注册提供者）

import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';

@Module({
  controllers: [UserController],
  providers: [UserService]
})
export class UserModule {}

✅ 原理@Injectable() 标记为可注入提供者 → 模块 providers 注册 → Nest IoC 容器通过构造器自动实例化并注入依赖。

---

三、核心对比小结

框架	标识 Bean 注解	注入方式	是否用 @Autowired
Spring	@Service/@Controller	构造器 / 字段 /setter	是
Nest	@Injectable()/@Controller()	仅构造器	否

同一个查询用户列表接口

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

---

先给你终极结论（背会）

Nest 架构 ↔ SpringBoot (Java) 架构

1. Controller ↔ Controller
2. Service ↔ Service
3. Repository ↔ Mapper
4. Entity ↔ Domain
5. 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，也不对应 MapperDTO 是前端传进来的参数，只做校验、接收参数。

// 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：管前端传什么参数

springBoot

一、层级调用执行顺序（请求过来的真实流转）

请求 → Controller → Service → Mapper → XML → DB DataEntity 是贯穿全程的数据实体载体，各层都能使用，不参与调用链路。

流转拆解：

1. Controller：接收前端请求，调用 Service
2. Service：处理业务逻辑，调用 Mapper
3. Mapper：MyBatis 接口，定义数据库方法
4. XML：Mapper 对应的 SQL 映射文件，编写具体 SQL
5. DB Data：数据库真实数据
6. Entity：封装数据库字段，全程用来传参、返参

二、项目目录摆放常规顺序

entity
mapper
xml
service
controller

三、各层职责一句话分清

• Entity：实体类，和数据库表字段一一对应
• Mapper：DAO 层接口，声明增删改查抽象方法
• XML：MyBatis 映射文件，书写对应 SQL 语句
• Service：业务层，编写业务逻辑、事务控制
• Controller：接口层，接收请求、组装返回结果

四、完整调用示例链路

Controller → Service → Mapper 接口 → XML 执行 SQL → 查询 DB 数据 → 逐层封装 Entity 返回

五、补充规范

1. 禁止 Controller 直接调用 Mapper，业务逻辑必须写在 Service 层
2. Entity 只做数据承载，不写业务逻辑
3. SQL 统一维护在 XML 中，方便后续优化排查
4. 事务注解@Transactional加在 Service 层方法上