Java实现递归删除菜单和目录及目录下所有文件

import com.baomidou.mybatisplus.annotation.idtype;
import com.baomidou.mybatisplus.annotation.tableid;
import com.baomidou.mybatisplus.annotation.tablename;
import lombok.data;
 
import java.io.serializable;
import java.util.date;
 
/**
 * 系统菜单
 */
@data
@tablename(value = "menu")
public class menu implements serializable {
 
    private static final long serialversionuid = 1l;
 
    /*** 菜单id*/
    @tableid(type = idtype.input)
    private long menuid;
 
    /*** 父级菜单id*/
    private long upmenuid;
 
    /*** 菜单编码*/
    private string menucode;
 
    /*** 菜单名称*/
    private string menuname;
 
    /*** 菜单级别（默认1级）*/
    private integer menulevel;
 
    /*** 菜单页面打开方式（1-本页面打开 2 新标签页打开 3-新窗口打开）*/
    private integer pageopentype;
 
    /*** 菜单类型（1-菜单 2-权限按钮）*/
    private integer menutype;
 
    /*** 菜单图标*/
    private string menuicon;
 
    /*** 菜单url*/
    private string menuurl;
 
    /*** 菜单序号*/
    private integer menuorder;
 
    /*** 菜单描述*/
    private string menudesc;
 
    /*** 数据状态（0-删除 1-正常） */
    private integer dataflag;
 
    /*** 是否禁用(0-否 1-是)*/
    private integer isdisable;
 
    /*** 创建人id*/
    private long createid;
 
    /*** 创建时间*/
    private date createtime;
 
}

import com.baomidou.mybatisplus.core.conditions.query.querywrapper;
import com.test.java.domain.entity.menu;
import com.test.java.mapper.menumapper;
import com.test.java.service.menuservice;
import org.springframework.util.collectionutils;
 
import javax.annotation.resource;
import java.util.arraylist;
import java.util.list;
 
public class menuserviceimpl implements menuservice {
 
    @resource
    private menumapper menumapper;
 
    @override
    public integer deletemenubyid(long menuid) {
        // 校验当前要删除的菜单是否存在
        menu menu = menumapper.selectbyid(menuid);
        if (null == menu) {
            throw new runtimeexception("菜单已删除");
        }
 
        // 创建list集合，用于封装所有要删除的菜单id
        list<long> menuidlist = new arraylist<>();
        // 向menuidlist集合设置删除菜单id（根据id删除菜单）
        this.querymenuchildbyid(menuid, menuidlist);
        // 把当前菜单id封装到idlist里面
        menuidlist.add(menuid);
 
        // 批量删除当前菜单 及其所有子菜单
        return menumapper.deletebatchids(menuidlist);
    }
 
 
    // 根据当前菜单id，查询其所有子菜单id，再封装到idlist集合
    private void querymenuchildbyid(long menuid, list<long> idlist) {
        // 查询菜单里面子菜单id
        querywrapper<menu> wrapper = new querywrapper<>();
        wrapper.eq("up_menu_id", menuid);
        list<menu> childmenulist = menumapper.selectlist(wrapper);
        if (!collectionutils.isempty(childmenulist)) {
            // 把childmenulist里面菜单id值获取出来，封装idlist里面，做递归查询
            childmenulist.foreach(item -> {
                //封装idlist里面
                idlist.add(item.getmenuid());
                //递归查询
                this.querymenuchildbyid(item.getmenuid(), idlist);
            });
        }
    }
 
}

import lombok.extern.slf4j.slf4j;
 
import java.io.file;
 
/**
 * 文件相关工具类
 */
@slf4j
public class fileutils {
 
    /**
     * 删除文件或文件夹
     *
     * @param path 文件路径
     * @return 返回true(删除成功), 返回false(删除失败)
     */
    public static boolean deletefileordirectory(string path) {
        file file = new file(path);
        // 判断文件是否存在
        if (file.exists()) {
            // 判断是否为文件
            if (file.isfile()) {
                // 删除文件
                return deletefile(path);
            } else {
                // 删除文件夹
                return deletedirectory(path);
            }
        } else {
            return false;
        }
    }
 
    /**
     * 删除文件
     *
     * @param path 文件路径
     * @return 返回true(删除成功), 返回false(删除失败)
     */
    public static boolean deletefile(string path) {
 
        boolean result = false;
 
        file file = new file(path);
        if (file.isfile() && file.exists()) {
            result = file.delete();
            log.info("删除文件成功：{}", path);
            return result;
        } else {
            log.info("删除文件失败：{}", path);
            return result;
        }
    }
 
    /**
     * 删除文件夹(先删文件再删目录)
     *
     * @param path 文件夹路径
     * @return 返回true(删除成功), 返回false(删除失败/文件夹不存在)
     */
    public static boolean deletedirectory(string path) {
        if (!path.endswith(file.separator)) {
            // 补齐文件分隔符
            path = path + file.separator;
        }
        file directoryfile = new file(path);
        // 文件不存在、不是一个目录就打印退出返回false
        if (!directoryfile.exists() || !directoryfile.isdirectory()) {
            log.info("文件夹不存在，{}", path);
            return false;
        }
 
        boolean flag = true;
        // 获取所有的子文件及子文件夹
        file[] files = directoryfile.listfiles();
        if (files != null) {
            // 循环删除
            for (file file : files) {
                // 删除子文件
                if (file.isfile()) {
                    flag = deletefile(file.getabsolutepath());
                    if (!flag) {
                        break;
                    }
                } else {// 删除子文件夹
                    flag = deletedirectory(file.getabsolutepath());
                    if (!flag) {
                        break;
                    }
                }
            }
        }
        if (!flag) {
            log.info("删除文件夹失败");
            return false;
        }
        // 最后删除当前文件夹
        if (directoryfile.delete()) {
            log.info("删除文件夹成功，{}", path);
            return true;
        } else {
            log.info("删除文件夹失败，{}", path);
            return false;
        }
    }
 
}