简单的springboot项目

传参方式

URL 传参

URL 传参的两种常见方式是通过查询参数和路径参数。

查询参数：

查询参数是通过在 URL 后面使用 ? 字符，然后以 key=value 的形式添加到 URL 中。多个查询参数之间使用 & 符号分隔。例如：https://example.com/api?name=John&age=30。
在前端，可以使用 JavaScript 的 window.location.search 或者 URLSearchParams API 来获取和解析查询参数的值。

路径参数：

路径参数是将参数直接嵌入到 URL 的路径中。通常使用占位符的形式表示，并用实际的值替换占位符部分。例如：https://example.com/api/users/{userId}。
在前端，可以通过路由配置来定义带有参数的路径，并使用框架或库提供的方法来解析路径参数的值。例如，在 Vue.js 中可以使用 Vue Router 的动态路由来处理路径参数。

这两种方式在前端开发中都很常见，具体使用哪种方式取决于你的需求和项目的设计。查询参数适合传递可选的、不敏感的参数，而路径参数适合传递必需的、敏感的参数。

实例

查询参数用@RequestBody接收
在controller层不需要规定路径

@GetMapping
    public Result queryEmpsByPage(@RequestParam("name") String name,
                                  @RequestParam(value = "gender", defaultValue = "0") Integer gender,
                                  @RequestParam("begin") String begin, @RequestParam("end") String end,
                                  @RequestParam(value = "page", defaultValue = "1") Integer page,
                                  @RequestParam(value = "pageSize", defaultValue = "5") Integer pageSize) {

        return empService.queryEmpsByPage(name, gender, begin, end, page, pageSize);
    }

路径参数用@PathVariable接收
@PathVariable 路径传参
在controller层要规定路径

 @DeleteMapping("/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        empService.delete(ids);
        return Result.success();
    }

对应的xml文件代码如下，动态sql

<delete id="deteleByIfs">
        delete from emp where id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>

在测试的时候直接把参数拼在路径上

HTTP 请求体

在 HTTP 请求体中发送附加的数据。这种方式通常用于向后端发送较长或复杂的数据，例如 JSON 数据或文件上传。在前端可以使用 XMLHttpRequest 对象或 fetch API 发送 HTTP 请求，在后端可以使用对应的框架或库解析请求体并获取数据。

@RequestParam和@Param的区别

@RequestParam 和 @Param 是两个不同的注解，它们在不同的框架或库中使用，并有不同的含义和用途。

1. @RequestParam：
   @RequestParam 注解通常用于后端框架（如Spring MVC）中，用于从 HTTP 请求中获取查询参数或表单字段的值。它可以指定参数的名称、是否是必需的、默认值等属性。在Spring MVC中，可以通过该注解将请求参数绑定到方法的参数上。

   示例：

   @GetMapping("/example")
   public String exampleMethod(@RequestParam("name") String paramName) {
       // 方法逻辑
       return "result";
   }
   

   在这个示例中，@RequestParam("name") 表示要从 HTTP 请求中获取名为 “name” 的查询参数，并将其值绑定到 paramName 这个方法参数上。

2. @Param：
   @Param 注解通常用于一些 ORM 框架中，如MyBatis，用于指定数据库查询中的参数。它通常用于动态构建SQL查询语句时，指定参数的名称或别名。在MyBatis中，可以通过 @Param 注解给参数起一个名称，以便在XML映射文件中引用。

   示例：

   List<User> getUsersByNameAndAge(@Param("name") String name, @Param("age") int age);
   

   在这个示例中，@Param("name") 和 @Param("age") 分别指定了两个方法参数的名称，在对应的XML映射文件中可以通过这些名称来引用这些参数。

总结来说，@RequestParam 注解是用于后端框架中获取HTTP请求参数的值，而 @Param 注解则是用于ORM框架中指定SQL查询参数的名称。它们在不同的上下文中使用，具有不同的含义和功能。

三层架构

在经典的三层架构中，service层、mapper层和controller层分别表示三个逻辑层次：

1. service层：业务逻辑层，负责处理具体的业务逻辑，是业务逻辑的实现层。它通常与DAO层（或mapper层）和controller层打交道，接收请求，组织数据，调用DAO层进行数据库操作，最后将结果返回给调用者。

2. mapper层（或DAO层）：数据访问层，负责与数据库进行交互，执行SQL语句，进行数据的读取、写入和修改等操作。这一层把数据库的操作封装成方法，供service层调用，让service层更专注于业务逻辑的处理。

3. controller层：表示层，负责接收用户的请求，并将请求转发给service层进行处理，最后将处理结果返回给客户端。它通常是Web应用程序中的MVC框架中的控制器部分，负责处理HTTP请求、验证用户输入、调用service层处理业务逻辑等操作。

总之，service层、mapper层和controller层是三个不同的逻辑层，各自负责不同的任务。其中，service层处理具体的业务逻辑，mapper层与数据库进行交互，controller层负责接收请求和返回响应。它们之间通过定义清晰的接口和交互方式来实现松耦合的架构。
举一个简单的例子理解三层架构，以
当前端传过来请求时，controller层也就是表示层直接与前端交互，该层也接收从前端传过来的参数
以对部门操作为例

表示层

package com.example.xh.controller;

import com.example.xh.entity.Dept;
import com.example.xh.vo.Result;
import com.example.xh.service.DeptService;
import com.example.xh.vo.UpdateDeptVo;
import jakarta.annotation.Resource;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Objects;
//要有注解，表示这是一个controller层
@RestController
//该层可能有好几个类，怎么表示应该进入这个类？用路径表示
@RequestMapping("/depts")
public class DeptController {
    //service层注入controller层，controller层调用service层的方法
    @Resource
    private DeptService deptService;
    //查询 这里通过指明发起请求的方式来判定进入哪个方法
    @GetMapping
    public Result queryAllDepts(){
        List<Dept> depts = deptService.queryAllDepts();//直接调用service的方法
        return Result.success(depts);//controller层返回的是一个结果类
        //里面包含了请求是否成功，以及如果是请求数据，会把数据传过去
    }
    //更新
    @PutMapping
    public Result updateDept(@RequestBody UpdateDeptVo vo){
        //@RequestBody注释表示接收来自前端的传参，如果是json传参，需要用@RequestBody表示
        //检查传参是否正确可以在controller层做
        if(Objects.isNull(vo.getId())){
            return  Result.error("id不能为空");
        }
        if(StringUtils.isEmpty(vo.getName())){
            return  Result.error("Name不能为空");
        }
        //直接调用service的方法
        int i = deptService.updateDept(vo.getId(),vo.getName());
        return i>0?Result.success():Result.error("更新失败");
    }
    //插入
    @PostMapping
    public  Result insertDept(@RequestBody UpdateDeptVo vo){
        //检查传参是否正确
        if(StringUtils.isEmpty(vo.getName())){
            return  Result.error("Name不能为空");
        }
        return deptService.insertDept(vo.getName());
    }
    //删除
    @DeleteMapping("/{id}")
    //当使用url传参中的路径传参时，采用@PathVariable接收参数
    //@PathVariable("id") int Id表示将前端传过来的id与后端的Id绑定
    public Result deleteById(@PathVariable("id") int id){
           int i = deptService.deleteById(id);
           return i>0?Result.success():Result.error("删除失败");
    }
}

Result的封装

这里是返回给前端的数据，一般是前后端进行协调，什么样的返回代表什么样的含义

package com.example.xh.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//自动产生get和set方法
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Integer code;//响应码，1 代表成功; 0 代表失败
    private String msg;  //响应信息 描述字符串
    private Object data; //返回的数据

    //增删改 成功响应
    public static Result success(){
        return new Result(1,"success",null);
    }
    //查询 成功响应
    public static Result success(Object data){
        return new Result(1,"success",data);
    }
    //失败响应
    public static Result error(String msg){
        return new Result(0,msg,null);
    }
}

表示层接收完消息后，并进行简单的参数验证后，调用服务层的函数实现对应的功能，那么主要的操作要放在服务层。服务层一般有两种类，接口类和接口的实现类，降低代码的耦合。
接口类

package com.example.xh.service;

import com.example.xh.entity.Dept;
import com.example.xh.vo.Result;

import java.util.List;

public interface DeptService {
    List<Dept> queryAllDepts();
    int updateDept(int id,String name);
    Result insertDept(String name);
    int deleteById(int id);
}

接口的实现类

package com.example.xh.service.impl;

import com.example.xh.entity.Emp;
import com.example.xh.mapper.EmpMapper;
import com.example.xh.service.EmpService;
import com.example.xh.vo.PageVo;
import com.example.xh.vo.Result;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;

//业务层
@Service
public class EmpServiceImp implements EmpService {
    @Resource
    private EmpMapper empMapper;
    @Override
    public Result queryEmpsByPage(String name, Integer gender, String begin, String end, Integer page, Integer pageSize) {
        //开启分页
        Page<Object> objects = PageHelper.startPage(page,pageSize);
        //查询数据
        List<Emp> emps = empMapper.queryEmpsByPage(name, gender, begin, end, page, pageSize);
        //查询出的数据放置在pagevo里
        PageVo<Emp> pageVo = new PageVo<>();
        pageVo.setRows(emps);
        pageVo.setTotal(objects.getTotal());
        //把page对象放在result里
        return Result.success(pageVo);
    }

    @Override
    public void delete(List<Integer> ids) {
        empMapper.deteleByIfs(ids);
    }

    @Override
    public Result save(Emp emp) {
        //检查某些操作是否合法，放在服务层里去做
        Emp emp1 = empMapper.selectEmpByName(emp.getUsername());
        if(Objects.nonNull(emp1)){
            return Result.error("用户名"+emp.getUsername()+"重复");
        }
        //需要新添加一些内容，也放在服务层里去做，dao层就是对数据库操作，其它不用管
        emp.setUpdateTime(LocalDateTime.now());
        emp.setCreateTime(LocalDateTime.now());
        int i =  empMapper.insertEmp(emp);
        return i>0?Result.success():Result.error("添加失败");
    }

    @Override
    public Emp findById(Integer id) {
        return  empMapper.findById(id);
    }

    @Override
    public Result update(Emp emp) {
        Emp emp2 = empMapper.findById(emp.getId());
        //修改的用户名和以前的用户名不相同，就检查新用户名是不是合法的，即不重复
        if(!emp2.getUsername().equals(emp.getUsername())){
            Emp emp1 = empMapper.selectEmpByName(emp.getUsername());
            if(Objects.nonNull(emp1)){
                return Result.error("用户名"+emp.getUsername()+"重复");
            }
        }
        emp.setUpdateTime(LocalDateTime.now());
        int i =  empMapper.update(emp);
        return i>0?Result.success("更新成功"):Result.error("更新失败");
    }
}

最后就是Dao层，基本是写sql语句

package com.example.xh.mapper;

import com.example.xh.entity.Dept;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface DeptMapper {
    //查询
    @Select("select id,name,update_time from dept")
    List<Dept> queryAllDepts();
    //根据姓名查询  用在插入，当插入相同名字部门时显示插入错误
    @Select("select * from dept where name = #{name}")
    Dept selectDeptByName(@Param("name") String name);
    //@Param("name") String Name 将后端的Name与数据库里的name绑定
    //更新
    @Update("update dept set name=#{name},update_time=now() where id=#{id}")
    int updateDept(@Param("id") int id,@Param("name") String name);
    //插入 测试成功
    @Insert("insert into dept(name,create_time,update_time) values (#{name},now(),now())")
    int insertDept(@Param("name") String name);
    //删除 测试成功
    @Delete("delete from dept where id = #{id}")
    int deleteById(@Param("id") int id);
}