简单实现了下：

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.*;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;

/**
 * 文件/目录加解密相关
 * @author: Nemo
 * @date: 2019/3/19.
 */
public class FileCrote {

    /**
     * 加密后的文件后缀
     */
    private static final String SUBFIX = ".enc";

    /**
     * 执行路径
     */
    private static String path = "";

    /**
     * 执行模式 1加密 2解密
     */
    private static String mode = "1";

    /**
     * 执行密码
     */
    private static String pass = "";

    private static String currentFilePath = null;

    /**
     * 根据路径加密文件
     * 1、如果是目录，则找它下面的文件进行加密
     * 2、如果是文件，则直接加密
     * @param path
     * @throws IOException
     */
    private static void encrypt(String path) throws IOException, GeneralSecurityException {
        System.out.println("开始处理"+path);
        File file = new File(path);
        if(!file.exists()){
            System.out.println("需加密的路径不存在:"+path);
            return;
        }
        if(file.isDirectory()){
            //目录则遍历其下的文件
            File[] files = file.listFiles();
            if(files == null){
                return;
            }
            for (File subFile : files) {
                encrypt(subFile.getAbsolutePath());
            }
        }else{
            //文件则直接加密
            encrypt(file);
        }
    }

    /**
     * 文件加密
     * @param file
     * @throws IOException
     */
    private static void encrypt(File file) throws IOException, GeneralSecurityException {
        String path = file.getAbsolutePath();
        if(path.endsWith(SUBFIX)){
            System.out.println("已加密文件不需再次加密"+path);
            return;
        }

        String encFilePath = path + SUBFIX;
        File encFile = new File(encFilePath);

        System.out.println("开始加密文件"+path);
        encryptFile(file,encFile,Cipher.ENCRYPT_MODE);
    }

    /**
     * 加解密文件操作
     * @param srcFile
     * @param encFile
     * @throws IOException
     */
    private static void encryptFile(File srcFile, File encFile,int mode) throws IOException, GeneralSecurityException {
        if(!srcFile.exists()){
            System.out.println("source file not exixt");
            return;
        }

        currentFilePath = srcFile.getAbsolutePath();

        //密码
        Cipher cipher = getCipher(mode);

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(encFile);

            //真正处理
            crypt(fis, fos, cipher);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                fis.close();
            }
            if (fos != null) {
                fos.close();
            }
        }

        //源文件删除
        srcFile.delete();
    }

    /**
     * 得到加解密Cipher
     * @param mode
     * @return
     * @throws GeneralSecurityException
     */
    private static Cipher getCipher(int mode) throws GeneralSecurityException {
        String type = "AES";
        Cipher cipher = Cipher.getInstance(type+"/ECB/PKCS5Padding");
        KeyGenerator kgen = KeyGenerator.getInstance(type);
        kgen.init(128, new SecureRandom(pass.getBytes()));
        SecretKey key = kgen.generateKey();
        cipher.init(mode,key);
        return cipher;
    }

    /**
     * 加密解密流
     * @param in        加密解密前的流
     * @param out       加密解密后的流
     * @param cipher    加密解密
     * @throws IOException
     * @throws GeneralSecurityException
     */
    private static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException, GeneralSecurityException {
        int blockSize = cipher.getBlockSize() * 1000;
        int outputSize = cipher.getOutputSize(blockSize);

        byte[] inBytes = new byte[blockSize];
        byte[] outBytes = new byte[outputSize];

        int inLength = 0;
        boolean more = true;
        while (more) {
            inLength = in.read(inBytes);
            if (inLength == blockSize) {
                int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
                out.write(outBytes, 0, outLength);
            } else {
                more = false;
            }
        }
        if (inLength > 0) {
            outBytes = cipher.doFinal(inBytes, 0, inLength);
        } else {
            outBytes = cipher.doFinal();
        }
        out.write(outBytes);
    }

    /**
     * 根据路径解密
     * 1、如果是目录，则找它下面的加密文件进行解密
     * 2、如果是文件，并且它是加密文件，则直接解密
     * @param path
     * @throws IOException
     */
    private static void decrypt(String path) throws IOException, GeneralSecurityException {
        System.out.println("开始处理"+path);
        File file = new File(path);
        if(!file.exists()){
            System.out.println("需解密的路径不存在:"+path);
            return;
        }
        if(file.isDirectory()){
            //目录则遍历其下的文件
            File[] files = file.listFiles();
            if(files == null){
                return;
            }
            for (File subFile : files) {
                decrypt(subFile.getAbsolutePath());
            }
        }else{
            decrypt(file);
        }
    }

    /**
     * 文件解密
     * @param file
     * @throws IOException
     */
    private static void decrypt(File file) throws IOException, GeneralSecurityException {
        String path = file.getAbsolutePath();
        if(!path.endsWith(SUBFIX)){
            System.out.println("非加密文件不需解密"+path);
            return;
        }
        System.out.println("开始解密文件"+path);

        String newPath = path.substring(0,path.length() - SUBFIX.length());
        encryptFile(file,new File(newPath),Cipher.DECRYPT_MODE);
    }

    /**
     * 字符串是否非空
     * @param s
     * @return
     */
    private static boolean isNotEmpty(String s){
        if (s == null || "".equals(s)) {
            return false;
        }
        return true;
    }

    /**
     * 开始处理
     * @throws IOException
     * @throws GeneralSecurityException
     */
    private static void deal() throws IOException, GeneralSecurityException {
        while (true) {
            print();
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String s = reader.readLine();
            if("path".equals(s)) {
                System.out.println("\r\n请输入执行路径\r\n");
                while (true) {
                    reader = new BufferedReader(new InputStreamReader(System.in));
                    s = reader.readLine();
                    if (!isNotEmpty(s)) {
                        System.out.println("\r\n请输入执行路径\r\n");
                        continue;
                    }else {
                        File file = new File(s);
                        if(!file.exists()){
                            System.out.println("\r\n该路径不存在，请重新输入\r\n");
                            continue;
                        }
                    }
                    path = s;
                    break;
                }
            } else if("pass".equals(s)) {
                System.out.println("\r\n请输入加/解密密码\r\n");
                while (true) {
                    reader = new BufferedReader(new InputStreamReader(System.in));
                    s = reader.readLine();
                    if (!isNotEmpty(s)) {
                        System.out.println("\r\n请输入加/解密密码\r\n");
                        continue;
                    }
                    pass = s;
                    break;
                }
            } else if ("1".equals(s)) {
                mode = s;
                System.out.println("\r\n当前已选模式：加密\n");
            } else if ("2".equals(s)) {
                mode = s;
                System.out.println("\r\n当前已选模式：解密\r\n");
            }else if("start".equals(s)){
                if(!isNotEmpty(path)) {
                    System.out.println("\r\n请输入加/解密密码再开始\r\n");
                    continue;
                }

                if(!isNotEmpty(pass)) {
                    System.out.println("\r\n请输入执行路径后再开始\r\n");
                    continue;
                }

                if ("1".equals(mode)) {
                    encrypt(path);
                    System.out.println("\r\n\r\n操作完成\r\n\r\n");
                } else {
                    try {
                        decrypt(path);
                        System.out.println("\r\n\r\n操作完成\r\n\r\n");
                    }catch (BadPaddingException e) {
                        System.out.println("文件："+currentFilePath+"解密失败，密码错误");
                    }
                }
            }else if("quit".equals(s)){
                System.exit(-1);
            } else {
                System.out.println("\r\n输入错误\r\n");
            }
        }
    }

    /**
     * 输出提示语
     */
    private static void print(){
        System.out.println("\r\n" +
                "输入path开始选择执行路径\r\n" +
                "输入pass开始选择加/解密密码\r\n" +
                "输入如下数字以选择处理模式：1 加密 2 解密\r\n" +
                "输入start则开始执行已选操作\r\n" +
                "输入quit则退出程序\r\n" +
                "当前选择路径："+path+"\r\n" +
                "当前选择模式："+mode+"\r\n" +
                "当前选择密码："+pass+"\r\n");
    }

    public static void main(String args[]) throws IOException, GeneralSecurityException {
        deal();
    }

}