@GetMapping("/depts")  
	//指定请求方式  
	public Result list(){  
	    System.out.println("查询全部部门数据");  
	    List<Dept> deptList =  deptService.findAll();  
	    return Result.success(deptList);  
	}

@Mapper  
public interface DeptMapper{  
    @Results({  
            @Result(column = "create_time", property = "createTime"),  
            @Result(column = "update_time", property = "updateTime")  
    })  
    @Select("SELECT id, name, create_time, update_time FROM dept ORDER BY update_time DESC")  
    List<Dept> findAll();  
}

	SELECT 
	    id, name, 
	    dept_name AS deptName, -- 数据库是 dept_name，实体类是 deptName
	    create_time AS createTime 
	FROM dept;

	<resultMap id="DeptResultMap" type="com.example.pojo.Dept">
	    <id column="id" property="id" />
	    <result column="name" property="deptName" />
	    <result column="c_time" property="createTime" />
	</resultMap>
	
	<select id="findAll" resultMap="DeptResultMap">
	    SELECT id, name, c_time FROM dept
	</select>

<!--自定义结果集-->  
<resultMap id="empResultMap" type="asia.creat.pojo.Emp">  
    <id column="id" property="id" />  
    <result column="username" property="username" />  
    <result column="name" property="name" />  
    <result column="gender" property="gender" />  
    <result column="phone" property="phone" />  
    <result column="job" property="job" />  
    <result column="salary" property="salary" />  
    <result column="image" property="image" />  
    <result column="entry_date" property="entryDate" />  
    <result column="dept_id" property="deptId" />  
    <result column="create_time" property="createTime" />  
    <result column="update_time" property="updateTime" />  
    <!--封装exprList-->  
    <collection property="exprList" ofType="asia.creat.pojo.EmpExpr">  
        <id column="ee_Id" property="id"/>  
        <result column="ee_company" property="company"/>  
        <result column="ee_job" property="job"/>  
        <result column="ee_begin" property="begin"/>  
        <result column="ee_end" property="end"/>  
        <result column="ee_emp_id" property="empId"/>  
    </collection>
</resultMap>

server{
	listen 90;
	# 省略......
	# ......
	location ^~ /api/{
		# 只要URL 是以 /api/ 开头的请求
		rewrite ^~/api/(.*)$ /$1 break;
		proxy_pass http://localhost:8080; # 代理转发
	}
}

	/*  
	* 基于HttpServetRequest接收前端请求参数，删除部门数据  
	* */  
	@DeleteMapping("/depts")  
	public Result deleteById(HttpServletRequest request){  
	    String idStr = request.getParameter("id");  
	    int id = Integer.parseInt(idStr);  
	    System.out.println("根据ID删除部门:"+id);  
	    return Result.success();  
	}

	@DeleteMapping("/depts")  
	public Result deleteById(@RequestParam("id") Integer deptId){  
	    System.out.println("根据ID删除部门:"+deptId);  
	    return Result.success();  
	}

	@DeleteMapping("/depts")  
	public Result deleteById(Integer id){  
	    System.out.println("根据ID删除部门:"+id);  
	    return Result.success();  
	}

	/*  
	* 分页查询  
	* */  
	@GetMapping  
	public Result page(@RequestParam(defaultValue = "1") Integer page, Integer pageSize){  
	    log.info("分页查询{},{}",page,pageSize);  
	    PageResult<Emp> pageResult = empService.page(page, pageSize);  
	    return Result.success(pageResult);  
	}

Controller:
	@PostMapping("/depts")  
	public Result add(@RequestBody Dept dept){ //将json数据封装到对象  
	    System.out.println("新增部门"+dept);  
	    deptService.add(dept);
	    return Result.success();  
	}
	
Service:
	@Override  
	public void add(Dept dept) {  
	    dept.setCreateTime(LocalDateTime.now());  
	    dept.setUpdateTime(LocalDateTime.now());  
	    deptMapper.add(dept);  
	}
	
Mapper:
	@Insert("INSERT INTO dept (name,create_time,update_time)VALUES (#{name},#{creatTime},#{updateTime})")  
	❗❗❗注意：VALUES后用的是属性名(驼峰命名)而不是字段名(下划线)❗❗❗
	
	void add(Dept dept);

@GetMapping("/depts/{id}")  
public Result getInfo(@PathVariable Integer id){  
	❗❗❗ 如果占位符名称 {id} 和方法参数名 id 一致，可以直接映射❗❗❗
    System.out.println("根据ID查询部门："+ id);  
    return Result.success();  
}

@Data
public class EmpQueryDTO {
    private String name;
    
    // 接收类似 "2024-01-01" 的字符串
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private LocalDate beginDate;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private LocalDate endDate;
}

@GetMapping  
	public Result pageByCondition(String name, Integer gender,  
		  @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,  
		  @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end,  
		...
		...
		return Result.success(result);  
	}

	@Options(useGeneratedKeys = true,keyProperty = "id")
	//获取到生成的主键  
	@Insert("...插入语句...")  
	void insertEmp(Emp emp);

	empService.insertEmp(emp); 
	System.out.println(emp.getId()); // 这里就能打印出数据库生成的那个新 ID 了

	<insert id="insert" useGeneratedKeys="true" keyProperty="id">
	    insert into emp(...) values(...)
	</insert>

@Data  
public class EmpQueryParam {  
    private Integer page = 1;  
    private Integer pageSize = 10;  
    private String name;  
    private Integer gender;  
    @DateTimeFormat(pattern = "yyyy-MM-dd")  
    private String begin;  
    @DateTimeFormat(pattern = "yyyy-MM-dd")  
    private String end;  
}

@RequestMapping("/depts") //指定请求路径前缀  
@RestController
public class DeptController {  
    @Autowired  
    private DeptService deptService;  
	  
    @RequestMapping(value = "/depts",method = RequestMethod.GET)  
    @GetMapping  
    //指定请求方式  
    public Result list(){...}  
	  
    @PostMapping  
    public Result add(@RequestBody Dept dept){...}  
	  
    @DeleteMapping  
    public Result deleteById(Integer id){...}  
	  
    @GetMapping("/{id}")  --> 即为 "/depts/{id}"
    public Result getInfo(@PathVariable Integer id){...}  
	  
	  
    @PutMapping  
    public Result update(@RequestBody Dept dept){...}  
}

	//logger 来自 SLF4j包
	private  static final Logger log =
	 org.slf4j.LoggerFactory.getLogger(LogTest.class);

	<root level="info">
		<appender-ref ref="STDOUT" />
		<appender-ref ref="FILE" />
	</root>

	@Override  
	public PageResult<Emp> page(Integer page, Integer pageSize) {  
	    Long total = empMapper.count();  
	    List<Emp> rows = empMapper.page((page -1)*pageSize, pageSize);  
	    return new PageResult<Emp>(total,rows);  
	}

@Override  
	public PageResult<Emp> page(Integer page, Integer pageSize) {  
	    //设置分页参数PageHelper  
	    PageHelper.startPage(page, pageSize);  
	    //执行查询  
	    List<Emp> emp = empMapper.list(page, pageSize);  
	    //解析查询结果并封装数据  
	    Page<Emp> p = (Page<Emp>) emp;  //多态的实现
	    return new PageResult<Emp>(p.getTotal(), p.getResult());  
	}

@Service
public class EmpServiceImpl implements EmpService {
    @Autowired
    private EmpMapper empMapper;
    @Autowired
    private DeptMapper deptMapper;

    @Transactional // 开启事务
    @Override
    public void deleteDept(Integer id) {
        // 1. 删除部门
        deptMapper.deleteById(id);
        
        // 模拟异常：一旦报错，上面的删除操作也会撤销
        // int i = 1/0; 
        
        // 2. 删除该部门下的所有员工
        empMapper.deleteByDeptId(id);
    }
}

	@Transactional//默认出现运行时异常RuntimeException才会回滚
	@Transactional(rollbackFor = {Exception.class})//指定所有异常都会回滚

@Transactional(readOnly = true)
public User getUserById(Long id) {
    return userRepository.findById(id);
}

	@PostMapping("/upload")  
	public Result upload(String name, Integer age, MultipartFile file){  
	    log.info("接收参数：{},{},{}",name,age,file);  
	    return Result.success();  
	}

	@PostMapping("/upload")  
	public Result upload(String name, Integer age, MultipartFile file) throws IOException {  
	    log.info("接收参数：{},{},{}",name,age,file);  
	    //原始文件名  
	    String fof = file.getOriginalFilename();  
	    //新文件名  
	    String extension = fof.substring(fof.lastIndexOf("."));  
	    String newName = UUID.randomUUID() + extension;  
	    //保存文件  
	    file.transferTo(new File("F:/images/"+ newName));  
	    return Result.success();  
	}

@Value("${aliyun.oss.endpoint}")  
private String endpoint;  
@Value("${aliyun.oss.bucketName}")  
private String bucketName;  
@Value("${aliyun.oss.region}")  
private String region;

@Component  
public  class AliyunOSSOperator {  
    @Autowired  
    private AliyunOSSProperties aliyunOSSProperties;  
	
	
	public String upload(byte[] content, String originalFilename) throws ClientException {
	    String endpoint = aliyunOSSProperties.getEndpoint();  
	    String bucketName = aliyunOSSProperties.getBucketName();  
	    String region = aliyunOSSProperties.getRegion();
	    
	    ......
    }
}

@Data  
@Component  
@ConfigurationProperties(prefix = "aliyun.oss")  
public class AliyunOSSProperties {  
    private String endpoint;  
    private String bucketName;  
    private String region;  
}

@RestControllerAdvice // = @ControllerAdvice + @ResponseBody
public class GlobalExceptionHandler {

    // 处理自定义业务异常
    @ExceptionHandler(BusinessException.class)
    public Result handleBusinessException(BusinessException e) {
        return Result.error(e.getCode(), e.getMessage());
    }

    // 处理参数验证异常 (如 @Valid 校验失败)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result handleValidationException(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldError().getDefaultMessage();
        return Result.error(400, msg);
    }

    // 兜底：处理所有未知的运行异常
    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e) {
        log.error("系统崩溃了，救命！", e); 
        return Result.error(500, "服务器开小差了，请稍后再试");
    }
    ---------------------
	@ExceptionHandler  
	public Result handleException(Exception e) {  
	    log.error("发生异常: ", e);  
	    return Result.error("服务器发生异常，请稍后再试");  
	}  
	@ExceptionHandler  
	public Result handleDuplicateKeyException(DuplicateKeyException e) {  
	    log.error("发生异常: ", e);  
	    String msg = e.getMessage();  
	    int i = msg.indexOf("Duplicate entry");  
	    String errMsg = msg.substring(i);  
	    String[] arr = errMsg.split(" ");  
	  
	    return Result.error("'" + arr[2] + "' 已存在，请检查数据");  
	}
}

	{ "alg": "HS256", "typ": "JWT" }

	{ 
		"sub": "ZhangSan", 
		"role": "Java-Dev", 
		"exp": 1746144000 
	}

private static final String SECRET = "基于base64的字符串（字节数必须大于32）";  
private static final SecretKey KEY = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
  
@Test  
public void testGenerateJwt() {  
    Map<String, Object> dataMap = new HashMap<>();  
    dataMap.put("userId", 1);  
    dataMap.put("username", "admin");  
  
    String token = Jwts.builder()  
            .claims(dataMap)  
            .expiration(new Date(System.currentTimeMillis() + 3600 * 1000))  
            .signWith(KEY)  
            .compact();  
  
    System.out.println(token);  
}  
  
@Test  
public void testParseJwt() {  
    String token = "JWT得到的Token";  
    Claims claims = Jwts.parser()  
            .verifyWith(KEY)  
            .build()  
            .parseSignedClaims(token)  
            .getPayload();  
    System.out.println(claims);  
}

		[浏览器请求]
		    │
		    ▼
		┌────── Filter (去程：校验Token、记录时间) ──────┐
		│   │                                       │
		│   ▼                                       │
		│ ┌──── Controller (解析请求、参数校验) ────┐ │
		│ │   │                                 │ │
		│ │   ▼                                 │ │
		│ │ ┌── Service (业务逻辑处理) ────────┐ │ │
		│ │ │   │                           │ │ │
		│ │ │   ▼                           │ │ │
		│ │ │ ┌ Mapper (SQL执行) ──┐        │ │ │
		│ │ │ │   │                │        │ │ │
		│ │ │ │   ▼                │        │ │ │
		│ │ │ │ [ 数据库 DB ] <────┘        │ │ │
		│ │ │ │   │ (返回结果)               │ │ │
		│ │ │ └────────────────────────────┘ │ │
		│ │ │   │                           │ │ │
		│ │ └── Service (业务结果组装) ────────┘ │ │
		│ │   │                                 │ │
		│ └──── Controller (封装结果对象) ─────────┘ │
		│   │                                       │
		└────── Filter (回程：清理ThreadLocal、日志打印) ┘
		    │
		    ▼
		[返回响应]
//-- 这种图强调了 Filter 是最外层，它包裹着所有的内部组件：--
		( ( ( ( [ 数据库 DB ] ) ) ) )
      ▲   ▲   ▲   ▲     ▲   ▼   ▼   ▼   ▼     ▼
      │   │   │   └─────┴───┘   │   │   │     │
      │   │   └──── Mapper ─────┘   │   │     │
      │   └─────── Service ─────────┘   │     │
      └────────── Controller ───────────┘     │
      └───────────── Filter ──────────────────┘
    [请求进入]                           [响应返回]