public String simpleParam(@RequestParam(name="name")String username,Integer age){
    
}

Java  @Service  
  @Primary  // 当存在多个 EmpService 类型Bean时，优先注入此类  
  public class EmpServiceA implements EmpService {  
      // ...  
  }  

Java  @RestController  
  public class EmpController {  
      @Autowired  
      @Qualifier("empServiceA")  // 明确指定注入名称为 "empServiceA" 的Bean  
      private EmpService empService;  
  }  

Java  @RestController  
  public class EmpController {  
      @Resource(name = "empServiceB")  // 直接指定Bean名称  
      private EmpService empService;  
  }  

@SpringBootTest
class SpringbootMybatisQuickstart1ApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void test1() {
        List<User> userList = userMapper.list();
        userList.stream().forEach(user -> {
            System.out.println(user);
        });
    }

}

// 2. 获取连接对象
String url = "jdbc:mysql://localhost:3306/mybatis";
String username = "root";
String password = "1234";
Connection connection = DriverManager.getConnection(url, username, password);

// 3. 获取执行SQL的对象Statement，执行SQL，返回结果
String sql = "select * from user";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);

// 4. 封装结果数据（封装的结果需要一个字段一个字段来解析）
List<User> userList = new ArrayList<>();
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    short age = resultSet.getShort("age");
    short gender = resultSet.getShort("gender");
    String phone = resultSet.getString("phone");

    User user = new User(id, name, age, gender, phone);
    userList.add(user);
}

Connection getConnection() throws SQLException; // 获取连接

//@Getter
//@setter
//@ToString
//@EqualsAndHashCode
@Data
@NoArgsConstructor//无参构造
@AllArgsConstructorr//全参构造
public class User{
    private Integer id;
	private String name;
	private Short age;
	private Short gender;
	private String phone;
}

@Mapper
public interface EmpMapper{
    //根据ID册除数据
	@Delete("delete from emp where id = #{id)")
	public void delete(Integer id);
}

public int delete(Integer id);

@Select("select *from emp where id = #{id)")
public Emp getByld(Integer id);

Java@Select("select id, username, password, name, gender, image, job, entrydate, " +
        "dept_id deptId, create_time createTime, update_time updateTime " +  // 字段别名与属性名一致
        "from emp where id = #{id}")
public Emp getById(Integer id);

Java@Select("select * from emp where id = #{id}")  // 查询所有字段
@Results({
    @Result(column = "dept_id", property = "deptId"),    // 字段dept_id → 属性deptId
    @Result(column = "create_time", property = "createTime"),  // 字段create_time → 属性createTime
    @Result(column = "update_time", property = "updateTime")   // 字段update_time → 属性updateTime
})
public Emp getById(Integer id);

Properties# 开启驼峰命名自动映射（推荐）
mybatis.configuration.map-underscore-to-camel-case=true

@Select("select * from emp where name like '%${name}%' and gender = #{gender} and entrydate between #{begin} and #{end} order by update_time desc")
public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

@Select("select * from emp where name like concat('%', #{name}, '%') " +  // 使用 concat 拼接 %
        "and gender = #{gender} " + 
        "and entrydate between #{begin} and #{end} " + 
        "order by update_time desc")
public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

@Select("select * from emp where name like concat('%',#{name},'%') and gender = #{gender} and entrydate between #{begin} and #{end} order by update_time desc")
public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

@Select(("select * from emp where name like concat('%',#{name},'%') and gender = #{gender}")
List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

@Select("select * from emp where name like concat('%',#{name},'%') and gender = #{gender} and entrydate between #{begin} and #{end} order by update_time desc")
public List<Emp> list(@Param("name") String name, @Param("gender") Short gender, @Param("begin") LocalDate begin, @Param("end") LocalDate end);

@Select(("select * from emp where name like concat('%',#{name},'%') and gender = #{gender}")
List<Emp> list(String var1, Short var2, LocalDate var3, LocalDate var4);

//传统风格
http://localhost:8080/user/getById?id=1GET：查询id为1的用户
http://localhost:8080/user/saveUserPOST：新增用户
http://localhost:8080/user/updateUserPOST：修改用户
http://localhost:8080/user/deleteUser?id=1GET：删除id为1的用户

//REST风格
//1.URL 定位资源
//2.HTTP动词描述操作
http://localhost:8080/users/1GET：查询id为1的用户
http://localhost:8080/usersPOST：新增用户
http://localhost:8080/usersPUT：修改用户
http://localhost:8080/users/1DELETE：删除id为1的用户

@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.gzgs.controller;

import com.gzgs.pojo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class DeptController {

//    private static Logger log = LoggerFactory.getLogger(DeptController.class);
//    可以直接用slf4j这个注解来输出日志

    @RequestMapping("/depts")
    public Result list(){
        log.info("查询全部部门");
        return Result.success();
    }
}

@RequestMapping(value = "/depts",method = RequestMethod.GET)

//现在可以用
@GetMapping("/depts")

@DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id){
        log.info("删除对应id的部门:{}",id);
        //调用方法
        deptService.delete(id);
        return Result.success();
    }

@Slf4j
@RestController
@RequestMapping("/emps")
public class EmpController {

    @Autowired
    private EmpService empService;

    // @RequestParam(defaultValue = "1")设置默认值
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page, 
                      @RequestParam(defaultValue = "10") Integer pageSize) {
        log.info("分页查询, {}, {}", page, pageSize);
        PageBean pageBean = empService.page(page, pageSize);
        return Result.success(pageBean);
    }
}

//EmpController
@PostMapping
public Result save(@RequestBody Emp emp) {
    empService.save(emp);
    return Result.success();
}

//EmpService
@Override
public void save(Emp emp) {
    // 设置创建时间和更新时间为当前时间
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    empMapper.save(emp); // 调用Mapper层保存数据
}

//EmpMapper
/**
 * 保存员工信息
 */
@Insert("insert into emp " +
        "(username, name, gender, image, job, entrydate, dept_id, create_time, update_time) " +
        "values " +
        "(#{username}, #{name}, #{gender}, #{image}, #{job}, #{entrydate}, #{deptId}, #{createTime}, #{updateTime})")
void save(Emp emp);

String getOriginalFilename(); //获取原始文件名
voidtransferTo（Filedest);//将接收的文件转存到磁盘文件中
long getSize();//获取文件的大小，单位：字节
byte[] getBytes();//获取文件内容的字节数组
InputStream getlnputStream();//获取接收到的文件内容的输入流

@PostMapping("/upload")
public Result upload(MultipartFile image) throws IOException {
    Log.info("上传的文件为: {}", image.getOriginalFilename());
    // 调用工具类上传文件到OSS
    String url = aliOssUtils.upload(image);
    Log.info("文件上传成功: {}", image.getOriginalFilename());
    return Result.success(url);
}

public String upload(MultipartFile file) throws IOException { // IDE提示“0个用法”，可忽略
    // 获取上传文件的输入流（用于读取文件内容）
    InputStream inputStream = file.getInputStream();
    
    // 避免文件覆盖（生成唯一文件名）
    String originalFilename = file.getOriginalFilename(); // 获取原文件名（如：test.jpg）
    String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf(".")); // 唯一文件名（如：550e8400-e29b-41d4-a716-446655440000.jpg）
    
    // 上传文件到OSS（创建客户端→执行上传）
    OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret); // 初始化OSS客户端（需配置端点、AccessKey）
    ossClient.putObject(bucketName, fileName, inputStream); // 上传文件（存储桶名称→文件名→输入流）
    
    // 构造文件访问URL（OSS标准访问格式）
    String[] endpointParts = endpoint.split("://"); // 拆分端点（如：https://oss-cn-hangzhou.aliyuncs.com → ["https", "oss-cn-hangzhou.aliyuncs.com"]）
    String url = endpointParts[0] + "://" + bucketName + "." + endpointParts[1] + "/" + fileName; // 拼接URL（如：https://my-bucket.oss-cn-hangzhou.aliyuncs.com/550e8400-e29b-41d4-a716-446655440000.jpg）
    
    // 关闭OSS客户端（释放资源，避免泄漏）
    ossClient.shutdown();
    
    return url; // 返回上传后的文件访问路径
}

@GetMapping("/{id}")
public Result getById(@PathVariable Integer id) {
    Log.info("根据ID查询员工，ID: {}", id); // 日志记录查询的员工ID
    Emp emp = empService.getById(id); // 调用服务层方法查询员工数据
    return Result.success(emp); // 返回成功响应，包含查询到的员工信息
}

@PostMapping
public Result login(@RequestBody Emp emp) {
    Log.info("登录的员工为: {}", emp); // 记录登录员工的信息（用户名、密码等）
    Emp loginEmp = empService.login(emp); // 调用服务层验证登录
    return loginEmp != null ? Result.success(loginEmp) : Result.error("用户名或密码错误"); // 根据验证结果返回响应
}

@Test
public void parseJwt() {
    // 1. 创建JWT解析器，指定签名密钥（必须与生成令牌时的密钥一致）
    Claims claims = Jwts.parser()
            .setSigningKey("itheima") // 签名密钥（需与生成令牌时的密钥完全一致）
            // 2. 解析JWT令牌（参数为待校验的JWT字符串）
            .parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ0bGlhcyIsImV4cCI6MTY1OTkxNTE3Mywic3ViIjoi6YeR5bq4In0.EUTfeqPkGslekdkBeczcCe7a7xbcllwB1MXllccTMwo")
            // 3. 获取令牌中的Payload（ claims ）
            .getBody();
    
    // 打印解析后的claims（包含令牌中的自定义信息，如用户ID、角色等）
    System.out.println(claims); 
    // 示例输出：{iss=tlias, exp=1659915173, sub=管理员, id=1, username=jinyong}
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(loginCheckInterceptor)  // 注册登录校验拦截器
            .addPathPatterns("/**")                 // **需要拦截的资源**：所有路径（任意级）
            .excludePathPatterns("/login");          // **不需要拦截的资源**：登录路径（放行登录请求）
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper; // 注入部门Mapper，用于操作部门表
    @Autowired
    private EmpMapper empMapper;   // 注入员工Mapper，用于操作员工表

    @Override
    public void delete(Integer id) {
        // 1. 删除部门（根据部门ID删除部门表中的记录）
        deptMapper.delete(id);
        // 2. 删除部门下的员工（根据部门ID删除员工表中的关联记录）
        empMapper.deleteByDeptId(id);
    }
}

public interface EmpMapper {
    /**
     * 根据部门ID，删除该部门下的所有员工数据
     * @param deptId 部门ID
     */
    @Delete("delete from emp where dept_id = #{deptId}")
    void deleteByDeptId(Integer deptId);
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper; // 注入部门Mapper（操作部门表）
    @Autowired
    private EmpMapper empMapper;   // 注入员工Mapper（操作员工表）

    @Override
    public void delete(Integer id) {
        // 1. 删除部门（第一步：删除部门表中的记录）
        deptMapper.delete(id);
        
        // 模拟异常（测试数据一致性问题）：此处会抛出ArithmeticException
        int i = 1 / 0;
        
        // 2. 删除部门下的员工（第二步：根据部门ID删除员工表中的关联记录）
        empMapper.deleteByDeptId(id);
    }
}

public interface EmpMapper {

    /**
     * 根据部门ID删除该部门下的所有员工
     * @param deptId 部门ID
     */
    @Delete("delete from emp where dept_id = #{deptId}")
    void deleteByDeptId(Integer deptId);
}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;
    @Autowired
    private EmpMapper empMapper;

    /**
     * 删除部门及下属员工（事务管理：方法上的@Transactional）
     * 说明：该方法的所有操作（删除部门、删除员工）将作为一个事务处理
     */
    @Override
    @Transactional // 方法上添加@Transactional，控制该方法的事务！！！！！
    public void delete(Integer id) {
        // 1. 删除部门（第一步：成功执行）
        deptMapper.delete(id);
        
        // 模拟异常（第二步：抛出ArithmeticException）
        int i = 1 / 0; // 此处异常会触发事务回滚
        
        // 2. 删除部门下的员工（第三步：不会执行）
        empMapper.deleteByDeptId(id);
    }
}

@Transactional // Spring事务管理（默认仅回滚RuntimeException）
@Override
public void delete(Integer id) throws Exception {
    deptMapper.deleteById(id); // 1. 删除部门数据（成功执行）
    
    // 模拟业务异常（抛出Checked Exception）
    if (true) {
        throw new Exception("出错啦..."); // 2. 抛出Exception（Checked异常，默认不回滚）
    }
    
    empMapper.deleteByDeptId(id); // 3. 删除部门下的员工（未执行）
}

@Transactional(rollbackFor = Exception.class) // 回滚所有异常（包括Checked Exception）
@Override
public void delete(Integer id) throws Exception {
    deptMapper.deleteById(id); // 1. 删除部门
    if (true) {
        throw new Exception("出错啦..."); // 2. 抛出异常（触发回滚）
    }
    empMapper.deleteByDeptId(id); // 3. 未执行
}

@Before("execution(public void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))
public void before(JoinPoint joinPoint)

@Before("@annotation(com.itheima.anno.Log)
public void before() 

@Pointcut("execution(* com.itheima.service.DeptService.list()) || " +
		"execution(* com.itheima.service.DeptService.delete(java.lang.Integer)) ")
private void pt(){}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {
    
}

@annotation(com.itheima.anno.Log)

@Before("@annotation(com.itheima.anno.Log)")
public void before(){
	log.info("before ...);
}

@Around("pt()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    log.info("MyAspect8 around before ...");
    
    // 1. 获取目标对象的类名
    String className = joinPoint.getTarget().getClass().getName();
    log.info("目标对象的类名:{}", className);
    
    // 2. 获取目标方法的方法名
    String methodName = joinPoint.getSignature().getName();
    log.info("目标方法的方法名：{}", methodName);
    
    // 3. 获取目标方法运行时传入的参数
    Object[] args = joinPoint.getArgs();
    log.info("目标方法运行时传入的参数：{}", Arrays.toString(args));
    
    // 4. 放行目标方法执行
    Object result = joinPoint.proceed();
    
    // 5. 获取目标方法运行的返回值
    log.info("目标方法运行的返回值：{}", result);
    
    log.info("MyAspect8 around after ...");
    return null;
}

// 根据Bean的名称（"deptController"）获取，需手动类型转换  
DeptController bean1 = (DeptController) applicationContext.getBean("deptController");  
System.out.println(bean1);  

// 根据Bean的类型（DeptController.class）获取，自动类型转换  
DeptController bean2 = applicationContext.getBean(DeptController.class);  
System.out.println(bean2);  

// 根据Bean的名称（"deptController"）和类型（DeptController.class）获取，无需手动转换  
DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);  
System.out.println(bean3);  

@Scope("prototype")  
@RestController  
@RequestMapping("/depts")  
public class DeptController {  

}  

@Autowired
private SAXReader saxReader;

@Bean  
@ConditionalOnClass(name = "io.jsonwebtoken.Jwts") // 当前环境存在指定类时，才声明该bean  
public HeaderParser headerParser(){...}  

@Bean  
@ConditionalOnMissingBean // 当不存在当前类型的bean时，才声明该bean  
public HeaderParser headerParser(){...}  

@Bean  
@ConditionalOnProperty(name = "name", havingValue = "itheima") // 配置文件中存在对应属性和值时，才注册bean  
public HeaderParser headerParser(){...}