java svn获取文件

/**
 * @ClassName SvnKitUtils
 * @Author JIANGLANG
 * @Description svn
 * @Date 13:28 2023/11/28
 **/
public class SvnKitUtils {
    private SVNClientManager clientManager;
    private ISVNAuthenticationManager authManager;
    private SVNRepository repository;

    /**
     * 读取配置文件 只能读取properties类型的文件, 读取的时候只需要文件名, 不需要后缀
     */
    private static ResourceBundle rb = ResourceBundle.getBundle("svnConfig");
    private static String svnUrl = rb.getString("svn.svnUrl");
    private static String svnUsername = rb.getString("svn.username");
    private static String svnPassword = rb.getString("svn.password");

    /**
     * @return
     * @Author JIANGLANG
     * @Description 初始化svn连接
     * @Date 13:29 2023/11/28
     * @Param []
     **/
//    TODO 需要用的时候就放开 -- 配置文件svnConfig.properties必须配置信息通过
    public SvnKitUtils() {
//        System.out.println("******svn获取---初始化******");
//        try {
            验证
//            this.createDefaultAuthenticationManager(svnUsername, svnPassword);
//            this.authSvn(svnUrl);
//        } catch (SVNException e) {
//            throw new RuntimeException(e.getMessage());
//        }
    }

    /**
     * @param username svn用户名称
     * @param password svn用户密码
     * @throws SVNException 异常信息
     */
    private void createDefaultAuthenticationManager(String username, String password) throws SVNException {
        try {
            // 身份验证
            authManager = SVNWCUtil.createDefaultAuthenticationManager(username, password.toCharArray());
        } catch (Exception e) {
            throw new RuntimeException("SVN身份认证失败：" + e.getMessage());
        }
    }

    /**
     * 通过不同的协议初始化版本库
     */
    private void setupLibrary() {
        DAVRepositoryFactory.setup();
        SVNRepositoryFactoryImpl.setup();
        FSRepositoryFactory.setup();
    }

    /**
     * 验证登录svn
     *
     * @param svnUrl 用户svn的仓库地址
     */
    private void authSvn(String svnUrl) throws SVNException {
        // 初始化版本库
        setupLibrary();
        try {
            repository = SVNRepositoryFactory.create(SVNURL.parseURIEncoded(svnUrl));
        } catch (SVNException e) {
            throw new RuntimeException("SVN创建库连接失败：" + e.getMessage());
        }
        // 创建身份验证管理器
        repository.setAuthenticationManager(authManager);
        DefaultSVNOptions options = SVNWCUtil.createDefaultOptions(true);
        try {
            //创建SVN实例管理器
            clientManager = SVNClientManager.newInstance(options, authManager);
        } catch (Exception e) {
            throw new RuntimeException("SVN实例管理器创建失败：" + e.getMessage());
        }
    }

    /**
     * 确定path是否是一个工作空间
     *
     * @param path 文件路径
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private boolean isWorkingCopy(File path) throws SVNException {
        if (!path.exists()) {
            return false;
        }
        try {
            if (null == SVNWCUtil.getWorkingCopyRoot(path, false)) {
                return false;
            }
        } catch (SVNException e) {
            throw new RuntimeException("path是否是一个工作空间 失败：" + e.getMessage());
        }
        return true;
    }

    /**
     * 确定一个URL在SVN上是否存在
     *
     * @param url svn访问地址
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private boolean isURLExist(SVNURL url) {
        try {
            SVNRepository svnRepository = SVNRepositoryFactory.create(url);
            svnRepository.setAuthenticationManager(authManager);
            SVNNodeKind nodeKind = svnRepository.checkPath("", -1);
            return nodeKind == SVNNodeKind.NONE ? false : true;
        } catch (SVNException e) {
            throw new RuntimeException("URL在SVN否存在失败：" + e.getMessage());
        }
    }

    /**
     * @return com.wide.program.entity.SvnEntity
     * @Author JIANGLANG
     * @Description 获取svn下所有的目录
     * @Date 17:09 2023/11/28
     * @Param [path]
     **/
    public SvnEntity getFileListBySVNRepository(String path) throws SVNException {
        // 遍历所有目录，获取所有文件路径
        SvnEntity svnEntity = new SvnEntity();
        svnEntity.setSrcName(repository.getLocation().getPath());
        svnEntity.setSrc(path);
        // 获取所有文件路径
        listFiles(repository, path, svnEntity);
//        System.out.println(svnEntity);

        return svnEntity;
    }

    /**
     * @return void
     * @Author JIANGLANG
     * @Description
     * @Date 13:32 2023/11/28
     * @Param [repository, path svn路径下的路径, filePaths存储数据]
     **/
    private static void listFiles(SVNRepository repository, String path, SvnEntity svnEntity) throws SVNException {
        Collection entries = repository.getDir(path, SVNRevision.HEAD.getNumber(), null, (Collection) null);
        Iterator iterator = entries.iterator();
        List<SvnEntity> svnEntities1 = new ArrayList<>();
        while (iterator.hasNext()) {
            SVNDirEntry entry = (SVNDirEntry) iterator.next();
            String filePath = (path.equals("")) ? entry.getName() : path + "/" + entry.getName();
            SvnEntity svnEntity1 = new SvnEntity();
            svnEntity1.setSrc(filePath);
            svnEntity1.setSrcName(entry.getName());
            svnEntities1.add(svnEntity1);
            if (entry.getKind() == SVNNodeKind.FILE) {
            } else if (entry.getKind() == SVNNodeKind.DIR) {
                // 文件夹
                listFiles(repository, filePath, svnEntity1);
            }
        }
        svnEntity.setChildren(svnEntities1);
    }

    /**
     * @return java.lang.String
     * @Author JIANGLANG
     * @Description svn上面文件下载
     * @Date 14:25 2023/11/29
     * @Param [src, localFilePath] src:svn上文件路劲，localFilePath本地文件夹路劲
     **/
    public int downloadBySVN(String src, String fileSavePath) throws SVNException {
        //判断当前目录是否存在
        File dir = new File(fileSavePath + src);
        //不存在创建
        if (!dir.exists() && !dir.isDirectory()) {
            dir.getParentFile().mkdirs();
        }
        String localFilePath = fileSavePath + src;

        SVNProperties fileProperties;
        FileOutputStream outputStream;
        SVNURL url = SVNURL.parseURIEncoded(svnUrl + "/" + src);
        try {
            SVNRepository svnRepository = SVNRepositoryFactory.create(url);
            svnRepository.setAuthenticationManager(authManager);
            SVNNodeKind nodeKind = svnRepository.checkPath("", -1);
            if (nodeKind == SVNNodeKind.NONE) {
                // SVN上不存在该地址
                return 2;
            } else if (nodeKind == SVNNodeKind.DIR) {
                // SVN地址未指向文件
                return 3;
            }
            fileProperties = new SVNProperties();
            outputStream = new FileOutputStream(new File(localFilePath));
            svnRepository.getFile("", -1, fileProperties, outputStream);
            outputStream.close();

            // 文件下载成功
            return 0;
        } catch (SVNException | IOException e) {
            e.printStackTrace();
//            return "错误:" + e.getMessage();
            return -1;
        }
    }

    /**
     * @return java.lang.String
     * @Author JIANGLANG
     * @Description svn处理，如果是文件就下载，如果是文件夹就整个文件夹下载
     * @Date 14:25 2023/11/29
     * @Param [src, localFilePath] src:svn上文件路劲，localFilePath本地文件夹路劲
     **/
    private int downloadFileFolderBySVN(SvnEntity svnEntity, String fileSavePath) throws SVNException {
        //是否有子目录
        if (svnEntity.hasChildren()) {
            for (SvnEntity child : svnEntity.getChildren()) {
                int i = downloadFileFolderBySVN(child, fileSavePath);
//                不满足条件和报错不放过
//                if (i != 1)
//                    return i;
            }
        } else {
            String src = svnEntity.getSrc();
            int i = downloadBySVN(src, fileSavePath);
            System.out.println(i + "------" + src);
//            不满足条件和报错不放过
//            if (i != 1)
//                return i;
        }
        // 执行完成结果
        return 1;
    }

    public int download(String path, String fileSavePath) throws SVNException {
        // 判断svn文件路径是否存在
        SVNURL url = SVNURL.parseURIEncoded(svnUrl + "/" + path);
        if (!isURLExist(url))
            // 路径不存在
            return 2;
        //根据路径获取结构体
        SvnEntity svnEntity = getFileListBySVNRepository(path);
        if (svnEntity == null)
            // 路径文件不存在
            return 4;
        return downloadFileFolderBySVN(svnEntity, fileSavePath);
    }

    public static void main(String[] args) {
        try {
            SvnKitUtils svnDeal = new SvnKitUtils();
            int download = svnDeal.download("update/354.txt", "D:/mine/svn-download-test/");
            System.out.println(download);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}