项目—本地文件搜索

最新推荐文章于 2023-09-28 23:47:40 发布

我选择沉默

最新推荐文章于 2023-09-28 23:47:40 发布

阅读量659

点赞数

分类专栏：学习笔记文章标签： java sqlite maven

本文链接：https://blog.csdn.net/qq_52390903/article/details/126585311

版权

学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

项目介绍

使用Java实现的本地文件搜索项目，支持多平台使用，支持拼音搜索和模糊搜索

项目功能

1.选中文件夹，对文件夹下的文件进行扫描，并将文件的名称大小，修改时间展示在界面上

2.对文件进行搜索，可以使用全称搜索，拼音搜索，首字母进行搜索

技术栈

Java、JavaFX，SQLite数据库、JBDC、多线程

项目结构

项目实现

app包

Controller界面管理类

与前端页面进行绑定，项目启动时，对界面进行初始化，选择目录或搜索后对页面进行刷新

package app;

import callback.impl.FileSave2DB;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.ObservableList;
import javafx.event.Event;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Label;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import javafx.stage.DirectoryChooser;
import javafx.stage.Window;
import task.FileScanner;
import task.FileSearch;
import util.DBInit;

import java.io.File;
import java.net.URL;
import java.util.List;
import java.util.ResourceBundle;

/**
 *
 *
 **/
public class Controller implements Initializable {

    @FXML
    private GridPane rootPane;

    @FXML
    private TextField searchField;

    @FXML
    private TableView<FileMeta> fileTable;

    @FXML
    private Label srcDirectory;

    private Thread scanThread;

    public void initialize(URL location, ResourceBundle resources) {
        DBInit.init();
        // 添加搜索框监听器，内容改变时执行监听事件
        searchField.textProperty().addListener(new ChangeListener<String>() {
            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
                freshTable();
            }
        });
    }

    public void choose(Event event) {
        // 选择文件目录
        DirectoryChooser directoryChooser=new DirectoryChooser();
        Window window = rootPane.getScene().getWindow();
        File file = directoryChooser.showDialog(window);
        if(file == null)
            return;
        // 获取选择的目录路径，并显示
        String path = file.getPath();
        this.srcDirectory.setText(path);
        //进行文件扫描，并且决定将信息保存到哪个中端
        FileScanner fileScanner = new FileScanner(new FileSave2DB());
        if (scanThread != null){
            //创建扫描任务，该任务还没结束，中断当前的扫描任务
            scanThread.interrupt();
        }
        //开启新的扫描任务
        scanThread = new Thread(()->{
           fileScanner.scan(file);
            // TODO 刷新页面，展示刚才的扫描信息
            this.freshTable();
        });
        scanThread.start();
    }

    // 刷新表格数据
    private void freshTable(){
        ObservableList<FileMeta> metas = fileTable.getItems();
        metas.clear();
        //所选的目录
        String dir = srcDirectory.getText();
        if(dir !=null && dir.length() !=0){
            //界面中选择了文件，只要把数据库中的数据展示在界面上
            //获取用户搜索输入
            String context = searchField.getText();
            //根据输入内容展示相应的数据（输入为空展示全部数据）
            List<FileMeta> fileFromDB = FileSearch.search(dir,context);
            //将查询的内容刷新到界面中
            metas.addAll(fileFromDB);
        }
    }
}

FileMeta 文件信息类

数据库中每一行信息就是该类的一个对象

package app;

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.ToString;
import util.Util;

import java.util.Date;

/**
 * 该类的一个对象对应数据库的一行数据
 **/
@Data
@ToString
@NoArgsConstructor
@EqualsAndHashCode
public class FileMeta {
    private String name;

    private String path;

    private Boolean isDirectory;

    private Long size;

    private Date lastModified;

    private String pinYin;

    private String PinYinFirst;

    //对是否是文件夹、大小、最后操作时间进行修改
    private String isDirectoryText;

    private String sizeText;

    private String lastModifiedText;

    public void setSize(Long size){
        this.size = size;
        this.sizeText = Util.parseSize(size);
    }

    public void setIsDirectory(Boolean directory) {
        this.isDirectory = directory;
        this.isDirectoryText = Util.parseIsDir(directory);
    }

    public void setLastModified(Date lastModified) {
        this.lastModified = lastModified;
        this.lastModifiedText = Util.parseLMT(lastModified);
    }

    public FileMeta(String name, String path, Boolean isDirectory, Long size, Date lastModified) {
        this.name = name;
        this.path = path;
        this.isDirectory = isDirectory;
        this.size = size;
        this.lastModified = lastModified;
    }

}

task包

FileScanner 文件扫描类

使用线程池对文件进行扫描，每扫描到一个文件夹就创建一个子线程交给他进行描述，并调用回调函数将扫描的文件信息保存到数据库中，使用多线程中的工具包中的Semaphore类进行计数初始化值为0使线程阻塞在这里，当最后一个子线程结束后释放掉资源使信号量Semaphore加1，使得主线程继续执行下去

package task;

import callback.FileScannerCallBack;
import lombok.Getter;

import java.io.File;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;


/**
 * 进行文件扫描操作
 */
@Getter
public class FileScanner {

    //扫描的文件个数
    private AtomicInteger fileNum = new AtomicInteger();

    //扫描的文件夹个数
    private AtomicInteger dirNum = new AtomicInteger(1);

    //扫描文件的子线程个数，只有当子线程为0时，主线程才执行
    private AtomicInteger threadCount = new AtomicInteger();

    //当最后一个子线程执行完成后，唤醒主线程
    private CountDownLatch latch = new CountDownLatch(1);

    //计数器
    private Semaphore semaphore = new Semaphore(0);

    //获取电脑可用CPU个数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    //创建线程池
    private ThreadPoolExecutor pool = new ThreadPoolExecutor(CPU_COUNT,CPU_COUNT*2,
            10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(),
            new ThreadPoolExecutor.AbortPolicy());


    //文件扫描回调对象
    private FileScannerCallBack callBack;

    public FileScanner(FileScannerCallBack callBack) {
        this.callBack = callBack;
    }

    /**
     * 文件扫描方法，根据传入的文件开始扫描任务
     *
     * @param file 扫描的文件夹
     */
    public void scan(File file) {
        System.out.println("开始文件扫描，根目录为：" + file);
        long start = System.nanoTime();
        //将扫描任务交给创建的线程处理
        scanInternal(file);
        //统计线程数
        getThreadCount().incrementAndGet();
        try {
            //等待
            latch.await();
//            semaphore.acquire();
        } catch (InterruptedException e) {
            System.err.println("扫描任务中断，根目录为：" + file);
        }finally {
            System.out.println("关闭线程池.");
            //子线程结束是正常关闭
            //中断任务，需要停止所有扫描文件夹的子线程
            pool.shutdownNow();
        }
        long end = System.nanoTime();
        System.out.println("文件扫描任务结束，共耗时 ：" + (end - start)/1000000 +"ms");
        System.out.println("文件扫描任务结束，根目录为 + " + file);
        System.out.println("共扫描到 ： " + fileNum.get() + "个文件");
        System.out.println("共扫描到 ： " + dirNum.get() + "个文件夹");
    }

    /**
     * 扫描任务的子线程递归方法
     * @param file
     */
    private void scanInternal(File file) {
        if (file == null) {
            return;
        }
        //扫描任务交给线程池中的线程处理
        pool.submit(()->{
            //使用回调函数，将目录下的所有内容保存到指定中端
            this.callBack.callBack(file);
            //获得文夹的子目录
            File[] files = file.listFiles();
            //将当前目录进行扫描
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    dirNum.incrementAndGet();
                    //将扫描文件夹的任务交给新线程处理
                    threadCount.incrementAndGet();
                    scanInternal(file1);
                } else {
                    fileNum.incrementAndGet();
                }
            }
            System.out.println(Thread.currentThread().getName()+ "扫描" + file + "任务结束");
            //任务结束子线程数-1；
            threadCount.decrementAndGet();
            //当所有扫描任务结束时子线程数为0
            if(threadCount.get() == 0){
                System.out.println("所有扫描任务结束");
                //唤醒主线程,计数器-1
                latch.countDown();
//                semaphore.release();
            }
        });

    }
}

FileSearch 文件搜索类

根据用户输入的文件名，从数据库中查询对应的文件

package task;

import app.FileMeta;
import util.DBUtil;

import java.io.File;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author hu
 * @date 2022/7/12 22:04
 * 根据用户输入的文件名，从数据库中查找相应的文件
 */
public class FileSearch {


    public static List<FileMeta> search(String dir, String context) {
        List<FileMeta> fileMetas = new ArrayList<>();
        Connection connection =null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            connection = DBUtil.getConnection();
            String sql = "select name,path,is_directory,size,last_modified from file_meta where " +
                    " (path = ? or path like ?)";
            if(context != null && context.trim().length() != 0){
                sql += " and (name like ? or pinyin like ? or pinyin_first like ?)";
            }
            ps = connection.prepareStatement(sql);
            ps.setString(1,dir);
            ps.setString(2,dir + File.separator + "%");
            if(context != null && context.trim().length() != 0){
                ps.setString(3,"%" + context + "%");
                ps.setString(4,"%" + context + "%");
                ps.setString(5,"%" + context + "%");
            }
            System.out.println("正在从数据库中检索信息，sql为：" + ps);
            rs = ps.executeQuery();
            while (rs.next()){
                FileMeta meta = new FileMeta();
                meta.setName(rs.getString("name"));
                meta.setPath(rs.getString("path"));
                meta.setIsDirectory(rs.getBoolean("is_directory"));
                meta.setLastModified(new Date(rs.getTimestamp("last_modified").getTime()));
                if(!meta.getIsDirectory()){
                    meta.setSize(rs.getLong("size"));
                }
                fileMetas.add(meta);
                System.out.println("检索到文件信息：name = " + meta.getName() + ", path = " + meta.getPath() );
            }
        } catch (SQLException E) {
            System.err.println("从数据库中查找内容出错，请检查SQL语句");
            E.printStackTrace();
        }finally {
            DBUtil.close(ps,rs);
        }
        return fileMetas;
    }
}

callback包

FileScannerCallBack 回调函数接口

扫描时由具体的子类决定将扫描的信息持久化到哪个终端

package callback;

import java.io.File;


/**
 * 文件扫描的回调窗口
 */
public interface FileScannerCallBack {
    /**
     * 扫描时由具体的子类决定将扫描的信息持久化到哪个中端
     * @param dir
     */
    void callBack(File dir);
}

FileSave2DB 回调函数实现类

将扫描的信息保存到SQLite数据库中

先获取文件夹下所有的子文件存储在内存中，并与数据库中的数据进行比较，如果数据库中数据不存在，那么文件信息保存到数据库中，如果数据库中存在文件信息，而内存中不存在那么将数据库中的文件信息进行删除（当扫描一遍文件夹，将文件夹中的某个文件进行删除，然后再次扫描，更新信息）。

package callback.impl;

import app.FileMeta;
import callback.FileScannerCallBack;
import util.DBUtil;
import util.PinyinUtil;

import java.io.File;
import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 类说明
 *
 * @author hu
 * @date 2022/7/10 13:03
 */
public class FileSave2DB implements FileScannerCallBack {
    @Override
    public void callBack(File dir) {
        //获取dir下的所有子文件
        File[] files = dir.listFiles();
        //如果files为空说明是文件不是文件夹
        if (files != null && files.length != 0) {
            //将dir文件夹中所有的信息保存到内存中，缓存中的数据一定是从os中读取的最新的数据
            List<FileMeta> local = new ArrayList<>();
            for (File file : files) {
                FileMeta meta = new FileMeta();
                if (file.isDirectory()) {
                    setCommonFiled(file.getName(),file.getParent(),true,file.lastModified(),meta);
                } else {
                    setCommonFiled(file.getName(),file.getParent(),false,file.lastModified(),meta);
                    meta.setSize(file.length());
                }
                local.add(meta);
            }
            //从数据库中读取dir文件夹中所有的信息
            List<FileMeta> dbFiles = query(dir);
            //对比两个集合,本地没有的数据,数据库中有进行删除操作
            for (FileMeta meta : dbFiles) {
                if (!local.contains(meta)) {
                    delete(meta);
                }
            }
            //对比两个集合,本地有的数据,数据库中没有进行插入操作
            for (FileMeta meta : local) {
                if (!dbFiles.contains(meta)) {
                    save(meta);
                }
            }
        }
    }

    /**
     * 将数据库中存在本地不存在的信息删除
     *
     * @param meta
     */
    private void delete(FileMeta meta) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            connection = DBUtil.getConnection();
            String sql = "delete from file_meta where " + " (name = ? and path = ?)";
            //如果是文件夹还要删除文件夹中的子文件和子文件夹
            if (meta.getIsDirectory()) {
                sql += " or path = ?";
                sql += " or path like ?";
            }
            ps = connection.prepareStatement(sql);
            ps.setString(1, meta.getName());
            ps.setString(2, meta.getPath());
            if (meta.getIsDirectory()) {
                ps.setString(3, meta.getPath() + File.separator + meta.getName());
                ps.setString(4, meta.getPath() + File.separator + meta.getName()
                        + File.separator + "%");
            }
            System.out.println("执行删除操作，SQL为：" + ps);
            int rows = ps.executeUpdate();
            if (meta.getIsDirectory()) {
                System.out.println("删除文件夹" + meta.getName() + "成功，共删除" + rows + "个文件夹");
            } else {
                System.out.println("删除文件" + meta.getName() + "成功");
            }
        } catch (SQLException e) {
            System.err.println("文件删除出错，请检查SQL语句");
            e.printStackTrace();
        } finally {
            DBUtil.close(ps);
        }
    }

    /**
     * 将数据库不存在的信息保存到数据库中
     *
     * @param meta
     */
    private void save(FileMeta meta) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            connection = DBUtil.getConnection();
            String sql = "insert into file_meta values(?,?,?,?,?,?,?)";
            ps = connection.prepareStatement(sql);
            String fileName = meta.getName();
            ps.setString(1, fileName);
            ps.setString(2, meta.getPath());
            ps.setBoolean(3, meta.getIsDirectory());
            if (!meta.getIsDirectory()) {
                //是文件的时候才有大小
                ps.setLong(4, meta.getSize());
            }
            ps.setTimestamp(5, new Timestamp(meta.getLastModified().getTime()));
            //是否要传入拼音，看文件名是否包含中文
            if (PinyinUtil.containsChinese(fileName)) {
                String[] pinyins = PinyinUtil.getPinyinByFilename(fileName);
                ps.setString(6, pinyins[0]);
                ps.setString(7, pinyins[1]);
            }
            System.out.println("执行文件的保存操作，SQL为：" + ps);
            int rows = ps.executeUpdate();
            System.out.println("成功保存" + rows + "行文件信息");
        } catch (SQLException e) {
            System.err.println("保存文件信息出错，请检查SQL语句");
            e.printStackTrace();
        } finally {
            DBUtil.close(ps);
        }
    }

    /**
     * 查询数据库中路径下的文件信息
     *
     * @param dir
     * @return
     */
    private List<FileMeta> query(File dir) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<FileMeta> dbFiles = new ArrayList<>();
        try {
            connection = DBUtil.getConnection();
            String sql = "select name,path,is_directory,size,last_modified from file_meta" +
                    " where path = ?";
            ps = connection.prepareStatement(sql);
            ps.setString(1, dir.getPath());
            rs = ps.executeQuery();
            while (rs.next()) {
                //从数据库中获取信息
                FileMeta meta = new FileMeta();
                meta.setName(rs.getString("name"));
                meta.setPath(rs.getString("path"));
                meta.setIsDirectory(rs.getBoolean("is_directory"));
                meta.setLastModified(new Date(rs.getTimestamp("last_modified").getTime()));
                //只有是文件时才获取大小
                //文件夹的大小为null从数据库中返回为0
                if (!meta.getIsDirectory()) {
                    meta.setSize(rs.getLong("size"));
                }
                dbFiles.add(meta);
            }
        } catch (SQLException throwables) {
            System.err.println("查询数据库指定路径下的文件出错，请检查SQL语句");
            throwables.printStackTrace();
        } finally {
            DBUtil.close(ps, rs);
        }
        return dbFiles;
    }


    private void setCommonFiled(String name, String path, boolean isDirectory, Long lastModified, FileMeta meta) {
        meta.setName(name);
        meta.setPath(path);
        meta.setIsDirectory(isDirectory);
        // file对象的lastModified是一个长整型，以时间戳为单位的
        meta.setLastModified(new Date(lastModified));
    }
}

util工具包

DBinit类，数据表初始化类

从init.sql中获取创建数据表的SQL语句，根据我们自定义的分隔符对sql语句进行分开，然后执行，创建数据表。

package util;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 在界面初始化时创建文件信息数据表
 */
public class DBInit {

    public static List<String> readSQL(){
        List<String> ret = new ArrayList<>();
        //从init.sql文件中获取内容
        InputStream in = DBInit.class.getClassLoader()
                .getResourceAsStream("init.sql");
        Scanner sc = new Scanner(in);
        //自定义分隔符 next()按自定义分隔符划分
        sc.useDelimiter(";");
        //按照分隔符拆分读取
        while(sc.hasNext()){
            String str = sc.next();
            //当字符串为空或者为换行符时跳过
            if("".equals(str) || "\n".equals(str)){
                continue;
            }
            //将字符串中的 '--'转化为''
            if(str.contains("--")){
               str = str.replaceAll("--","");
            }
            ret.add(str);
        }
        return ret;
    }

    public static void init(){
        Connection connection = null;
        Statement statement = null;
        try {
            connection = DBUtil.getConnection();
            List<String> sqls = readSQL();
            statement =  connection.createStatement();
            for(String sql : sqls){
                System.out.println("执行SQL操作" + sql);
                statement.executeUpdate(sql);
            }
        } catch (SQLException e) {
            System.out.println("数据库初始化失败！");
            e.printStackTrace();
        }finally {
            DBUtil.close(statement);
        }
    }
}

DBUtil DQLite工具类

获取数据库源，创建数据库连接，创建、SQLtie数据库，返回数据库连接，关闭数据库连接

package util;

import org.sqlite.SQLiteConfig;
import org.sqlite.SQLiteDataSource;

import javax.sql.DataSource;
import java.io.File;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * SQLite的工具类
 * 获取SQLite数据库源，数据库连接
 * 向外界提供连接
 */
public class DBUtil {

    //单例模式 创建数据源
    private volatile static DataSource DATASOURCE;
    //单例数据库连接
    private volatile static Connection CONNECTION;

    private static DataSource getDataSource() {
        if (DATASOURCE == null) {
            //多线程下，只有一个线程能进入同步代码块
            synchronized (DBUtil.class) {
                if (DATASOURCE == null) {
                    //SQLite没有账户密码，只需要设置日期格式即可
                    SQLiteConfig config = new SQLiteConfig();
                    config.setDateStringFormat(Util.DATE_PATTERN);
                    DATASOURCE = new SQLiteDataSource(config);
                    //向下转型
                    ((SQLiteDataSource) DATASOURCE).setUrl(getUrl());

                }
            }
        }
        return DATASOURCE;
    }

    /**
     * SqLite,没有客户端和服务端，只需要指定地址即可
     * @return
     */
    private static String getUrl() {
        //指定数据库的地址
        String path = "D:\\IDEA workspace\\search_everything\\target";
        String url = "jdbc:sqlite://" + path + File.separator + "search_everything.db";
        System.out.println("获得数据库连接为:" + url);
        return url;
    }

    /**
     * 返回数据库连接
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        if (CONNECTION == null){
            synchronized (DBUtil.class){
                if (CONNECTION == null){
                    CONNECTION = getDataSource().getConnection();
                }
            }
        }
        return CONNECTION;
    }

    public static void close(Statement statement){
        if(statement != null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public static void close(Statement statement, ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        close(statement);
    }

}

PinyinUtil 拼音工具类

将汉字转化为拼音和拼音的首字母的缩写，从而提供模糊搜索和拼音搜索

package util;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

/**
 *
 */
public class PinyinUtil {
    //定义汉语拼音的配置，全局常量唯一
    private static final HanyuPinyinOutputFormat FORMAT;

    //中文对应Unicode编码区间
    private static final String CHINESE_PATTERN = "[\\u4E00-\\u9FA5]";

    static {
        //类加载是执行静态代码块，对FORMAT进行初始化，还进行一些配置相关工作
        FORMAT = new HanyuPinyinOutputFormat();
        //设置转化后的英文字母全小写
        FORMAT.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        //设置不带音调
        FORMAT.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        //特殊字符用v代替  绿(lu) ->lv
        FORMAT.setVCharType(HanyuPinyinVCharType.WITH_V);
    }

    /**
     * 传入一个文件夹的名称，返回全拼音字符串和首字母小写字符串
     * 若文件名包含其他字符，英文，数字，不作处理直接保存
     * @param fileName
     * @return
     */
    public static String[] getPinyinByFilename(String fileName){
        //返回全拼音字符串和首字母小写字符串
        String[] ret = new String[2];
        //遍历文件名，碰到中文转化为拼音，碰到其他字符直接保存
        StringBuffer allName = new StringBuffer();
        StringBuffer firstCharacter = new StringBuffer();
        for(Character c : fileName.toCharArray()){
            try {
                //将字符转化为拼音
                String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(c,FORMAT);
                if(pinyins == null || pinyins.length == 0){
                     //这个字符是非中文字符
                    allName.append(c);
                    firstCharacter.append(c);
                }else{
                    //是中文字符 和 -> [he,huo..]
                    allName.append(pinyins[0]);
                    firstCharacter.append(pinyins[0].charAt(0));
                }
            } catch (BadHanyuPinyinOutputFormatCombination badHanyuPinyinOutputFormatCombination) {
                //这个字符是非中文字符
                allName.append(c);
                firstCharacter.append(c);
            }
        }
        ret[0] = allName.toString();
        ret[1] = firstCharacter.toString();
        return ret;
    }

    /**
     * 判断给定的字符串是否包含汉字
     * @param name
     * @return
     */
    public static boolean containsChinese(String name) {
        return name.matches(".*" +CHINESE_PATTERN + ".*");
    }
}

Util工具类

对日期格式进行设置，将文件大小进行转化，判断是否是文件夹

package util;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 工具类
 */
public class Util {

    //设置日期格式
    public static final String DATE_PATTERN = "yy-MM-dd hh:mm:ss";

    /**
     * 传入一个文件大小，返回不同的单位
     * B,KB,MB,GB
     * @param size
     * @return
     */
    public static String parseSize(Long size) {
        String[] unit = {"B","KB","MB","GB"};
        int flag = 0;
        while (size > 1024){
            size/=1024;
            flag ++;
        }
        return size + unit[flag];
    }

    public static String parseIsDir(Boolean directory) {
        return directory ? "文件夹" : "文件";
    }

    public static String parseLMT(Date lastModified) {
        return new SimpleDateFormat(DATE_PATTERN).format(lastModified);
    }
}

Main类

项目启动类

import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;

/**
 * @author yuisama
 * @date 2022/07/06 15:06
 **/
public class Main extends Application {

    @Override
    public void start(Stage primaryStage) throws Exception{
        Parent root = FXMLLoader.load(getClass().getClassLoader().getResource("app.fxml"));
        primaryStage.setTitle("search_everything");
        primaryStage.setScene(new Scene(root, 1000, 800));
        primaryStage.show();
    }
    public static void main(String[] args) {
        launch(args);
    }
}

资源包

app.fxml 前端代码

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.control.cell.*?>

<GridPane fx:id="rootPane" alignment="center" hgap="10" vgap="10" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/8" fx:controller="app.Controller">
    <children>

        <Button onMouseClicked="#choose" prefWidth="90" text="选择目录" GridPane.columnIndex="0" GridPane.rowIndex="0" />
        <Label fx:id="srcDirectory">
            <GridPane.margin>
                <Insets left="100.0" />
            </GridPane.margin>
        </Label>
        <TextField fx:id="searchField" prefWidth="900" GridPane.columnIndex="0" GridPane.rowIndex="1" />

        <TableView fx:id="fileTable" prefHeight="1000" prefWidth="1300" GridPane.columnIndex="0" GridPane.columnSpan="2" GridPane.rowIndex="2">
            <columns>
                <TableColumn fx:id="nameColumn" prefWidth="220" text="名称">
                    <cellValueFactory>
                        <PropertyValueFactory property="name" />
                    </cellValueFactory>
                </TableColumn>
                <TableColumn prefWidth="400" text="路径">
                    <cellValueFactory>
                        <PropertyValueFactory property="path" />
                    </cellValueFactory>
                </TableColumn>
                <TableColumn fx:id="isDirectory" prefWidth="90" text="文件类型">
                    <cellValueFactory>
                        <PropertyValueFactory property="isDirectoryText" />
                    </cellValueFactory>
                </TableColumn>
                <TableColumn fx:id="sizeColumn" prefWidth="90" text="大小(B)">
                    <cellValueFactory>
                        <PropertyValueFactory property="sizeText" />
                    </cellValueFactory>
                </TableColumn>
                <TableColumn fx:id="lastModifiedColumn" prefWidth="160" text="修改时间">
                    <cellValueFactory>
                        <PropertyValueFactory property="lastModifiedText" />
                    </cellValueFactory>
                </TableColumn>
            </columns>
        </TableView>
    </children>
</GridPane>

数据表创建代码

-- drop table if exists file_meta;
    create table if not exists file_meta(
        name varchar(50) not null,
        path varchar(100) not null,
        is_directory boolean not null,
        size bigint ,
        last_modified timestamp not null,
        pinyin varchar(200) ,
        pinyin_first varchar(50)
    );

Maven

构建Java项目，对jar包进行管理

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.guang.hu</groupId>
    <artifactId>search_everything</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
            <version>2.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.xerial</groupId>
            <artifactId>sqlite-jdbc</artifactId>
            <version>3.36.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.10.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <!-- 指定入口类 -->
                            <mainClass>Main</mainClass>
                            <!-- 在jar的MF文件中生成classpath属性 -->
                            <addClasspath>true</addClasspath>
                            <!-- classpath前缀,即依赖jar包的路径 -->
                            <classpathPrefix>lib/</classpathPrefix>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>3.3.0</version>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!-- 指定依赖包的输出路径，需与上方的classpathPrefix保持一致 -->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>