public class Test
{
   static final int BUFFER = 2048;
  
   public static String ChangeName(String s)
   {    
         int j = 0;
         String newstring = "";
         for (int i=0; i<s.length(); i++)
         {
          if (s.charAt(i)== '.')
          {
           j = i;
          }
         }
         newstring = s.substring(0,j);
         return  newstring;  
     
   }

   public static void main (String argv[])
   {
      try
      {
         BufferedInputStream origin = null;
         String filename = "";
        
        
         byte data[] = new byte[BUFFER];
        
         File f = new File(".");
         String files[] = f.list();

         for (int i=0; i < files.length; i++)
         {
            filename = files[i];
            FileOutputStream dest = new FileOutputStream(ChangeName(filename) +".zip");
            ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest));
            System.out.println("Adding: "+files[i]);           
            FileInputStream fi = new FileInputStream(files[i]);
            origin = new BufferedInputStream(fi, BUFFER);
            ZipEntry entry = new ZipEntry(files[i]);
            out.putNextEntry(entry);
            int count;
            while((count = origin.read(data, 0,BUFFER)) != -1)
            {
               out.write(data, 0, count);
            }
            origin.close();
            out.close();
         }        
      }
      catch(Exception e)
      {
         e.printStackTrace();
      }
   }
}

One of the reason why the move to iBatis was due to paging, the requirement is to show data from more than 4 million records, querying data for paging was taking a lot of time using result set. Next step was moving to scrollable result set, however managing the connection and the open result set, i'm afraid will be daunting to the developers, some of them new. We can surely destroy the connection once the session expires but how about the result sets we may need to open when users access other pages for which data is to be queried in millions of row table?

Ibatis to the rescue, with the PaginatedList interface and PaginatedDataList as the implementation. Using iBatis is very simple. Below is a sample to do dynamic queries with poperty name and value substitution.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" 
  "http://www.ibatis.com/dtd/sql-map-2.dtd">
<sqlMap>
	<!-- Data is cached at server depending on the size -->
	<cacheModel id="domain1Cache" type="LRU">
		<flushInterval hours="1"/>
		<property name="size" value="100" />
	</cacheModel>

	<!-- aliasing, -->
	<typeAlias alias="domain1VO" type="com.company.domain1.domain1VO" />
	
	<!-- 
		Result mapping from sql to java object of domain1VO which is com.company.domain1.domain1VO.
		If there is more that one column with the same name, use sql aliasing.
	-->
	<resultMap id="domain1Result" class="domain1VO">
		<result property="domain1No" column="FIELD1"/>
		<result property="referenceNo" column="FIELD2"/>
		<result property="status" column="FIELD3"/>
		...
	</resultMap>
	
	<!--
		Each select has a unique id, the data to be used for criteria, empty if there isn't any. If 
		multiple string criteria, put them in a map use the parameterMap keyword instead of parameterClass
	-->
	<select id="finddomain1" parameterClass="com.company.domain1.domain1SearchVO"
		resultMap="domain1Result" cacheModel="domain1Cache">
		<!-- We are using CDATA for the following sql fragment because of the 'STATUS <> 'N'' notice
			 the less than, greater than symbols which are xml markers.
	    -->
		<![CDATA[
			SELECT FIELD1, FIELD2, FIELD3 
			FROM TABLE WHERE ( FIELD4 <> 'N' ) AND #code# IN (CODE) AND ID = #companyId#
		]]>
		<!--
			#Code# <- substitues domain1SearchVO.Code value
		-->

		<!--
			Below does dynamic query, depending if the property has data, create query reflecting the data.
			isNotEmpty is used to substitute 
			<code>
		        if ((search.getValue() != null) && (search.getValue().length() > 0)) {
		            getdomain1s.append(" AND " + search.getCriteria());
		            getdomain1s.append(" = '");
		            getdomain1s.append(search.getValue());
		            getdomain1s.append("'");
		        }
			</code>
			
			$criteria$ <- this is for substituting property name. Note $ instead of # which is for property value
		-->		
			<isNotEmpty prepend="AND" property="value" >
				$criteria$ = #value#
			</isNotEmpty>
			
			<isNotEmpty prepend="AND" property="status" >
				STATUS = #status#
			</isNotEmpty>
			 ORDER BY ID
	</select>
</sqlMap>

总结多数据源的问题，其实它需要分为以下三种情况：各个数据源的数据结构不同、各个数据源的数据结构相同、各个数据源的数据结构部分相同又有部分不同。对于第二种情况，各个数据源的数据结构相同，我们使用一个sessionFactory，而在sessionFactory中通过MultiDataSource来动态切换数据源，应当是一个不错的方案，既解决了多个sessionFactory对相同的值对象重复装载对内存的浪费，又使数据源的切换对客户程序透明，简化了代码的实现和对客户程序的影响。但是，对于第一种情况，各个数据源的数据结构不同，运用这样的方案存在潜在风险。

对于各个数据源的数据结构不同的情况，使用一个sessionFactory而在这个sessionFactory中动态切换数据源，可能造成数据访问的张冠李戴。譬如，数据源A有表T而数据源B没有，可能造成客户程序在访问表T的时候却尝试去连接数据源B，因为客户程序访问哪个数据源是在程序运行期间由客户程序决定的，因此这样的错误是很难发现的。也许客户程序的一个不经意的错误就可能造成错误。解决这个问题的方法有两个：一是严格要求客户程序不要写错，这当然是可以做到的，但作为框架设计者，另一个解决方法是在框架中就避免出现这样的情况。因此我祭出了MultiSessionFactory的方案来解决各个数据源的数据结构不同的多数据源问题。

问题的分析

与MultiDataSource的方案一样，MultiSessionFactory同样是在spring框架下调用ApplicationContext的getBean()方法而不会另外创建beanFacoty，也同样使用Decorator模式来处理切换的问题。MultiSessionFactory的对象关系如图：

方案的实现

在整个这个方案中，我们需要实现的只有MultiSessionFactory类和我们可爱的Spserver，总共就两个类，然后呢就是一些spring的配置，就完成了。

MultiSessionFactory实现了SessionFactory，同时为了得到AplicationContext而实现了ApplicationContextAware。MultiSessionFactory的代码如下：

首先生成证书请求：

#openssl req -new > server.csr

按照提示输入相关信息后，会在当前目录自动生成server.csr和privkey.pem两个文件，privkey.pem是私钥文件，默认会有passphrase，如果不移除的话，每次运行apache的时候都会提示输入passphrase，所以如果服务器重启后如果你不在服务器前面，则apache无法正常运行。

所以，第二步需要移除passphrase：

#openssl rsa -in privkey.pem -out server.key

这一步会让你输入前面设定的passphrase，所以在前面的时候不要胡乱设定一个passphrase哈。

第三步，生成服务器证书：

#openssl req -x509 -days 3650 -key server.key -in server.csr > server.crt

days参数是指定证书有效期的，3650是10 年，够长的了吧？
最后，在httpd.conf里的相应域名配置里加上：

SSLCertificateFile /etc/httpd/conf/key/server.crt
SSLCertificateKeyFile /etc/httpd/conf/key/server.key

然后重启apache即可。

====

UPDATE：

还有一种方法，先按照指定算法生成密钥：

#openssl genrsa -des3 1024 -new > server.old.key

然后移除passphrase：

#openssl rsa -in server.old.key -out server.key

然后生成证书请求：

#openssl req -new -key server.key > server.csr

最后生成证书：

#openssl req -x509 -days 3650 -key server.key -in server.csr > server.crt

讲一下主要思路：读取配置文件，取得所需的信息；查看版本库是否存在，不存在则checkout，存在则update；执行svn log生成日期文件；调用java -jar statsvn.jar生成版本库的报表。

开始实现：

1.配置文件两个respository.cfg.xml，statsvn.cfg.xml：

respository.cfg.xml样式

<?xml version="1.0"?>
<respositoryconfig>
<respository httpurl = "http://localhost:8080/svn/test" fileurl = "file:///F:/AMP/SVNRespository/test" >
     <checkoutdir dir = "F:/Test" />
     <outputdir dir = "F:/TestReport" />
</respository>
</respositoryconfig>

statsvn.cfg.xml样式

<?xml version="1.0"?>
<statsvnconfig>
<svnhome dir = "F:/AMP/Subversion/bin" />
<statsvnjar dir = "F:/statsvn.jar" />
</statsvnconfig>

2.pytho脚本：

from xml.dom.minidom import parse, parseString
import os, sys

class respconfig:
       def __setattr__(self, attr, value):
           if attr == 'reposhttpurl':
               self.__dict__[attr] = value
           elif attr == 'reposfileurl':
               self.__dict__[attr] = value
           elif attr == 'checkoutdir':
               self.__dict__[attr] = value
           elif attr == 'outputdir':
               self.__dict__[attr] = value
           else:
               raise AttributeError, attr + ' not allowed'
        
       def __getattr__(self, attr):
           if attr == "reposhttpurl":
               return self.__dict__[attr]
           elif attr == "reposfileurl":
               return self.__dict__[attr]
           elif attr == 'checkoutdir':
               return self.__dict__[attr]
           elif attr == 'outputdir':
               return self.__dict__[attr]
           else:
               raise AttributeError, attr

class statsvnconfig:
       def __setattr__(self, attr, value):
           if attr == 'svnhome':
               self.__dict__[attr] = value
           elif attr == 'statsvnjar':
               self.__dict__[attr] = value
           else:
               raise AttributeError, attr + ' not allowed'
        
       def __getattr__(self, attr):
           if attr == "svnhome":
               return self.__dict__[attr]
           elif attr == 'statsvnjar':
               return self.__dict__[attr]
           else:
               raise AttributeError, attr
        
def loadRespConfig(xmlfile):
       dom1 = parse(xmlfile)
       config_element = dom1.getElementsByTagName("respositoryconfig")[0]
       resps = config_element.getElementsByTagName("respository")
       respconfigs = []
       for resp in resps:
           respcfg = respconfig()
           respcfg.reposhttpurl = resp.attributes["httpurl"].value
           respcfg.reposfileurl = resp.attributes["fileurl"].value
           respcfg.checkoutdir = resp.getElementsByTagName("checkoutdir")[0].attributes["dir"].value
           respcfg.outputdir = resp.getElementsByTagName("outputdir")[0].attributes["dir"].value
           respconfigs.append(respcfg)
       return respconfigs

def loadStatSvnConfig(xmlfile):
       dom1 = parse(xmlfile)
       config_element = dom1.getElementsByTagName("statsvnconfig")[0]
       statsvncfg = statsvnconfig()
       statsvncfg.svnhome = config_element.getElementsByTagName("svnhome")[0].attributes["dir"].value
       statsvncfg.statsvnjar = config_element.getElementsByTagName("statsvnjar")[0].attributes["dir"].value
       return statsvncfg

def createSvnLog(svnhome, reposhttpurl, checkouturl):
       cmd = '%s/svn log %s -v --xml > %s/logfile.log'% (svnhome, reposhttpurl, checkouturl)
       os.popen(cmd, 'r')

def updateRepos(svnhome, checkouturl):
       cmd = '%s/svn update %s'% (svnhome, checkouturl)
       os.popen(cmd, 'r')

def checkoutRepos(svnhome, reposfileurl, checkouturl):
       cmd = '%s/svn checkout %s %s'% (svnhome, reposfileurl, checkouturl)
       os.popen(cmd, 'r')

def createStatSvnReport(statsvnjar, outputdir, checkoutdir):
       cmd = 'java -jar %s -output-dir %s -threads 10 %s/logfile.log %s'% (statsvnjar, outputdir, checkoutdir, checkoutdir)
       os.popen(cmd, 'r')

def checkoutRequired(checkoutdir):
       if os.path.exists(checkoutdir):
           return False
       else:
           return True
        
if __name__ == '__main__':
       respconfigs = loadRespConfig(os.getcwd() + "respository.cfg.xml")
       statsvncfg = loadStatSvnConfig(os.getcwd() + "statsvn.cfg.xml")
       i = 0
       length = len(respconfigs)
       while 1:
           if i >= length:
               break
           if checkoutRequired(respconfigs[i].checkoutdir):
               checkoutRepos(statsvncfg.svnhome, respconfigs[i].reposfileurl, respconfigs[i].checkoutdir)
           else:
               updateRepos(statsvncfg.svnhome, respconfigs[i].checkoutdir)
           createSvnLog(statsvncfg.svnhome, respconfigs[i].reposhttpurl, respconfigs[i].checkoutdir)
           createStatSvnReport(statsvncfg.statsvnjar, respconfigs[i].outputdir, respconfigs[i].checkoutdir)
           i = i + 1
       sys.exit()

剩下的就是通过py2exe把py脚本生成exe或者写个bat文件调用改py脚本，把exe或者bat文件放到windows计划任务中去就可以了。

起初是因为Apache不能认到/var/www以外目录的问题才了解到SELinux的。
在网上找了很多怎么关掉SELinux的文档，如："在system-config-securitylevel把selinux关掉就可以了"。但都不正确。
RHEL4上关掉SELinux的正确方法为：
修改/etc/selinux/config文件中的SELINUX="" 为 disabled
然后重启。

代码如下：
    final List tempList = list;
    try {
      if (List tempList != null) {
        template.execute(
            new SqlMapClientCallback() {
          public Object doInSqlMapClient(SqlMapExecutor executor) throws
              SQLException {
            executor.startBatch();
            for (int i = 0, n = tempList.size(); i < n; i++) {
              executor.update("test.batchupdate",(Map)tempList.get(i));
            }
            executor.executeBatch();
            return null;
          }
        }
        );
      }
    }
   用法就是这么简单，但是其工作的原理还没搞懂。

2.创建POJO类,Student.java，此程序中用到的所有类都放在cn.itcast包下面，
 其他的配置文件都放在txd.configfile包下面。
 package cn.itcast;
 
 public class Student {
  private Integer id;
 
  private String firstname;
 
  private String lastname;
 
  public String getFirstname() {
   return firstname;
  }
 
  public void setFirstname(String firstname) {
   this.firstname = firstname;
  }
 
  public Integer getId() {
   return id;
  }
 
  public void setId(Integer id) {
   this.id = id;
  }
 
  public String getLastname() {
   return lastname;
  }
 
  public void setLastname(String lastname) {
   this.lastname = lastname;
  }
 }

3.跟Student类对应的xml配置文件Student.xml,
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" "http://www.ibatis.com/dtd/sql-map-2.dtd">
 <sqlMap namespace="student">
  <!--insert元素,id属性值作为标识此元素,parameterClass属性是参数的类型,此
  属性的值是Java类的全限定名（即包括类的包名）。它是可选的，但强烈建议使用。
  它的目的是 限制输入参数的类型为指定的Java类，并优化框架的性能。##符号中
  间的名字来自此类的属性.-->
  <insert id="insert_student" parameterClass="cn.itcast.Student">
   insert into student(firstname,lastname) values
   (#firstname#,#lastname#)
  </insert>
 
  <select id="getStudent" resultClass="cn.itcast.Student">
   select id, firstname, lastname from student
  </select>
 
  <delete id="delStudent" parameterClass="int">
   delete from student where id=#value#
  </delete>
 
  <update id="updateStudent" parameterClass="cn.itcast.Student">
   update student set firstname=#firstname#,lastname=#lastname#
   where id=#id#
  </update>
 </sqlMap>

4.jdbc.properties文件,存储数据库连接的driver,url,username,password等信息,
 driver=com.mysql.jdbc.Driver
 url=jdbc:mysql:///itcast
 username=root
 password=

5. SqlMap的配置文件SqlMapConfigExample.xml,
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE sqlMapConfig
 PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"
 "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
 
 <sqlMapConfig>
  <!--<properties>元素，用于在配置文件中使用标准的Java属性文件（name＝value）-->
  <properties resource="txd/configfile/jdbc.properties" />
  <!--
  cacheModelsEnabled:全局性地启用或禁用SqlMapClient的所有缓存model。
  enhancementEnabled:全局性地启用或禁用运行时字节码增强，以优化访问
   Java Bean属性的性能，同时优化延迟加载的性能。
  lazyLoadingEnabled:全局性地启用或禁用SqlMapClient的所有延迟加载。
  maxRequests:同时执行SQL语句的最大线程数。
  maxSessions:同一时间内活动的最大session数。
  maxTransactions:同时进入SqlMapClient.startTransaction()的最大线程数。
  useStatementNamespaces:如果启用本属性，必须使用全限定名来引用mapped statement。
   Mapped statement的全限定名由sql-map的名称和mapped-statement的名称合成。
  -->
  <settings cacheModelsEnabled="true" enhancementEnabled="true"
   lazyLoadingEnabled="true" maxRequests="32" maxSessions="10"
   maxTransactions="5" useStatementNamespaces="false" />
 
  <!--
  <transationManager>元素让您为SQL Map配置事务管理服务。属性type指定所
  使用的事务管理器类型。这个属性值可以是一个类名，也可以是一个别名。
  包含在框架的三个事务管理器分别是：JDBC，JTA和EXTERNAL。
  -->
  <transactionManager type="JDBC">
   <!--dataSource元素为SQL Map数据源设置了一系列参数。-->
   <dataSource type="SIMPLE">
    <property name="JDBC.Driver" value="${driver}" />
    <property name="JDBC.ConnectionURL" value="${url}" />
    <property name="JDBC.Username" value="${username}" />
    <property name="JDBC.Password" value="${password}" />
   </dataSource>
  </transactionManager>
  <!--<sqlMap>元素用于包括SQL Map映射文件和其他的SQL Map配置文件。-->
  <sqlMap resource="txd/configfile/Student.xml" />
 </sqlMapConfig>

6.MySqlMapClient.java类,用于产生一个SqlMapClient
 package cn.itcast;
 
 import java.io.IOException;
 import java.io.Reader;
 
 import com.ibatis.common.resources.Resources;
 import com.ibatis.sqlmap.client.SqlMapClient;
 import com.ibatis.sqlmap.client.SqlMapClientBuilder;
 
 public class MySqlMapClient {
 
  private static SqlMapClient sqlMapClient;
 
  static {
   String resource = "txd/configfile/SqlMapConfigExample.xml";
   Reader reader = null;
   try {
    reader = Resources.getResourceAsReader(resource);
    sqlMapClient = SqlMapClientBuilder.buildSqlMapClient(reader);
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 
  public static SqlMapClient getSqlMapInstance() {
   return sqlMapClient;
  }
 
 }

7.StudentManager 类测试一下上面的代码,
 package cn.itcast;
 
 import java.sql.SQLException;
 import java.util.List;
 
 import com.ibatis.sqlmap.client.SqlMapClient;
 
 public class StudentManager {
 
  public static void main(String[] args) {
   SqlMapClient sqlMap = MySqlMapClient.getSqlMapInstance();
 
   // insert一条记录
 
   // Student student = new Student();
   // student.setFirstname("zhang");
   // student.setLastname("san");
   // try {
   // sqlMap.insert("insert_student", student);
   // System.out.println("插入成功!");
   // } catch (SQLException e) {
   // e.printStackTrace();
   // }
 
   // delete一条记录
 
   // try {
   // int result = sqlMap.delete("delStudent", 5);
   // System.out.println(result);
   // } catch (SQLException e) {
   // e.printStackTrace();
   // }
 
   // update一条已存在的记录
 
   Student student = new Student();
   student.setId(1);
   student.setFirstname("jiang");
   student.setLastname("zemin");
   try {
    int result = sqlMap.update("updateStudent", student);
    System.out.println(result);
   } catch (SQLException e) {
    e.printStackTrace();
   }
 
   // query获得多条记录
 
   // try {
   // List<Student> list = sqlMap.queryForList("getStudent", null);
   // for (Student student : list) {
   // System.out
   // .println(student.getId() + "\t"
   // + student.getFirstname() + "\t"
   // + student.getLastname());
   // }
   // } catch (SQLException e) {
   // e.printStackTrace();
   // }
 
   // query单条记录
 
   // try {
   // Student student = (Student) sqlMap.queryForObject("getStudent", 1);
   // System.out.println(student.getId());
   // System.out.println(student.getFirstname());
   // System.out.println(student.getLastname());
   // } catch (SQLException e) {
   // e.printStackTrace();
   // }
  }
 
 }

1   背景假设
厦门央瞬公司是一家电子元器件设备供应商，其中有个ARM部门，专门负责ARM芯片的方案设计、销售，并在北京、上海各设立了一个办事处。对于工作日志，原先采用邮件方式发给经理，但是这种方式有个缺点，那就是不具备连续性，要看以前的日志必须一封一封邮件去查看，很麻烦。于是就想到利用 Subversion， 让员工在自己电脑上编辑日志，然后利用svn传送回来，既方便员工自己编写日志，又方便对日志的归档处理，而且提交日志的时候只需要执行一下 svn update 即可，比发送邮件还要简单的多。

svn服务器相关信息

服务器地址： 192.168.0.1
服务器OS： MS Windows 2000 Server Edition 中文版
代码库本地目录： D:\svn\arm
arm部门文档的目录结构如下:

arm                 部门名称
├─diary           工作日志目录
│  ├─headquarters    总部工作日志目录
│  ├─beijing         北京办日志目录
│  └─shanghai        上海办日志目录
├─ref             公司公共文件参考目录
└─temp            临时文件目录
人员情况

morson，公司总经理，其实他不必亲自看任何东西，就连部门经理们的每周总结都不一定看。但是为了表示对他的尊敬，以及满足一下他的权力欲，还是给他开放了“阅读所有文档”的权限
michael，arm事业部的部门经理，没事的时候喜欢弄点儿新技术，用svn来管理日志，就是他相处来的主意
scofield，北京办人员，老员工，为人油滑难管
lincon，上海办人员，老员工，大老实人一个
linda，总部协调员、秘书，文笔不错，长得也不错
rory，单片机技术员，技术支持
访问权限需求分析

允许总经理读取所有文件
除部门经理外，所有其他人员，均只能看到本办事处人员工作日志
不允许匿名访问
ref目录只允许经理和秘书写，对其他人只读
temp目录人人都可以写
2   建立代码库
在服务器 D:\svn 目录下，建立 arm 代码库，命令如下:

D:\svn>svnadmin create arm
在客户机 F:\temp 目录下，建立好上述目录结构

用命令 F:\temp>svnimportarmsvn://192.168.0.1/arm 导入结构

【注意点：关于导入时候的细微差别】

3   编辑代码库基础配置文件
编辑代码库 arm\conf\svnserve.conf 文件，如下:

[general]
password-db = passwd.conf
anon-access = none
auth-access = write
authz-db = authz.conf
4   管理用户帐号
新建代码库 arm\conf\passwd.conf 文件，如下:

[users]
morson = ShowMeTheMoney
michael = mysecretpassword
scofield = hellolittilekiller
lincon = asyouknows111
rory = 8809117
linda = IlikeWorldCup2006
5   建立目录访问权限控制文件
新建代码库 arm\conf\authz.conf 文件，内容如下:

[groups]
g_vip = morson
g_manager = michael
g_beijing = scofield
g_shanghai = lincon
g_headquarters = rory, linda
g_docs = linda
[arm:/]
@g_manager = rw
* = r
[arm:/diary/headquarters]
@g_manager = rw
@g_headquarters = rw
@g_vip = r
* =
[arm:/diary/beijing]
@g_manager = rw
@g_beijing = rw
@g_vip = r
* =
[arm:/diary/shanghai]
@g_manager = rw
@g_shanghai = rw
@g_vip = r
* =
[arm:/ref]
@g_manager = rw
@g_docs = rw
* = r
[arm:/temp]
* = rw
6   测试
在服务器上，打开一个 DOS Prompt 窗口，输入如下指令:

svn co svn://127.0.0.1/arm --no-auth-cache --username rory --password 8809117
我们应该得到如下目录结构:

arm
├─diary
│  └─headquarters
├─ref
└─temp
然后修改ref目录下任意文件并提交，服务器将会报错“Access deni”

深入
本章将详细介绍前一章所涉及的两个配置文件， svnserve.conf 和 authz.conf，通过对配置逐行的描述，来阐明其中的一些细节含义。

这里首先要注意一点，任何配置文件的有效配置行，都不允许存在前置空格，否则程序会无法识别。也就是说，如果你直接从本文的纯文本格式中拷贝了相关的配置行过去，需要手动将前置的4个空格全部删除。当然了，如果你觉得一下子要删除好多行的同样数目的前置空格是一件苦差使，那么也许 UltraEdit 的“Column Mode”编辑模式，可以给你很大帮助呢。

1   svnserve.conf
arm\conf\svnserve.conf 文件，是 svnserve.exe 这个服务器进程的配置文件，我们逐行解释如下。

首先，我们告诉 svnserve.exe，用户名与密码放在 passwd.conf 文件下。当然，你可以改成任意的有效文件名，比如默认的就是 passwd:

password-db = passwd.conf
接下来这两行的意思，是说只允许经过验证的用户，方可访问代码库。 那么哪些是“经过验证的”用户呢？噢，当然，就是前面说那些在 passwd.conf 文件里面持有用户名密码的家伙。这两行的等号后面，目前只允许 read write none 三种值，你如果想实现一些特殊的值，比如说“read-once”之类的，建议你自己动手改源代码，反正它也是自由软件:

anon-access = none
auth-access = write
接下来就是最关键的一句呢，它告诉 svnserve.exe，项目目录访问权限的相关配置是放在 authz.conf 文件里:

authz-db = authz.conf
当然，svn 1.3.2 引入本功能的时候，系统默认使用 authz 而不是 authz.conf 作为配置文件。不过由于鄙人是处女座的，有着强烈的完美主义情结，看着 svnserve.conf 有后缀而 passwd 和 authz 没有就是不爽，硬是要改了。

2   authz.conf 之用户分组
arm\conf\authz.conf 文件的配置段，可以分为两类，``[group]`` 是一类，里面放置着所有用户分组信息。其余以 [arm:/] 开头的是另外一类，每一段就是对应着项目的一个目录，其目录相关权限，就在此段内设置。

首先，我们将人员分组管理，以便以后由于人员变动而需要重新设置权限时候，尽量少改动东西。我们一共设置了5个用户分组，分组名称统一采用 g_ 前缀，以方便识别。当然了，分组成员之间采用逗号隔开:

[groups]
# 任何想要查看所有文档的非本部门人士
g_vip = morson
# 经理
g_manager = michael
# 北京办人员
g_beijing = scofield
# 上海办人员
g_shanghai = lincon
# 总部一般员工
g_headquarters = rory, linda
# 小秘，撰写文档
g_docs = linda
注意到没有， linda 这个帐号同时存在“总部”和“文档员”两个分组里面，这可不是我老眼昏花写错了，是因为 svnserve.exe 允许我这样设置。它意味着，这个家伙所拥有的权限，将会比他的同事 rory 要多一些，这样的确很方便。具体多了哪些呢？请往下看！

3   authz.conf 之项目根目录
接着，我们对项目根目录做了限制，该目录只允许arm事业部的经理才能修改，其他人都只能眼巴巴的看着:

[arm:/]
@g_manager = rw
* = r
[arm:/] 表示这个目录结构的相对根节点，或者说是 arm 项目的根目录
这里的 @ 表示接下来的是一个组名，不是用户名。你当然也可以将 @g_manager=rw 这一行替换成 michael=rw ，而表达的意义完全一样。
* 表示“除了上面提到的那些人之外的其余所有人”，也就是“除了部门经理外的其他所有人”，当然也包括总经理那个怪老头
* = r 则表示“那些人只能读，不能写”
4   authz.conf 之项目子目录
然后，我们要给总部人员开放日志目录的读写权限:

[arm:/diary/headquarters]
@g_manager = rw
@g_headquarters = rw
@g_vip = r
* =
我敢打赌，设计svn的家伙们，大部分都是在 unix/linux 平台下工作，所以他们总喜欢使用 / 来标识子目录，而完全忽视在 MS Windows 下是用 \ 来做同样的事情。所以这儿，为了表示 arm\diary\headquarters 这个目录，我们必须使用 [arm:/diary/headquarters] 这样的格式。
这里最后一行的 *= 表示，除了经理、总部人员、特别人士之外，任何人都被禁止访问本目录。这一行是否可以省略呢？
之所以这儿需要将 @g_vip=r 一句加上，就是因为存在上述这个解释。如果说你没有明确地给总经理授予读的权力，则他会和其他人一样，被 * 给排除在外。
如果众位看官中间，有谁玩过防火墙配置的话，可能会感觉上述的配置很熟悉。不过这里有一点与防火墙配置不一样，那就是各个配置行之间，没有 先后顺序 一说。也就是说，如果我将本段配置的 *= 这一行挪到最前面，完全不影响整个配置的最终效果。
请注意这儿，我们并没有给 arm\diary 目录设置权限，就直接跳到其子目录下进行设置了。我当然是故意这样的，因为我想在这儿引入“继承”的概念。
权限具备继承性 任何子目录，均可继承其父目录的所有权限，除非它自己被明确设置了其他的权限。也就是说，在 arm 目录设置权限后， arm\diary 目录没有进行设置，就意味着它的权限与 arm 目录一样，都是只有经理才有权读写，其他人只能干瞪眼。
【 * = 是否可以省略】【用例子引入覆盖】【单用户权限的继承问题】【父目录权限集成与全面覆盖问题】
现在来看看

好了，我们现在掌握了“继承”的威力，它让我们节省了不少敲键盘的时间。可是现在又有一个问题了，

属性具备覆盖性质子目录若设置了属性，则完全覆盖父目录。

5   authz.conf 的其他注意点
父目录的 r 权限，对子目录 w 权限的影响
把这个问题专门提出来，是因为在1.3.1及其以前的版本里面，有个bug，即为了子目录的写权限，项目首目录必须具备读权限。因此现在使用了1.3.2版本，就方便了那些想在一个代码库存放多个相互独立的项目的管理员，来分配权限了。比如说央舜公司建立一个大的代码库用于存放所有员工日志，叫做 diary，而arm事业部只是其中一个部门，则可以这样做:

[diary:/]
@g_chief_manager = rw
[diary:/arm]
@g_arm_manager = rw
@g_arm = r
这样，对于所有arm事业部的人员来说，就可以将 svn://192.168.0.1/diary/arm 这个URL当作根目录来进行日常操作，而完全不管它其实只是一个子目录，并且当有少数好奇心比较强的人想试着 checkout 一下 svn://192.168.0.1/diary 的时候，马上就会得到一个警告“Access deni”，哇，太酷了。

默认权限
如果说我对某个目录不设置任何权限，会怎样？马上动手做个试验，将:

[diary:/]
@g_chief_manager = rw
改成:

[diary:/]
# @g_chief_manager = rw
这样就相当于什么都没有设置。在我的 svn 1.3.2 版本上，此时是禁止任何访问。也就是说，如果你想要让某人访问某目录，你一定要显式指明这一点。这个策略，看起来与防火墙的策略是一致的。

只读权限带来的一个小副作用
若设置了:

[arm:/diary]
* = r
则svnserve认为，任何人，都不允许改动diary目录，包括删除和改名，和新增。

也就是说，如果你在项目初期创建目录时候，一不小心写错目录名称，比如因拼写错误写成 dairy，以后除非你改动 authz.conf 里面的这行设置，否则无法利用 svn mv 命令将错误的目录更正。

改进
1   对中文目录的支持
上午上班的时候，Morson 来到 Michael 的桌子前面，说道：“你是否可以将我们的北京办、上海办目录，改成用中文的，看着那些拼音我觉得很难受？” Michael 心想，还好这两天刚了解了一些与 unicode 编码相关的知识，于是微笑地回答：“当然可以，你明天下午就可以看到中文目录名称了。”

使用 svn mv 指令，将原来的一些目录改名并 commit 入代码库，改名后的目录结构如下:

arm
├─工作日志
│  ├─总部人员
│  ├─北京办
│  └─上海办
├─公司公共文件参考目录
└─临时文件存放处
修改代码库的 authz.conf 文件，将相应目录逐一改名

使用 UltraEdit 将 authz.conf 文件转换成不带 BOM 的 UTF-8 格式

将配置文件转换成 UTF-8 格式之后，Subversion 就能够正确识别中文字符了。但是这里需要注意一点，即必须保证 UTF-8 文件不包含 BOM 。BOM 是 Byte Order Mark 的缩写，指 UNICODE 文件头部用于指明高低字节排列顺序的几个字符，通常是 FFFE ，而将之用 UTF-8 编码之后，就是 EFBBBF 。由于 UTF-8 文件本身不存在字节序问题，所以对 UTF-16 等编码方式有重大意义的 BOM，对于 UTF-8 来说，只有一个作用——表明这个文件是 UTF-8 格式。由于 BOM 会给文本处理带来很多难题，所以现在很多软件都要求使用不带 BOM 的 UTF-8 文件，特别是一些处理文本的软件，如 PHP、 UNIX 脚本文件等，svn 也是如此。

目前常用的一些文本编辑工具中，MS Windows 自带的“记事本”里面，“另存为”菜单保存出来的 UTF-8 格式文件，会自动带上 BOM 。新版本 UltraEdit 提供了选项，允许用户选择是否需要 BOM，而老版本的不会添加 BOM。请各位查看一下自己常用的编辑器的说明文件，看看它是否支持这个功能。

利用 UltraEdit ，我们可以将 BOM 去掉。方法是，首先利用“UTF-8 TO ASCII”菜单将文件转换成本地编码，通常是GB2312码，然后再使用“ASCII TO UTF-8(UNICODE Editing)”来转换到 UTF-8 即可。