Java通过SVNKit库操作SVN，实现文件上传、删除功能（完整代码）

最新推荐文章于 2024-04-17 14:59:18 发布
最新推荐文章于 2024-04-17 14:59:18 发布
阅读量2.6k 收藏 15
点赞数 6
分类专栏： java 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Warren_one/article/details/105715525
版权

最近应客户需求，研究了下Java实现附件上传到SVN功能。

SVNKit官方文档：https://svnkit.com/javadoc/index.html

SVNKit开发指南 ：https://pan.baidu.com/s/1EsEPp41IxHhw3KyMUUwo6A   提取码 ：558n

本文参照博客：https://blog.csdn.net/yxf771hotmail/article/details/88311508

 

svnkit版本：1.10.1 

<dependency>
    <groupId>org.tmatesoft.svnkit</groupId>
    <artifactId>svnkit</artifactId>
    <version>1.10.1</version>
</dependency>

svnConfig.properties 配置文件，存放在 resources目录下

# svn服务器路径
svn.svnUrl =https://xxx/svn
svn.username =root
svn.password =123456

详细代码如下,  修改完配置后可直接复制到本地执行main方法运行。

package com.XXX.common.utils;


import org.tmatesoft.svn.core.*;
import org.tmatesoft.svn.core.auth.ISVNAuthenticationManager;
import org.tmatesoft.svn.core.internal.io.dav.DAVRepositoryFactory;
import org.tmatesoft.svn.core.internal.io.fs.FSRepositoryFactory;
import org.tmatesoft.svn.core.internal.io.svn.SVNRepositoryFactoryImpl;
import org.tmatesoft.svn.core.internal.wc.DefaultSVNOptions;
import org.tmatesoft.svn.core.io.SVNRepository;
import org.tmatesoft.svn.core.io.SVNRepositoryFactory;
import org.tmatesoft.svn.core.wc.SVNClientManager;
import org.tmatesoft.svn.core.wc.SVNRevision;
import org.tmatesoft.svn.core.wc.SVNUpdateClient;
import org.tmatesoft.svn.core.wc.SVNWCUtil;

import java.io.File;
import java.util.ResourceBundle;

/**
 * @ClassName SvnKitUtils
 * @Description svn公共类
 * @Author hzh
 * @Date 2020/4/21
 * @Version 1.0
 */

public class SvnKitUtils {

    private SVNClientManager clientManager;
    private ISVNAuthenticationManager authManager;
    private SVNRepository repository;

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

    /**
     * 启动svn连接
     * @throws SVNException 异常信息
     */
    public SvnKitUtils()throws SVNException {
        try {
            this.createDefaultAuthenticationManager(svnUsername, svnPassword);
            this.authSvn(svnUrl);
        } catch (SVNException e) {
            throw new RuntimeException(e.getMessage());
        }
    }

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

    /**
     *
     * @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());
        }
    }

    /**
     * 验证登录svn
     * @param svnUrl 用户svn的仓库地址
     * @throws SVNException 异常信息
     */
    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());
        }
    }

    /**
     * 添加文件和目录到版本控制下
     * @param wcPath 工作区路径
     * @throws SVNException 异常信息
     */
    private void addEntry(File wcPath) throws SVNException{
        try {
            clientManager.getWCClient().doAdd(new File[] { wcPath }, true,
                    false, false, SVNDepth.INFINITY, false, false, true);
        } catch (SVNException e) {
            throw new RuntimeException("SVN添加文件到版本控制下失败：" + e.getMessage());
        }
    }


    /**
     * 将工作副本提交到svn
     * @param wcPath  被提交的工作区路径
     * @param keepLocks 是否在SVN仓库中打开或不打开文件
     * @param commitMessage 提交信息
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private SVNCommitInfo commit(File wcPath, boolean keepLocks, String commitMessage) throws SVNException {
        try {
            return clientManager.getCommitClient().doCommit(
                    new File[] { wcPath }, keepLocks, commitMessage, null,
                    null, true, false, SVNDepth.INFINITY);
        } catch (SVNException e) {
            throw new RuntimeException("SVN提交失败：" + e.getMessage());
        }
    }

    /**
     *  创建svn文件夹
     * @param url svn地址
     * @param commitMessage 提交信息
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private SVNCommitInfo makeDirectory(SVNURL url,String commitMessage) throws SVNException {
        try {
            return clientManager.getCommitClient().doMkDir(new SVNURL[] { url }, commitMessage);
        } catch (SVNException e) {
            throw new RuntimeException("SVN新建文件夹失败：" + e.getMessage());
        }
    }

    /**
     *  删除
     * @param url svn地址
     * @param commitMessage 提交信息
     * @return
     * @throws SVNException
     */
    private SVNCommitInfo delete(SVNURL url,String commitMessage) throws SVNException {
        try {
            return clientManager.getCommitClient().doDelete(new SVNURL[] { url }, commitMessage);
        } catch (SVNException 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) throws SVNException{
        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());
        }
    }

    /**
     * 递归检查不在版本控制的文件，并add到svn
     * @param wc  检查的文件
     * @throws SVNException 异常信息
     */
    private void checkVersiondDirectory(File wc) throws SVNException{
        if(!SVNWCUtil.isVersionedDirectory(wc)){
            this.addEntry(wc);
        }
        if(wc.isDirectory()){
            for(File sub:wc.listFiles()){
                if(sub.isDirectory() && sub.getName().equals(".svn")){
                    continue;
                }
                checkVersiondDirectory(sub);
            }
        }
    }

    /**
     * 删除目录（文件夹）以及目录下的文件
     * @param   sPath 被删除目录的文件
     * @return  目录删除成功返回true，否则返回false
     */
    private boolean deleteDirectory(String sPath) {
        //如果sPath不以文件分隔符结尾，自动添加文件分隔符
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        //如果dir对应的文件不存在，或者不是一个目录，则退出
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        //删除文件夹下的所有文件(包括子目录)
        File[] files = dirFile.listFiles();
        if(files != null){
            for (int i = 0; i < files.length; i++) {
                //删除子文件
                if (files[i].isFile()) {
                    flag = deleteFile(files[i].getAbsolutePath());
                    if (!flag) {
                        break;
                    }
                } else {
                    //删除子目录
                    flag = deleteDirectory(files[i].getAbsolutePath());
                    if (!flag){
                        break;
                    }
                }
            }
        }
        if (!flag){
            return false;
        }
        //删除当前目录
        if (dirFile.delete()) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 删除单个文件
     * @param   sPath    被删除文件的文件
     * @return 单个文件删除成功返回true，否则返回false
     */
    private boolean deleteFile(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 路径为文件且不为空则进行删除
        if (file.isFile() && file.exists()) {
            file.delete();
            flag = true;
        }
        return flag;
    }

    /**
     *  根据路径删除指定的目录或文件，无论存在与否
     *@param sPath  要删除的目录或文件
     *@return 删除成功返回 true，否则返回 false。
     */
    private boolean DeleteFolder(String sPath) {
        boolean flag = false;
        File file = new File(sPath);
        // 判断目录或文件是否存在 不存在返回 false
        if (!file.exists()) {
            return flag;
        } else {
            // 判断是否为文件
            if (file.isFile()) {
                // 为文件时调用删除文件方法
                return deleteFile(file.getAbsolutePath());
            } else {
                // 为目录时调用删除目录方法
                return deleteDirectory(file.getAbsolutePath());
            }
        }
    }

    /**
     * 更新SVN工作区
     * @param wcPath 工作区路径
     * @param updateToRevision 更新版本
     * @param depth update的深度：目录、子目录、文件
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private long update(File wcPath, SVNRevision updateToRevision, SVNDepth depth) throws SVNException{
        SVNUpdateClient updateClient = clientManager.getUpdateClient();
        updateClient.setIgnoreExternals(false);
        try {
            return updateClient.doUpdate(wcPath, updateToRevision,depth, false, false);
        } catch (SVNException e) {
            throw new RuntimeException("更新SVN工作区失败：" + e.getMessage());
        }
    }

    /**
     * SVN仓库文件检出
     * @param url 文件url
     * @param revision 检出版本
     * @param destPath 目标路径
     * @param depth checkout的深度，目录、子目录、文件
     * @return 返回信息
     * @throws SVNException 异常信息
     */
    private long checkout(SVNURL url, SVNRevision revision, File destPath, SVNDepth depth) throws SVNException{
        SVNUpdateClient updateClient = clientManager.getUpdateClient();
        updateClient.setIgnoreExternals(false);
        try {
            return updateClient.doCheckout(url, destPath, revision, revision,depth, false);
        } catch (SVNException e) {
            throw new RuntimeException("检出SVN仓库失败：" + e.getMessage());
        }
    }

    /**
     * @param svnPathUrl svn地址
     * @param workspace 工作区
     * @param filepath 上传的文件地址
     * @param filename 文件名称
     * @throws SVNException 异常信息
     */
    private void checkWorkCopy(String svnPathUrl,String workspace,String filepath,String filename)throws SVNException{
        SVNURL repositoryURL = null;
        if(StringUtils.isNotBlank(filepath)){
            svnPathUrl = svnPathUrl + filepath;
        }
        try {
            repositoryURL = SVNURL.parseURIEncoded(svnPathUrl);
        } catch (SVNException e) {
            throw new RuntimeException("解析svnUrl失败：" + e.getMessage());
        }

        File wc = new File(workspace);
        File wc_project = new File( workspace);

        SVNURL projectURL = null;
        try {
            projectURL = repositoryURL.appendPath(filename, false);
        } catch (SVNException e) {
            throw new RuntimeException("解析svnUrl文件失败：" + e.getMessage());
        }

        /*
         *  循环新建svn文件夹，不能直接把多个文件夹一块传过去新建，否则报错
         */
        if(StringUtils.isNotBlank(filepath) && filepath.contains("/")){
            String[] filepathArray = filepath.split("/");
            SVNURL svnFilePath = SVNURL.parseURIEncoded(svnUrl);
            for (String path : filepathArray) {
                //jdk8 分割后第一个为空
                if(StringUtils.isBlank(path)){
                    continue;
                }
                svnFilePath = svnFilePath.appendPath("/"+path,false);
                //检查文件夹在svn中是否存在
                boolean flag = this.isURLExist(svnFilePath);
                if(!flag){
                    //新建文件夹；  此操作要在checkout之前，否则checkout会报错
                    makeDirectory(svnFilePath,"新建文件夹");
                }
            }
        }

        if(!this.isWorkingCopy(wc)){
            if(!this.isURLExist(projectURL)){
                this.checkout(repositoryURL, SVNRevision.HEAD, wc, SVNDepth.EMPTY);
            }else{
                this.checkout(projectURL, SVNRevision.HEAD, wc_project, SVNDepth.INFINITY);
            }
        }else{
            this.update(wc, SVNRevision.HEAD, SVNDepth.INFINITY);
        }
    }

    /**
     * 循环删除.svn目录
     * @param spath
     */
    private void deletePointSVN(String spath){
        File wc = new File(spath);
        File[] files = wc.listFiles();
        if(files != null){
            for(File sub:files){
                if(sub.isDirectory() && sub.getName().equals(".svn")){
                    this.deleteDirectory(sub.getAbsolutePath());
                    continue;
                }
                if(sub.isDirectory()){
                    deletePointSVN(sub.getAbsolutePath());
                }
            }
        }
    }

    /**
     * @param  workspace 文件工作空间路径
     * @param filepath 上传的文件地址 以"/"开头的路径，用于在svn上新建对应文件夹
     * @param filename 上传的文件名称
     * @param isOverwrite 是否覆盖
     * @throws SVNException 异常信息
     */
    public void upload(String workspace, String filepath,String filename,Boolean isOverwrite)throws SVNException{
        String svnFilePath = svnUrl +"/"+filename;
        if(StringUtils.isNotBlank(filepath)){
            svnFilePath = svnUrl + filepath + "/" +filename;
        }
        //检查文件在svn中是否存在
        boolean flag = this.isURLExist(SVNURL.parseURIEncoded(svnFilePath));
        String workFilePath = workspace + "/"+ filename;
        File file = new File(workFilePath);
        /*
         * 切合实际业务场景来选择是否需要，
         * 一般本地demo测试需要，同时注释结束后删除.svn。
         * 线上环境不建议使用，线上文件最好加个时间戳来区分文件，防止相同名称文件，
         * 如果文件不加时间戳，建议先查询该文件是否存在，若存在，先删除再上传。
         */
        if(flag){
            if(isOverwrite){
                this.commit(file, true, "commit file:"+file);
            }
        }else{
            //开始前删除以前的.svn文件目录
            deletePointSVN(workspace);
            //checkOut .svn
            this.checkWorkCopy(svnUrl, workspace, filepath,filename);
            this.checkVersiondDirectory(file);
            this.commit(file, true, "commit file:"+file);
            /*
             * 结束后删除以前的.svn文件目录。
             * 根据实际情况选择是否在结束后删除，因为.svn删除后，线上若有相同文件，会默认直接提交，
             * 然后没有.svn文件会报错。
             */
            deletePointSVN(workspace);
        }

    }

    /**
     *  删除svn上文件
     * @param filepath 上传的文件地址
     * @param filename 文件名称
     * @throws SVNException
     */
    public void deleteSvnFile(String filepath, String filename)throws SVNException{
        String svnFilePath = svnUrl +"/"+filename;
        if(StringUtils.isNotBlank(filepath)){
            svnFilePath = svnUrl + filepath + "/" +filename;
        }
        //检查文件在svn中是否存在
        boolean flag = this.isURLExist(SVNURL.parseURIEncoded(svnFilePath));
        if(flag){
            this.delete(SVNURL.parseURIEncoded(svnFilePath),"删除文件："+svnFilePath);
        }

    }

    public static void main(String[] args) throws SVNException {
        try {
            String filename = "354.txt";
            String workspace = "D:/WorkBase/files";
            String filepath = "/file/2";
            SvnKitUtils svnDeal = new SvnKitUtils();
            svnDeal.upload(workspace,filepath, filename,true);
//            svnDeal.deleteSvnFile(filepath,filename);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



}

   愿本篇博客能够解决您的困惑！    转载请标明！！！

Warren_one
关注
专栏目录
java调用svn的方法(基本操作，并不全)
yehui18sui的专栏
05-02 2383
首先要使用svn的方法，就需要在工程中增加svn的jar包：  jar包到http://subversion.apache.org/download/#recommended-release  下载   ；  source包可以到   http://subversion.apache.org/download/        下载 jar导入工程后，就可以使用了 新建两个java文件：
Java 利用 svnKit 操作SVN 【获取所有文件夹、添加文件、文件下载】
08-10 1235
又遇到了一个功能点，网上的参考内容挺少的，终于把功能实现了，记一下，方便以后遇到坑的时候看看 <!-- more --> 主要功能点 获取一个SVN目录中的所有子文件夹以及文件 可以利用参数控制是否进行递归获取所有的文件夹中的子类 可以利用参数控制获取的是文件还是文件...
svnkit-1.8.7.jar
03-31
svnkit-1.8.7.jar svn1.8.7的jar包
Java 操作svn 使用svnkit进行新增上传、更新、删除文件等操作
weixin_46678922的博客
07-19 2212
Java 操作svn 使用svnkit进行新增上传、更新、删除文件等操作
学习记录693@java使用svnkit实战之上传文件到svn
最新发布
教练我想学编程
04-17 517
我是在linux通过yum install subversion 安装的svn，访问的协议是svn协议，也就是url是svn://ip/…的方式，网上几乎所有的文章在试用svnkit的时候都是http协议访问svn服务器的。以上操作就是把本地的test.docx文件上传到你svn仓库的test文件夹下面，并且重命名为123.docx，你执行代码后可以在本地的小乌龟执行更新操作，会发现文件真的增加了这个。另外注意svn://你的ip/test/123.docx，ip后面的目录如果不存在会自动创建。
SVNKit学习——wiki+简介（二）
desfmgs5372的博客
12-06 402
　　这篇文章是参考SVNKit官网在wiki的文档，做了个人的理解~ 　　首先抛出一个疑问，Subversion是做什么的，SVNKit又是用来干什么的？ 　　相信一般工作过的同学都用过或了解过svn，不了解的同学可以到官网看下，这里不作为本文重点。 　　需要理解的概念： 　　　　仓库（Repository）：是一个特殊的结构，记录文件版本管理的状态。 　　　　工作副本（Wor...
使用SVNkit删除版本库的文件
wjy320的专栏
01-06 304
源网址：http://wiki.svnkit.com/Committing_To_A_Repository Editing Operation: commiting to a repository The low-level layer provides for an ability tobuildandchangetree-like hierarchies in a repository ...
JAVA代码实现远程操作服务器文件
11-21
通过使用SVNKit库和Trilead SSH2库，可以实现远程服务器文件的上传、下载、复制、移动、删除等操作。这些操作可以通过JAVA代码来实现。 4. 使用SCPClient实现文件上传和下载 SCPClient是一个基于ssh的文件传输协议...
使用 SVNKit API 实现Java纯Java操作SVN与身份验证
- 虽然没有提供完整的 `makeDirectory()` 方法代码，但根据类名和功能描述，我们可以推测这个类可能还包括其他与SVN操作相关的功能，比如文件上传、修改、删除、版本回滚等。这些操作通常涉及到 `SVNClient` 对象...
java 获取svn日志信息_SVNKit --记一次获取SVN提交信息的经历
weixin_29023079的博客
02-27 1732
学会记录，时常反思，不断积累前言在工作中，遇到一个需求，需要监控研发人员每天提交的代码行数和代码bug数，关于代码的bug可以使用源码质量扫描工具sonar解决，但是对于svn每天提交的代码记录，哪种方式获取，对以后的数据筛选、存储、展示更有利，值得深思，后来，查阅资料，了解到了SVNKit 这个工具。介绍SVNKit (JavaSVN) 是一个纯 Java 的 SVN 客户端库,使用 SVNKi...
svnkit-1.8.0.zip
07-31
SVNKit (JavaSVN) 是一个纯 Java 的 SVN 客户端库,使用 SVNKit 无需安装任何 SVN 的客户端,支持各种操作系统。 这不是一个开源的类库,但你可以免费使用。 通过SVNKit,你可以在SVN上开发出自己的应用
svnkit1.8.15
08-06
svnkit，可以通过该jar获取svn上传历史信息，提交明细等。
java实现svn更新和提交.rar
05-28
基于svnkit-1.9.3和svnkit-cli-1.9.3，java实现svn更新和提交。
svnkit-1.8.6.jar
12-09
svnkit-1.8.6.jar
svnkit-dav-1.9.2.war
05-15
svn二次开发的包，有需要要进行自己下载，可以挂在tomca他上。
通过Java代码，将文件提交到指定的SVN路径
veronica199003的博客
06-09 1978
Java 上传文件到Svn 1、在pom.xml文件中添加需要配置的svnkit版本号，然后通过maven进行更新下载配置文件 <dependency> <groupId>org.tmatesoft.svnkit</groupId> <artifactId>svnkit</artifactId> <version>1.10.1</version> </dependency> 2,、配置s
java通过svnkit类库操作SVN，实现文件上传
风子杨的博客中心
03-07 5459
java通过svnkit类库操作SVN，实现文件上传 废话不多说，直接上代码，亲测可用！ package com.word; import java.io.*; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmatesoft.svn.core.SVNDepth; import org.tmatesoft.svn.core...
java调用svnkit工具类上传本地文件到svn服务器
weixin_30839881的博客
04-24 452
package org.jenkinsci.plugins.svn.upload.step; import java.io.*; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmatesoft.svn.core.SVNDepth; import org.tmatesoft.svn.core.SVNException...
svnkit:通过java操作svn
回家换拖鞋的专栏
05-31 2105
官方文档：http://wiki.svnkit.com/Getting_Started_With_SVNKit demo: 获取提交历史 public static List getLogs() throws SVNException{ /* * 对版本库进行初始化操作，使用https或http访问svn时，执行DAVRepositoryFactory.set
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值