svnkit获取SVN信息

public class SVNOperationServiceBean implements SVNOperationService
{

    private final DataVoiceLogger logger = DataVoiceLogFactory.getLogger(getClass());

    private SVNRepository repository = null;

    @PostConstruct
    public void initSVNOperationService()
    {

        DAVRepositoryFactory.setup();

        SVNRepositoryFactoryImpl.setup();

        FSRepositoryFactory.setup();

    }

    public void login(String username, String password, String url)
            throws Exception
    {
        password = new String(Base64.decode(password.getBytes()));
        this.repository = SVNRepositoryFactory.create(SVNURL.parseURIDecoded(url));

        ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(username,
                password);

        this.repository.setAuthenticationManager(authManager);

        testConnection();
    }

    private void testConnection() throws SVNException
    {
        this.repository.testConnection();
    }

    @Override
    public boolean testRepositoryConnected(SvnConfigInfo conf)
    {
        boolean isSucceed = false;
        try
        {
            login(conf.getUserAccount(), conf.getUserPassword(), conf.getConfigCodePath());
            String[] codepath = getCodePaths(conf.getConfigCodePath());
            SVNDirEntry dir = getTargetInfo(codepath[0], -1);
            if (dir != null)
            {
                isSucceed = true;
                logger.info(conf.getConfigCodePath() + "  testlogin success ");
            }

        }
        catch (SVNAuthenticationException e)
        {

            logger.error("login error" + e.getMessage());
        }
        catch (Exception e)
        {
            logger.error(e.getMessage());
        }
        return isSucceed;
    }

    public SVNDirEntry getTargetInfo(String path, long revision)
    {
        SVNDirEntry collect = null;
        try
        {
            collect = this.repository.info(path, revision);
        }
        catch (SVNException e)
        {
            collect = null;
            logger.error(e.getMessage());
        }
        return collect;
    }

    public List<SVNLogEntry> getSVNLog(long startRevision, long endRevision,
            String[] codePaths)
    {
        List<SVNLogEntry> entries = new ArrayList<SVNLogEntry>();
        try
        {
            this.repository.log(codePaths,
                    entries,
                    startRevision,
                    endRevision,
                    true,
                    true);
        }
        catch (SVNException e)
        {
            logger.error(e.getMessage());
        }
        return entries;
    }

    public SvnLogFileInfo getLastFileRevision(SvnLogFileInfo fInfo)
    {
    	SvnLogFileInfo fileInfo = null;
    	List<SVNFileRevision> s = new ArrayList<SVNFileRevision>();
        int index = -2;
        try
        {
            this.repository.getFileRevisions(fInfo.getFilename(), s, 0, fInfo.getRevision());
        }
        catch (SVNException e)
        {
            logger.error(e.getMessage());
        }

        index = s.size() + index;

        if (index >= 0)
        {
            SVNFileRevision revision = s.get(index);
            fileInfo = new SvnLogFileInfo();
            fileInfo.setFilename(revision.getPath(),this.getRepositoryType());
            fileInfo.setRevision(revision.getRevision());
        }

        return fileInfo;
    }

    public boolean copyFile(String workspace, String type, SvnLogFileInfo fileInfo)
    {

        FileOutputStream fo = null;
        boolean isSuccess = false;
        try
        {
            SVNProperties pro = new SVNProperties();
            File file = new File(workspace + "\\" + type + "\\" + fileInfo.getShortFileName());
            fo = new FileOutputStream(file);
            try
            {
                this.repository.getFile(fileInfo.getFilename(), fileInfo.getRevision(), pro, fo);
            }
            catch (SVNException e)
            {
            	logger.error("query the file "+fileInfo.getShortFileName()+"'info from repository, but file copy failed!");
            }
            fo.close();
            isSuccess = true;
        }
        catch (Exception e)
        {
        	logger.error(e.getMessage());
        }
        finally
        {
            try
            {
                if (fo != null)
                {
                    fo.close();
                }
            }
            catch (IOException e)
            {
            	logger.error(e.getMessage());
            }
        }
        return isSuccess;
    }

    public long getLatestRevision()
    {
        long lastRevision = 0;
        try
        {
            lastRevision = this.repository.getLatestRevision();
        }
        catch (SVNException e)
        {
            logger.error("Lastest revision of this repository is not exists!");
        }
        return lastRevision;
    }

    public String getSvnRoot()
    {
        SVNURL url = null;
        try
        {
            url = this.repository.getRepositoryRoot(false);
            return url.getPath();
        }
        catch (SVNException e)
        {
            e.printStackTrace();
            logger.error("You have no right get this repository root url !!!");
        }
        return null;
    }

    public String[] getCodePaths(String url)
    {
        String codepath = getSvnRoot();
        int homeIndex = url.indexOf(codepath);
        return new String[] { url.substring(homeIndex + codepath.length()) };
    }

	@Override
	public String getRepositoryType() {

		return RepositoryOperation.IREP_TYPE_SVN;
	}
}