JavaWeb后端开发：SpringBoot案例

package com.itheima.pojo;
//部门实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept {
    private Integer id; //ID
    private String name; //部门名称
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间
}

package com.itheima.pojo;
//员工实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Emp {
    private Integer id; //ID
    private String username; //用户名
    private String password; //密码
    private String name; //姓名
    private Short gender; //性别 , 1 男, 2 女
    private String image; //图像url
    private Short job; //职位 , 1 班主任 , 2 讲师 , 3 学工主管 , 4 教研主管 , 5 咨询师
    private LocalDate entrydate; //入职日期
    private Integer deptId; //部门ID
    private LocalDateTime createTime; //创建时间
    private LocalDateTime updateTime; //修改时间
}

package com.itheima.pojo;

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

@Slf4j
@RestController
public class DeptController {
    @Autowired
    private DeptService deptService;

    //private static Logger log = LoggerFactory.getLogger(DeptController.class);
    //定义log变量，或者使用@Slf4j注解

    //@RequestMapping(value = "/depts", method = RequestMethod.GET)//指定请求方式为GET
    @GetMapping("/depts")
    public Result depts() {
        log.info("查询全部部门数据");
        List<Dept> deptList = deptService.list();
        return Result.success(deptList);
    }
}

package com.itheima.service;

public interface DeptService {
    //查询全部部门数据
    List<Dept> list();
}

package com.itheima.service.impl;

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {
        return deptMapper.list();
    }
}

package com.itheima.mapper;

@Mapper
public interface DeptMapper {
    //查询全部部门数据
    @Select("select * from dept")
    List<Dept> list();
}

//DeptController
//删除部门
@DeleteMapping("depts/{id}")
public Result delete(@PathVariable Integer id) {
    log.info("根据id删除部门：{}", id);
    deptService.delete(id);
    return Result.success();
}

//DeptService
//删除部门
void delete(Integer id);

//DeptServiceImpl
//删除部门
@Override
public void delete(Integer id) {
    deptMapper.deleteById(id);
}

//DeptMapper
//删除部门
@Delete("delete from dept where id = #{id}")
void deleteById(Integer id);

//DeptController
//新增部门
@PostMapping("depts")
public Result add(@RequestBody Dept dept) {
    log.info("新增部门：{}", dept);
    deptService.add(dept);
    return Result.success();
}

//DeptService
//新增部门
void add(Dept dept);

//DeptServiceImpl
//新增部门
@Override
public void add(Dept dept) {
    dept.setCreateTime(LocalDateTime.now());
    dept.setUpdateTime(LocalDateTime.now());
    deptMapper.insert(dept);
}

//DeptMapper
//新增部门
@Insert("insert into dept(name, create_time, update_time) values (#{name}, #{createTime}, #{updateTime})")
void insert(Dept dept);

//DeptController
//根据ID查询部门
@GetMapping("depts/{id}")
public Result get(@PathVariable Integer id) {
    log.info("根据ID查询：{}", id);
    Dept dept = deptService.get(id);
    return Result.success(dept);
}

//DeptService
//根据ID查询部门
Dept get(Integer id);

//DeptServiceImpl
//根据ID查询部门
@Override
public Dept get(Integer id) {
    Dept dept = deptMapper.getById(id);
    return dept;
}

//DeptMapper
//根据ID查询部门
@Select("select * from dept where id = #{id}")
Dept getById(Integer id);

//DeptController
//修改部门
@PutMapping("depts")
public Result update(@RequestBody Dept dept) {
    log.info("修改部门：{}", dept);
    deptService.update(dept);
    return Result.success();
}

//DeptService
//修改部门
void update(Dept dept);

//DeptServiceImpl
//修改部门
@Override
public void update(Dept dept) {
    Dept dept_new = get(dept.getId());
    dept_new.setName(dept.getName());
    dept_new.setUpdateTime(LocalDateTime.now());
    deptMapper.update(dept_new);
}

//DeptMapper
//修改部门
@Update("update dept set name = #{name}, update_time = #{updateTime} where id = #{id}")
void update(Dept dept1);

package com.itheima.pojo;

//分页查询结果封装类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageBean {
    private long total;//总记录数
    private List rows;//数据列表，这里的List不写泛型，因为开发中不一定传的是emp，还可以是其他类
}

package com.itheima.controller;

@Slf4j
@RestController
public class EmpController {
    @Autowired
    private EmpService empService;

    //分页查询
    @GetMapping("emps")
    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);
    }
}

package com.itheima.service;

public interface EmpService {
    //分页查询
    PageBean page(Integer page, Integer pageSize);
}

package com.itheima.service.impl;

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

    @Override
    public PageBean page(Integer page, Integer pageSize) {//分页查询
        //1.获取总记录数
        Long count = empMapper.count();

        //2.根据分页查询结果列表
        Integer start = (page - 1) * pageSize;
        List<Emp> empList = empMapper.page(start, pageSize);

        //3.封装PageBean对象
        PageBean pageBean = new PageBean(count, empList);
        return pageBean;
    }
}

package com.itheima.mapper;

@Mapper
public interface EmpMapper {
    //查询总记录数
    @Select("select count(*) from emp")
    public Long count();

    //分页查询，获取列表数据
    @Select("select * from emp limit #{start}, #{pageSize}")
    public List<Emp> page(Integer start, Integer pageSize);
}

//EmpServiceImpl
//使用PageHelper实现员工信息查询
@Override
public PageBean page(Integer page, Integer pageSize) {
    //1.设置分页参数
    PageHelper.startPage(page, pageSize);

    //2.执行查询
    List<Emp> empList = empMapper.list();
    Page<Emp> p = (Page<Emp>) empList;

    //3.封装PageBean对象
    PageBean pageBean = new PageBean(p.getTotal(), p.getResult());
    return pageBean;
}

//EmpMapper
//员工信息查询
@Select("select * from emp")
public List<Emp> list();

//EmpController
//条件分页查询：在原来分页查询的基础上增加了查询条件参数
@GetMapping("emps")
public Result page(@RequestParam(defaultValue = "1") Integer page,
                   @RequestParam(defaultValue = "10") Integer pageSize,
                   String name, Short gender,
                   @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,
                   @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end) {
    log.info("分页查询，参数：{}，{}，{}，：{}，{}，{}", page, pageSize, name, gender, begin, end);
    PageBean pageBean = empService.page(page, pageSize, name, gender, begin, end);
    return Result.success(pageBean);
}

//EmpService
//条件分页查询：在原来分页查询的基础上增加了查询条件参数
PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end);

//EmpServiceImpl
//条件分页查询：在原来分页查询的基础上增加了查询条件参数
@Override
public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {
    //1.设置分页参数
    PageHelper.startPage(page, pageSize);

    //2.执行查询
    List<Emp> empList = empMapper.list(name, gender, begin, end);
    Page<Emp> p = (Page<Emp>) empList;

    //3.封装PageBean对象
    PageBean pageBean = new PageBean(p.getTotal(), p.getResult());
    return pageBean;
}

//EmpMapper
//条件分页查询：在原来分页查询的基础上增加了查询条件参数
//要使用if判断条件，所以使用动态SQL，用XML映射
public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);

//EmpController
//批量删除员工，传入的多个id用逗号分隔，可以被识别为数组
@DeleteMapping("emps/{ids}")
public Result delete(@PathVariable() List<Integer> ids) {
    log.info("批量删除操作，ids = {}", ids);
    empService.delete(ids);
    return Result.success();
}

//EmpService
//批量删除员工
void delete(List<Integer> ids);

//EmpServiceImpl
//批量删除员工
@Override
public void delete(List<Integer> ids) {
    empMapper.delete(ids);
}

//EmpMapper
//批量删除员工
void delete(List<Integer> ids);

//EmpController
//新增员工
@PostMapping("emps")
public Result save(@RequestBody Emp emp) {
    log.info("新增员工，emp：{}", emp);
    empService.save(emp);
    return Result.success();
}

//EmpService
//新增员工
void save(Emp emp);

//EmpServiceImpl
//新增员工
@Override
public void save(Emp emp) {
    emp.setCreateTime(LocalDateTime.now());
    emp.setUpdateTime(LocalDateTime.now());
    empMapper.insert(emp);
}

//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 insert(Emp emp);

//EmpController
//根据ID查询员工
@GetMapping("emps/{id}")
public Result getById(@PathVariable() Integer id) {
    log.info("根据id查询员工信息，id：{}", id);
    Emp emp = empService.getById(id);
    return Result.success(emp);
}

//EmpService
//根据ID查询员工
Emp getById(Integer id);

//EmpServiceImpl
//根据ID查询员工
@Override
public Emp getById(Integer id) {
    Emp emp = empMapper.getById(id);
    return emp;
}

//EmpMapper
//根据ID查询员工
@Select("select * from emp where id = #{id}")
Emp getById(Integer id);

//EmpController
//更新员工
@PutMapping("emps")
public Result update(@RequestBody Emp emp) {
    log.info("更新员工信息：{}", emp);
    empService.update(emp);
    return Result.success();
}

//EmpService
//更新员工
void update(Emp emp);

//EmpServiceImpl
//更新员工
@Override
public void update(Emp emp) {
    emp.setUpdateTime(LocalDateTime.now());
    empMapper.update(emp);
}

//EmpMapper
//更新员工
void update(Emp emp);

package com.itheima.controller;

@Slf4j
@RestController
public class UploadController {
    @PostMapping("/upload") //和前端的action字段一致
    public Result upload(String username, Integer age, MultipartFile image) {
        log.info("文件上次：{}，{}，{}", username, age, image);
        return Result.success();
    }
}

package com.itheima.controller;

@Slf4j
@RestController
public class UploadController {
    @PostMapping("/upload") //和前端的action字段一致
    public Result upload(String username, Integer age, MultipartFile image) throws Exception {
        log.info("文件上次：{}，{}，{}", username, age, image);

        //获取原始文件名
        String originalFilename = image.getOriginalFilename();

        //构造唯一的文件名（不能重复）--uuid（通用唯一识别码）
        int index = originalFilename.lastIndexOf(".");
        String extname = originalFilename.substring(index);//获取文件后缀
        String newFileName = UUID.randomUUID().toString() + extname;
        log.info("新的文件名：{}", newFileName);

        //将文件存储在服务器的磁盘目录中：我存在了resources的static目录下的images文件夹中
        image.transferTo(new File("E:/2_学习/JavaWeb/code/itheima_web_project/springboot-web-tlias/src/main/resources/static/images/"+ newFileName));

        return Result.success();
    }
}

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

package com.itheima;

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;
import java.io.FileInputStream;
import java.io.InputStream;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "srr-web-tlias";
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。
        String objectName = "1.jpg";
        // 填写本地文件的完整路径，例如D:\\localpath\\examplefile.txt。
        // 如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件流。
        String filePath= "E:/2_学习/JavaWeb/code/itheima_web_project/springboot-web-tlias/src/main/resources/static/images/Space02-Default.jpg";
        // 填写Bucket所在地域。以华东1（杭州）为例，Region填写为cn-hangzhou。
        String region = "cn-hangzhou";

        // 创建OSSClient实例。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            InputStream inputStream = new FileInputStream(filePath);
            // 创建PutObjectRequest对象。
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, objectName, inputStream);
            // 创建PutObject请求。
            PutObjectResult result = ossClient.putObject(putObjectRequest);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
} 

package com.itheima.utils;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.UUID;

/**
 * 阿里云 OSS 工具类
 */
@Component
public class AliOSSUtils {

    private String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
    private String accessKeyId = "LTAI5tK5ZM5yGVVFWvKxeNqJ";
    private String accessKeySecret = "";
    private String bucketName = "srr-web-tlias";

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile file) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = file.getInputStream();

        // 避免文件覆盖
        String originalFilename = file.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }

}

package com.itheima.controller;

@Slf4j
@RestController
public class UploadController {
    @Autowired
    private AliOSSUtils aliOSSUtils;

    @PostMapping("upload")
    public Result upload(MultipartFile image) throws IOException {
        log.info("文件上传，文件名：{}", image.getOriginalFilename());
        //调用阿里云OSS工具类进行文件上传
        String url = aliOSSUtils.upload(image);
        log.info("文件上传完成，文件访问的url:{}", url);
        return Result.success(url);
    }
}

@Component
public class AliOSSUtils {
    @Value("${aliyun.oss.endpoint}")
    private String endpoint;
    @Value("${aliyun.oss.accessKeyId}")
    private String accessKeyId;
    @Value("${aliyun.oss.accessKeySecret}")
    private String accessKeySecret;
    @Value("${aliyun.oss.bucketName}")
    private String bucketName;
}

package com.itheima.utils;

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

package com.itheima.utils;

/**
 * 阿里云 OSS 工具类
 */
@Component
public class AliOSSUtils {
    @Autowired
    private AliOSSProperties aliOSSProperties;

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile file) throws IOException {
        //获取阿里云OSS参数
        String endpoint = aliOSSProperties.getEndpoint();
        String accessKeyId = aliOSSProperties.getAccessKeyId();
        String accessKeySecret = aliOSSProperties.getAccessKeySecret();
        String bucketName = aliOSSProperties.getBucketName();

        // 获取上传的文件的输入流
        InputStream inputStream = file.getInputStream();

        // 避免文件覆盖
        String originalFilename = file.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}

package com.itheima.controller;

@Slf4j
@RestController
public class LoginController {
    @Autowired
    private EmpService empService;

    @PostMapping("login")
    public Result login(@RequestBody Emp emp) {
        log.info("员工登录：{}", emp);
        Emp e = empService.login(emp);
        return e != null ? Result.success() : Result.error("用户名或密码错误");
    }
}

//EmpService
//员工登录
Emp login(Emp emp);

//EmpServiceImpl
//员工登录
@Override
public Emp login(Emp emp) {
    return empMapper.getByUsernameAndPassword(emp);
}

//根据用户名和密码查询员工
@Select("select * from emp where username = #{username} and password = #{password}")
Emp getByUsernameAndPassword(Emp emp);

package com.itheima.controller;

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

import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
/**
 * HttpSession演示
 */
@Slf4j
@RestController
public class SessionController {
    //设置Cookie
    @GetMapping("/c1")
    public Result cookie1(HttpServletResponse response){
        response.addCookie(new Cookie("login_username","itheima")); //设置Cookie/响应Cookie
        return Result.success();
    }

    //获取Cookie
    @GetMapping("/c2")
    public Result cookie2(HttpServletRequest request){
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            if(cookie.getName().equals("login_username")){
                System.out.println("login_username: "+cookie.getValue()); //输出name为login_username的cookie
            }
        }
        return Result.success();
    }
}

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

package com.itheima.controller;

/**
 * HttpSession演示
 */
@Slf4j
@RestController
public class SessionController {
    @GetMapping("/s1")
    public Result session1(HttpSession session){
        log.info("HttpSession-s1: {}", session.hashCode());

        session.setAttribute("loginUser", "tom"); //往session中存储数据
        return Result.success();
    }

    @GetMapping("/s2")
    public Result session2(HttpServletRequest request){
        HttpSession session = request.getSession();
        log.info("HttpSession-s2: {}", session.hashCode());

        Object loginUser = session.getAttribute("loginUser"); //从session中获取数据
        log.info("loginUser: {}", loginUser);
        return Result.success(loginUser);
    }
}

package com.itheima;

//@SpringBootTest
//因为没使用到SpringBoot的功能，可以注释掉@SpringBootTest，加快测试的速度，否则需要加载整个SpringBoot工程会很慢
class SpringbootWebTliasApplicationTests {//在测试主方法下进行测试
	//生成JWT
	@Test
	public void testGenJwt(){
		Map<String, Object> claims = new HashMap<>();
		claims.put("id", 1);
		claims.put("name", "surourou");

		String jwt = Jwts.builder()
				.signWith(SignatureAlgorithm.HS256, "itheimaitheimaitheimaitheimaitheimaitheimaitheimaitheima") //签名算法：0.12.3版本要求签名算法必须大于或等于256bit，0.9.1版本没有要求
				.setClaims(claims) //自定义内容（载荷）
				.setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000)) //设置有效期为1h
				.compact(); //将结果包装为字符串
		System.out.println(jwt);
	}

	//解析JWT
	@Test
	public void testParseJwt(){
		Claims claims = Jwts.parser()
				.setSigningKey("itheimaitheimaitheimaitheimaitheimaitheimaitheimaitheima") //指定签名密钥
				.build() //0.12.3版本需要使用build()方法，0.9.1版本可以省略这一个方法
				.parseClaimsJws("eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoic3Vyb3Vyb3UiLCJpZCI6MSwiZXhwIjoxNzI5NzM2Njc0fQ.kOLJv1uPsmn-bEUagHO53L1esUl3c7f_4JlbMUHKso0") //解析令牌
				.getBody();
		System.out.println(claims);
	}

}

package com.itheima.utils;

public class JwtUtils {
    private static String signKey = "itheimaitheimaitheimaitheimaitheimaitheimaitheimaitheima";
    private static Long expire = 43200000L;

    /**
     * 生成JWT令牌
     * @param claims JWT第二部分负载 payload 中存储的内容
     * @return
     */
    public static String generateJwt(Map<String, Object> claims){
        String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, signKey)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;
    }

    /**
     * 解析JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分负载 payload 中存储的内容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                .setSigningKey(signKey)
                .build()
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }
}

package com.itheima.controller;

@Slf4j
@RestController
public class LoginController {
    @Autowired
    private EmpService empService;

    @PostMapping("login")
    public Result login(@RequestBody Emp emp) {
        log.info("员工登录：{}", emp);
        Emp e = empService.login(emp);
        //登录成功，生成令牌，下发令牌
        if(e != null) {
            Map<String, Object> claims = new HashMap<>();
            claims.put("id", e.getId());
            claims.put("name", e.getName());
            claims.put("username", e.getUsername());

            String jwt = JwtUtils.generateJwt(claims);
            return Result.success(jwt);
        }

        //登录失败，返回错误信息
        return Result.error("用户名或密码错误");
    }
}

package com.itheima.filter;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
//import javax.servlet.*;
//import javax.servlet.annotation.WebFilter;
//注意：必须使用jakarta下的包，不能使用javax，javax包虽然不报错，但是无法实现过滤功能。

import java.io.IOException;

@WebFilter(urlPatterns = "/*")
public class DemoFilter implements Filter {
    @Override //初始化方法，只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }

    @Override //拦截到请求之后调用，调用多次
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("拦截到了请求");
        //放行
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override //销毁方法，只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

package com.itheima;

@ServletComponentScan //开启对servlet组件的支持
@SpringBootApplication
public class SpringbootWebTliasApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringbootWebTliasApplication.class, args);
	}
}

package com.itheima.filter;

@WebFilter(urlPatterns = "/*")
public class AbcFilter implements Filter {
    @Override //初始化方法，只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Abc init 初始化方法执行了");
    }

    @Override //拦截到请求之后调用，调用多次
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("Abc 拦截到了请求，放行前逻辑");
        //放行
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("Abc 拦截到了请求，放行后逻辑");
    }

    @Override //销毁方法，只调用一次
    public void destroy() {
        System.out.println("Abc destroy 销毁方法执行了");
    }
}

package com.itheima.filter;

import com.alibaba.fastjson.JSONObject;
import com.itheima.pojo.Result;
import com.itheima.utils.JwtUtils;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
//必须使用jakarta下的包，使用javax会报错

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import java.io.IOException;

@Slf4j
@WebFilter(urlPatterns = "/*")
public class LoginCheckFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //强转
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        HttpServletResponse resp = (HttpServletResponse) servletResponse;

        //1.获取请求url
        String url = req.getRequestURL().toString();
        log.info("请求的url：{}", url);

        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
        if(url.contains("login")){
            log.info("登陆操作，放行");
            filterChain.doFilter(servletRequest, servletResponse);
            return;
        }

        //3.获取请求头中的令牌（token）
        String jwt = req.getHeader("token");

        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(jwt)){//判断jwt令牌是否为null或者空串
            log.info("请求头token为空，返回未登录的信息");
            Result error = Result.error("NOT_LOGIN");
            //手动转换，将对象转换为json数据响应 ---> 阿里巴巴fastJSON
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin); //输出流写入，响应给浏览器
            return;
        }

        //5.解析token，如果解析失败，返回错误结果（未登录）
        try{
            JwtUtils.parseJWT(jwt);
        }catch (Exception e){
            e.printStackTrace();
            log.info("解析令牌失败，返回未登录错误信息");
            Result error = Result.error("NOT_LOGIN");
            //手动转换，将对象转换为json数据响应 ---> 阿里巴巴fastJSON
            String notLogin = JSONObject.toJSONString(error);
            resp.getWriter().write(notLogin); //输出流写入，响应给浏览器
            return;
        }

        //6.放行
        log.info("令牌合法，放行");
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

package com.itheima.interceptor;

@Component
public class LoginCheckInterceptor implements HandlerInterceptor {
    @Override //目标资源方法运行前运行，返回true：放行，返回false不放行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }

    @Override //目标资源方法运行后运行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    @Override //视图渲染完毕后运行，最后运行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

package com.itheima.config;

@Configuration //配置类
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;
    @Override //注册拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
        //addPathPatterns：需要拦截哪些资源，excludePathPatterns：不需要拦截哪些资源
    }
}