@Component //将当前对象交给IOC容器管理,成为IOC容器的bean  
public class EmpDaoA implements EmpDao {  
    @Override
    public List<Emp> listEmp() {  
        //1. 加载并解析emp.xml  
        String file = this.getClass().getClassLoader().getResource("emp.xml").getFile();  
        System.out.println(file);  
        List<Emp> empList = XmlParserUtils.parse(file, Emp.class);  
        return empList;  
    }
}

@Component(name = "specificBeanName")
public class MyBean {
    // ...
}

/*部门类*/  
@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class Dept {  
    private Integer id;  
    private String name;  
    private LocalDateTime createTime;  
    private LocalDateTime updateTime;  
}

/*员工类*/  
@Data  
@NoArgsConstructor  
@AllArgsConstructor  
public class Emp {  
    private Integer id;  
    private String username;  
    private String password;  
    private String name;  
    private Short gender;  
    private String image;  
    private Short job;  
    private LocalDate entrydate;  
    private Integer deptId;  
    private LocalDateTime createTime;  
    private LocalDateTime updateTime;  
}

package com.itheima.mapper;  
import org.apache.ibatis.annotations.Mapper;  
​  
@Mapper  
public interface DeptMapper {  
}

package com.itheima.mapper;  
import org.apache.ibatis.annotations.Mapper;  
​  
@Mapper  
public interface EmpMapper {  
}  

package com.itheima.service;  
​  
//部门业务规则  
public interface DeptService {  
// `DeptService` 接口会定义一些与部门（Dept）相关的业务操作方法，比如添加部门、删除部门、更新部门信息或查询部门列表等。而 `DeptServiceImpl` 类则会提供这些业务操作的具体实现。
}

package com.itheima.service.impl;  
import com.itheima.service.EmpService;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.stereotype.Service;  
​  
//员工业务实现类  
@Slf4j  
@Service  
public class EmpServiceImpl implements EmpService {  
​  
}

package com.itheima.controller;  
import org.springframework.web.bind.annotation.RestController;  
​  
//部门管理控制器  
@RestController  
public class DeptController {  
}

package com.itheima.controller;  
import org.springframework.web.bind.annotation.RestController;  
​  
//员工管理控制器  
@RestController  
public class EmpController {  
}

@Slf4j  // 自动生成logger对象
@RestController  
public class DeptController {  
    @Autowired  
    private DeptService deptService;  // 自动调用deptService
​  
    //@RequestMapping(value = "/depts" , method = RequestMethod.GET)  
    @GetMapping("/depts")  // get depts时
    public Result list(){  
        log.info("查询所有部门数据");  
        List<Dept> deptList = deptService.list();  //调用deptService的list方法
        return Result.success(deptList);  
    }  
}

public interface DeptService {  
    /**  
     * 查询所有的部门数据  
     * @return   存储Dept对象的集合  
     */  
    List<Dept> list();  // list方法:方法将返回一个`List`集合，集合中包含`Dept`类型的对象
}

@Slf4j  
@Service  
public class DeptServiceImpl implements DeptService {  
    @Autowired  
    private DeptMapper deptMapper;  
      
    @Override  
    public List<Dept> list() {  
        List<Dept> deptList = deptMapper.list();  
        return deptList;  
    }  
}    

@Mapper  
public interface DeptMapper {  
    //查询所有部门数据  
    @Select("select id, name, create_time, update_time from dept")  
    List<Dept> list();  
}

@Slf4j  
@RestController  
public class DeptController {  
    @Autowired  
    private DeptService deptService;  
​  
    @DeleteMapping("/depts/{id}")  
    public Result delete(@PathVariable Integer id) {  
        //日志记录  
        log.info("根据id删除部门");  
        //调用service层功能  
        deptService.delete(id);  
        //响应  
        return Result.success();  
    }  
      
    //省略...  
}

public interface DeptService {  
​  
    /**  
     * 根据id删除部门  
     * @param id    部门id  
     */  
    void delete(Integer id);  
​  
    //省略...  
}

@Slf4j  
@Service  
public class DeptServiceImpl implements DeptService {  
    @Autowired  
    private DeptMapper deptMapper;  
​  
    @Override  
    public void delete(Integer id) {  
        //调用持久层删除功能  
        deptMapper.deleteById(id);  
    }  
      
    //省略...  
}

@Mapper  
public interface DeptMapper {  
    /**  
     * 根据id删除部门信息  
     * @param id   部门id  
     */  
    @Delete("delete from dept where id = #{id}")  
    void deleteById(Integer id);  
     
    //省略...  
}

@Slf4j  
@RestController  
public class DeptController {  
    @Autowired  
    private DeptService deptService;  
​  
    @PostMapping("/depts")  
    public Result add(@RequestBody Dept dept){  
    // @RequestBody  //把前端传递的json数据填充到实体类中
        //记录日志  
        log.info("新增部门：{}",dept);  
        //调用service层添加功能  
        deptService.add(dept);  
        //响应  
        return Result.success();  
    }  
​  
    //省略...  
}

public interface DeptService {  
​  
    /**  
     * 新增部门  
     * @param dept  部门对象  
     */  
    void add(Dept dept);  
​  
    //省略...  
}  

@Slf4j  
@Service  
public class DeptServiceImpl implements DeptService {  
    @Autowired  
    private DeptMapper deptMapper;  
​  
    @Override  
    public void add(Dept dept) {  
        //补全部门数据  
        dept.setCreateTime(LocalDateTime.now());  
        dept.setUpdateTime(LocalDateTime.now());  
        //调用持久层增加功能  
        deptMapper.inser(dept);  
    }  
​  
    //省略...  
}  

@Mapper  
public interface DeptMapper {  
​  
    @Insert("insert into dept (name, create_time, update_time) values (#{name},#{createTime},#{updateTime})")  
    void inser(Dept dept);  
​  
    //省略...  
}

public class PageBean{
	private Long total;
	private Long rows;
}

import com.itheima.pojo.PageBean;
import com.itheima.pojo.Result;
import com.itheima.service.EmpService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/emps")// 提前到此，本类的所有都基于/emps为前缀
public class EmpController {

    @Autowired
    private EmpService empService;

    //条件分页查询
    @GetMapping
    public Result page(@RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "10") Integer pageSize) 
    //@RequestParam(defaultValue="默认值") //设置请求参数默认值
    {
        //记录日志
        log.info("分页查询，参数：{},{}", page, pageSize);
        //调用业务层分页查询功能
        PageBean pageBean = empService.page(page, pageSize);
        //响应
        return Result.success(pageBean);
    }
}

public interface EmpService {  
    /**  
     * 条件分页查询  
     * @param page 页码  
     * @param pageSize 每页展示记录数  
     * @return  
     */  
    PageBean page(Integer page, Integer pageSize);  
}

import com.itheima.mapper.EmpMapper;  
import com.itheima.pojo.Emp;  
import com.itheima.pojo.PageBean;  
import com.itheima.service.EmpService;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import java.time.LocalDate;  
import java.util.List;  
​  
@Slf4j  
@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; //计算起始索引 , 公式: (页码-1)*页大小  
        List<Emp> empList = empMapper.list(start, pageSize);  
​  
        //3、封装PageBean对象  
        PageBean pageBean = new PageBean(count , empList);  
        return pageBean;  
    }  
}

@Mapper  
public interface EmpMapper {  
    //获取总记录数  
    @Select("select count(*) from emp")  
    public Long count();  
​  
    //获取当前页的结果列表  
    @Select("select * from emp limit #{start}, #{pageSize}")  
    public List<Emp> list(Integer start, Integer pageSize);  
}

@Mapper  
public interface EmpMapper {  
    //获取当前页的结果列表  
    @Select("select * from emp")  
    public List<Emp> page(Integer start, Integer pageSize);  
}

@Override  
public PageBean page(Integer page, Integer pageSize) {  
    // 设置分页参数  
    PageHelper.startPage(page, pageSize);   
    // 执行分页查询  
    List<Emp> empList = empMapper.list(name,gender,begin,end);   
    // 获取分页结果  
    Page<Emp> p = (Page<Emp>) empList;     
    //封装PageBean  
    PageBean pageBean = new PageBean(p.getTotal(), p.getResult());   
    return pageBean;  
}

@Slf4j  
@RestController  
@RequestMapping("/emps")  
public class EmpController {  
​  
    @Autowired  
    private EmpService empService;  
​  
    //条件分页查询  
    @GetMapping  
    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);  
    }  
}

public interface EmpService {  
    /**  
     * 条件分页查询  
     * @param page     页码  
     * @param pageSize 每页展示记录数  
     * @param name     姓名  
     * @param gender   性别  
     * @param begin   开始时间  
     * @param end     结束时间  
     * @return  
     */  
    PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end);  
}

@Slf4j  
@Service  
public class EmpServiceImpl implements EmpService {  
    @Autowired  
    private EmpMapper empMapper;  
​  
    @Override  
    public PageBean page(Integer page, Integer pageSize, String name, Short gender, LocalDate begin, LocalDate end) {  
        //设置分页参数  
        PageHelper.startPage(page, pageSize);  
        //执行条件分页查询  
        List<Emp> empList = empMapper.list(name, gender, begin, end);  
        //获取查询结果  
        Page<Emp> p = (Page<Emp>) empList;  
        //封装PageBean  
        PageBean pageBean = new PageBean(p.getTotal(), p.getResult());  
        return pageBean;  
    }  
}

@Mapper  
public interface EmpMapper {  
    //获取当前页的结果列表  
    public List<Emp> list(String name, Short gender, LocalDate begin, LocalDate end);  
}

@Slf4j
@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username, Integer age, MultipartFile image) throws IOException {
        log.info("文件上传：{},{},{}",username,age,image);

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

        //将文件存储在服务器的磁盘目录
        image.transferTo(new File("E:/images/"+originalFilename));

        return Result.success();
    }

}

@Slf4j
@RestController
public class UploadController {

    @PostMapping("/upload")
    public Result upload(String username, Integer age, MultipartFile image) throws IOException {
        log.info("文件上传：{},{},{}",username,age,image);

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

        //构建新的文件名
        String extname = originalFilename.substring(originalFilename.lastIndexOf("."));//文件扩展名
        String newFileName = UUID.randomUUID().toString()+extname;//随机名+文件扩展名

        //将文件存储在服务器的磁盘目录
        image.transferTo(new File("E:/images/"+newFileName));

        return Result.success();
    }

}

@Component
public class AliOSSUtils {
    /*以下4个参数没有指定值（默认值：null）*/
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;

    //省略其他代码...
}

@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;
 	
 	//省略其他代码...
 }   

@RestController  
public class LoginController {  
​  
    @Autowired  
    private EmpService empService;  
​  
    @PostMapping("/login")  
    public Result login(@RequestBody Emp emp){  
        Emp e = empService.login(emp);  
        return  e != null ? Result.success():Result.error("用户名或密码错误");  
    }  
}

public interface EmpService {  
​  
    /**  
     * 用户登录  
     * @param emp  
     * @return  
     */  
    public Emp login(Emp emp);  
​  
    //省略其他代码...  
}

@Slf4j  
@Service  
public class EmpServiceImpl implements EmpService {  
    @Autowired  
    private EmpMapper empMapper;  
​  
    @Override  
    public Emp login(Emp emp) {  
        //调用dao层功能：登录  
        Emp loginEmp = empMapper.getByUsernameAndPassword(emp);  
​  
        //返回查询结果给Controller  
        return loginEmp;  
    }     
      
    //省略其他代码...  
}

@Mapper  
public interface EmpMapper {  
​  
    @Select("select id, username, password, name, gender, image, job, entrydate, dept_id, create_time, update_time " +  
            "from emp " +  
            "where username=#{username} and password =#{password}")  
    public Emp getByUsernameAndPassword(Emp emp);  
      
    //省略其他代码...  
}

public class JwtUtils {

    private static String signKey = "itheima";//签名密钥
    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)//指定签名密钥
                .parseClaimsJws(jwt)//指定令牌Token
                .getBody();
        return claims;
    }
}

@RestController
@Slf4j
public class LoginController {
    //依赖业务层对象
    @Autowired
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody Emp emp) {
        //调用业务层：登录功能
        Emp loginEmp = empService.login(emp);

        //判断：登录用户是否存在
        if(loginEmp !=null ){
            //自定义信息
            Map<String , Object> claims = new HashMap<>();
            claims.put("id", loginEmp.getId());
            claims.put("username",loginEmp.getUsername());
            claims.put("name",loginEmp.getName());

            //使用JWT工具类，生成身份令牌
            String token = JwtUtils.generateJwt(claims);
            return Result.success(token);
        }
        return Result.error("用户名或密码错误");
    }
}

//定义一个类，实现一个标准的Filter过滤器的接口
public class DemoFilter implements Filter {
    @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }

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

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

@WebFilter(urlPatterns = "/*") //配置过滤器要拦截的请求路径（ /* 表示拦截浏览器的所有请求 ）  

public class DemoFilter implements Filter {  
    @Override //初始化方法, 只调用一次  
    public void init(FilterConfig filterConfig) throws ServletException {  
        System.out.println("init 初始化方法执行了");  
    }  
​  
    @Override //拦截到请求之后调用, 调用多次  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
        System.out.println("Demo 拦截到了请求...放行前逻辑");  
        //放行  
        chain.doFilter(request,response);  
    }  
​  
    @Override //销毁方法, 只调用一次  
    public void destroy() {  
        System.out.println("destroy 销毁方法执行了");  
    }  
}

@ServletComponentScan  
@SpringBootApplication  
public class TliasWebManagementApplication {  
​  
    public static void main(String[] args) {  
        SpringApplication.run(TliasWebManagementApplication.class, args);  
    }  
​  
}

@Slf4j
@WebFilter(urlPatterns = "/*") //拦截所有请求
public class LoginCheckFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        //前置：强制转换为http协议的请求对象、响应对象 （转换原因：要使用子类中特有方法）
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //1.获取请求url
        String url = request.getRequestURL().toString();
        log.info("请求路径：{}", url); //请求路径：http://localhost:8080/login


        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
        if(url.contains("/login")){
            chain.doFilter(request, response);//放行请求
            return;//结束当前方法的执行
        }


        //3.获取请求头中的令牌（token）
        String token = request.getHeader("token");
        log.info("从请求头中获取的令牌：{}",token);


        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(token)){
            log.info("Token不存在");

            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);

            return;
        }

        //5.解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){
            log.info("令牌解析失败!");

            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);
            return;
        }
        //6.放行
        chain.doFilter(request, response);
    }
}

//自定义拦截器  
@Component  
public class LoginCheckInterceptor implements HandlerInterceptor {  
    //目标资源方法执行前执行。 返回true：放行    返回false：不放行  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
        System.out.println("preHandle .... ");  
          
        return true; //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 .... ");  
    }  
}

@Configuration    
public class WebConfig implements WebMvcConfigurer {

    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册自定义拦截器对象
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
                .excludePathPatterns("/login");//设置不拦截的请求路径
    }
}

// ======================登陆配置拦截器===================
//自定义拦截器
@Component //当前拦截器对象由Spring创建和管理
@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {
    //前置方式
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle .... ");
        //1.获取请求url
        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行

        //3.获取请求头中的令牌（token）
        String token = request.getHeader("token");
        log.info("从请求头中获取的令牌：{}",token);

        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(token)){
            log.info("Token不存在");

            //创建响应结果对象
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            //设置响应头（告知浏览器：响应的数据类型为json、响应的数据编码表为utf-8）
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);

            return false;//不放行
        }

        //5.解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){
            log.info("令牌解析失败!");

            //创建响应结果对象
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            //设置响应头
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);

            return false;
        }

        //6.放行
        return true;
    }

// ====================并非同一个文件=======================
// 注册配置
@Configuration  
public class WebConfig implements WebMvcConfigurer {
    //拦截器对象
    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
       //注册自定义拦截器对象
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

@RestControllerAdvice  
public class GlobalExceptionHandler {  
​  
    //处理异常  
    @ExceptionHandler(Exception.class) //指定能够处理的异常类型 
    //当控制器（Controller）中的方法抛出异常时，Spring 框架会查找匹配的异常处理器来处理该异常。 
    // `Exception`：这是 Java 标准库中的一个类，它是所有“非运行时异常”（checked exceptions）的超类。
    // `.class`：这是一个语法糖，用于获取一个类的 `Class` 对象。当你使用 `.class` 语法时，编译器会生成一个指向该类的 `Class` 对象的引用。
    public Result ex(Exception e){  
        e.printStackTrace();//打印堆栈中的异常信息  
        //捕获到异常之后，响应一个标准的Result  
        return Result.error("对不起,操作失败,请联系管理员");  
    }  
}

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

    @Autowired
    private EmpMapper empMapper;

    
    @Override
    @Transactional  //当前方法添加了事务管理
    public void delete(Integer id){
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        int i = 1/0;

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
    }
}

@Transactional
public void delete(Integer id) throws Exception {
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        if(true){
            throw new Exception("出现异常了~~~");
        }

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
}

@Slf4j  
@Service  
public class DeptServiceImpl implements DeptService {  
    @Autowired  
    private DeptMapper deptMapper;  
​  
    @Autowired  
    private EmpMapper empMapper;  
​  
      
    @Override  
    @Transactional(rollbackFor=Exception.class)  
    public void delete(Integer id){  
        //根据部门id删除部门信息  
        deptMapper.deleteById(id);  
          
        //模拟：异常发生  
        int num = id/0;  
​  
        //删除部门下的所有员工信息  
        empMapper.deleteByDeptId(id);     
    }  
}

@Service
public class DeptLogServiceImpl implements DeptLogService {

    @Autowired
    private DeptLogMapper deptLogMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)//事务传播行为：不论是否有事务，都新建事务
    @Override
    public void insert(DeptLog deptLog) {
        deptLogMapper.insert(deptLog);
    }
}