纯java操作SVN，使用svnkit做commit,update 提交，更新操作

时间：2022-08-30 00:01:10
public class SVNUtil {

private static Logger logger = Logger.getLogger(SVNUtil.class);

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

/**
 * 验证登录svn
 */
public static SVNClientManager authSvn(String svnRoot, String username,
String password) {
// 初始化版本库
setupLibrary();

// 创建库连接
SVNRepository repository = null;
try {
repository = SVNRepositoryFactory.create(SVNURL
.parseURIEncoded(svnRoot));
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
return null;
}

// 身份验证
ISVNAuthenticationManager authManager = SVNWCUtil

.createDefaultAuthenticationManager(username, password);

// 创建身份验证管理器
repository.setAuthenticationManager(authManager);

DefaultSVNOptions options = SVNWCUtil.createDefaultOptions(true);
SVNClientManager clientManager = SVNClientManager.newInstance(options,
authManager);
return clientManager;
}

/**
 * Make directory in svn repository
 * @param clientManager
 * @param url 
 * eg: http://svn.ambow.com/wlpt/bsp/trunk 
 * @param commitMessage
 * @return
 * @throws SVNException
 */
public static SVNCommitInfo makeDirectory(SVNClientManager clientManager,
SVNURL url, String commitMessage) {
try {
return clientManager.getCommitClient().doMkDir(
new SVNURL[] { url }, commitMessage);
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return null;
}

/**
 * Imports an unversioned directory into a repository location denoted by a
 * destination URL
 * @param clientManager
 * @param localPath
 * a local unversioned directory or singal file that will be imported into a 
 * repository;
 * @param dstURL
 * a repository location where the local unversioned directory/file will be 
     * imported into
 * @param commitMessage
 * @param isRecursive 递归
 * @return
 */
public static SVNCommitInfo importDirectory(SVNClientManager clientManager,
File localPath, SVNURL dstURL, String commitMessage,
boolean isRecursive) {
try {
return clientManager.getCommitClient().doImport(localPath, dstURL,
commitMessage, null, true, true,
SVNDepth.fromRecurse(isRecursive));
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return null;
}

/**
 * Puts directories and files under version control
 * @param clientManager
 * SVNClientManager
 * @param wcPath 
 * work copy path
 */
public static void addEntry(SVNClientManager clientManager, File wcPath) {
try {
clientManager.getWCClient().doAdd(new File[] { wcPath }, false,
false, false, SVNDepth.fromRecurse(true), false, false,
true);
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
}

/**
 * Collects status information on a single Working Copy item
 * @param clientManager
 * @param wcPath
 * local item's path
 * @param remote
 * true to check up the status of the item in the repository, 
 *that will tell if the local item is out-of-date (like '-u' option in the SVN client's 
 *'svn status' command), otherwise false
 * @return
 * @throws SVNException
 */
public static SVNStatus showStatus(SVNClientManager clientManager,
File wcPath, boolean remote) {
SVNStatus status = null;
try {
status = clientManager.getStatusClient().doStatus(wcPath, remote);
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return status;
}

/**
 * Commit work copy's change to svn
 * @param clientManager
 * @param wcPath 
 *working copy paths which changes are to be committed
 * @param keepLocks
 *whether to unlock or not files in the repository
 * @param commitMessage
 *commit log message
 * @return
 * @throws SVNException
 */
public static SVNCommitInfo commit(SVNClientManager clientManager,
File wcPath, boolean keepLocks, String commitMessage) {
try {
return clientManager.getCommitClient().doCommit(
new File[] { wcPath }, keepLocks, commitMessage, null,
null, false, false, SVNDepth.fromRecurse(true));
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return null;
}

    /**
     * Updates a working copy (brings changes from the repository into the working copy).
     * @param clientManager
     * @param wcPath
     * working copy path
     * @param updateToRevision
     * revision to update to
     * @param depth
     * update的深度：目录、子目录、文件
     * @return
     * @throws SVNException
     */
public static long update(SVNClientManager clientManager, File wcPath,
SVNRevision updateToRevision, SVNDepth depth) {
SVNUpdateClient updateClient = clientManager.getUpdateClient();

/*
 * sets externals not to be ignored during the update
 */
updateClient.setIgnoreExternals(false);

/*
 * returns the number of the revision wcPath was updated to
 */
try {
return updateClient.doUpdate(wcPath, updateToRevision,depth, false, false);
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return 0;
}

/**
 * recursively checks out a working copy from url into wcDir
 * @param clientManager
 * @param url
 * a repository location from where a Working Copy will be checked out
 * @param revision
 * the desired revision of the Working Copy to be checked out
 * @param destPath
 * the local path where the Working Copy will be placed
 * @param depth
 * checkout的深度，目录、子目录、文件
 * @return
 * @throws SVNException
 */
public static long checkout(SVNClientManager clientManager, SVNURL url,
SVNRevision revision, File destPath, SVNDepth depth) {

SVNUpdateClient updateClient = clientManager.getUpdateClient();
/*
 * sets externals not to be ignored during the checkout
 */
updateClient.setIgnoreExternals(false);
/*
 * returns the number of the revision at which the working copy is
 */
try {
return updateClient.doCheckout(url, destPath, revision, revision,depth, false);
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return 0;
}

/**
 * 确定path是否是一个工作空间
 * @param path
 * @return
 */
public static boolean isWorkingCopy(File path){
if(!path.exists()){
logger.warn("'" + path + "' not exist!");
return false;
}
try {
if(null == SVNWCUtil.getWorkingCopyRoot(path, false)){
return false;
}
} catch (SVNException e) {
logger.error(e.getErrorMessage(), e);
}
return true;
}

}



public class SvnProjectService {
private Logger logger = Logger.getLogger(SvnProjectService.class);

// 项目的存放位置
private String workspace = null;
private String templete = null;

private ResourceBundle rb = ResourceBundle.getBundle("application");

private String username = null;
private String password = null;


private void init(){
String webapp = SvnProjectService.class.getClassLoader().getResource("").toString().substring(6);
webapp = webapp.substring(0, webapp.indexOf(rb.getString("project.webapp")) + 10);
username = rb.getString("svn.username");
password = rb.getString("svn.password");
workspace = rb.getString("project.svn.path");
templete = webapp + File.separator + rb.getString("project.template");
}

public SvnProjectService(){
super();
init();
}

/**
 * 从SVN更新项目到work copy
 * @param project
 * Project
 * @return
 */
@Override
public boolean updateProjectFromSvn(Project project) {
if(null == project || null == project.getSvnUrl()){
return false;
}

        SVNClientManager clientManager = SVNUtil.authSvn(project.getSvnUrl(), username, password);
if (null == clientManager) {
logger.error("SVN login error! >>> url:" + project.getSvnUrl()
+ " username:" + username + " password:" + password);
return false;
}

        // 注册一个更新事件处理器
        clientManager.getCommitClient().setEventHandler(new UpdateEventHandler());

        SVNURL repositoryURL = null;
try {
// eg: http://svn.ambow.com/wlpt/bsp
repositoryURL = SVNURL.parseURIEncoded(project.getSvnUrl()).appendPath("trunk/"+project.getName(), false);
} catch (SVNException e) {
logger.error(e.getMessage(),e);
return false;
}

        File ws = new File(new File(workspace), project.getName());
        if(!SVNWCUtil.isVersionedDirectory(ws)){
        SVNUtil.checkout(clientManager, repositoryURL, SVNRevision.HEAD, new File(workspace), SVNDepth.INFINITY);
        }else{
        SVNUtil.update(clientManager, ws, SVNRevision.HEAD, SVNDepth.INFINITY);
        }
return true;
}

/**
 * 提交项目到SVN
 * @param project
 * Project
 * @return
 */
@Override
public boolean commitProjectToSvn(Project project) {
if(null == project || null == project.getSvnUrl()){
return false;
}

        SVNClientManager clientManager = SVNUtil.authSvn(project.getSvnUrl(), username, password);
if (null == clientManager) {
logger.error("SVN login error! >>> url:" + project.getSvnUrl()
+ " username:" + username + " password:" + password);
return false;
}

        // 注册一个提交事件处理器
        clientManager.getCommitClient().setEventHandler(new CommitEventHandler());

SVNURL repositoryURL = null;
try {
// eg: http://svn.ambow.com/wlpt/bsp
repositoryURL = SVNURL.parseURIEncoded(project.getSvnUrl()).appendPath("trunk", false);
} catch (SVNException e) {
logger.error(e.getMessage(),e);
return false;
}

String wsDir = workspace + File.separator + project.getName();
File ws = new File(wsDir);

if(!SVNUtil.isWorkingCopy(ws)){
SVNUtil.checkout(clientManager, repositoryURL, SVNRevision.HEAD, new File(workspace), SVNDepth.EMPTY);
}
if(!SVNWCUtil.isVersionedDirectory(ws)){
SVNUtil.addEntry(clientManager, ws);
}
String commitMessage = "Commit '" + wsDir + "' to '" + repositoryURL.getPath() + "'";

SVNUtil.commit(clientManager, ws, false, commitMessage);

return true;
}

}

application.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/auto
jdbc.username=root
jdbc.password=root

#dbcp settings
dbcp.maxIdle=20
dbcp.maxActive=20

project.svn.path=d:/projects


#svn settings
svn.username=zww
svn.password=12345


Project类只是一个普通的POJO类。里面有svnRoot属性。即svn的根路径。


标签：

相关文章