技术的本质是生活 共同学习,共同进步。专注技术，享受人生。 http://chinajavawolf.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 (3)Tapestry5学习小结:显示问题 chinajavawolf 作者: chinajavawolf  链接：http://chinajavawolf.javaeye.com/blog/94584  发表时间: 2007年06月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

显示问题
我在做验证的时候发现，我的验证提示语的位置总是有问题（也许就我碰到了），我打开了tapestry-core包内的default.css文件，看到
DIV.t-error LI {
  margin-left: -20px;
}
我把-20px改为20px后，显示正常了。
 
还有我发现Tapestry5对html的验证非常严格，缺少个td或者 tr什么的，或者tag标记写成了大写也不行。这点感觉不是很爽，因为美工有的时候没时间去帮你找哪个td少写了，因为对于美工来说少个td对页面没什么影响。而且我发现如果你在html上不加上
  1. >  

这句话，对于& nbsp;这样的内容都会报错。

Frame的情况在Tapestry5中好像没有以前那么麻烦了，直接使用就可以了，不过感觉给美工带来了一些麻烦。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 27 Jun 2007 11:34:08 +0800 http://chinajavawolf.javaeye.com/blog/94584 http://chinajavawolf.javaeye.com/blog/94584 (2)Tapestry5学习小结:中文验证问题 chinajavawolf 作者: chinajavawolf  链接：http://chinajavawolf.javaeye.com/blog/94565  发表时间: 2007年06月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Tapestry5学习小结:中文验证问题
Tapestry5.0.5-SNAPSHOT目前的验证文件没有提供中文的本地化内容。邮件列表中有人提供了一个份，可以down下来使用，也可以自己写入自己希望的内容。ValidationStrings_zh_Cn.properties
field-is-required=请输入{0}输入框的内容。
field-too-short={1}输入框的内容不能少于{0}字节。
 
invalid-date-format={0}输入框的日期格式不正确，正确格式为MM/DD/YYYY。
invalid-int-format={0}输入框的内容必须是整数。
invalid-format=无法识别{0}输入框的格式。
invalid-numeric-format={0}输入框的内容必须是数字。
 
date-too-early={0}输入框的日期必须在{1}之后。
date-too-late={0}输入框的日期必须在{1}之前。
 
number-too-small={0}输入框的数字不能少于{1}。
number-too-large={0}输入框的数字不能大于{1}。
 
number-range={0}输入框的数字必须在{1}和{2}之间。
 
invalid-email-format=电子邮件地址{0}格式错误，正确的格式user@hostname。
 
pattern-not-matched={0}不符合所要求的格式{1}。
 
invalid-url-format =错误的URL。
disallowed-protocol =不被允许的协议，必须是{0}。
 
Errors_zh_CN.properties
default-banner =在你继续之前，必须纠正如下错误.
http://issues.apache.org/jira/browse/TAPESTRY-249

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 27 Jun 2007 10:54:25 +0800 http://chinajavawolf.javaeye.com/blog/94565 http://chinajavawolf.javaeye.com/blog/94565 (1)Tapestry5学习小结:中文问题 chinajavawolf 作者: chinajavawolf  链接：http://chinajavawolf.javaeye.com/blog/94557  发表时间: 2007年06月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

(1)    Tapestry中文问题
在目前的Tapestry5.0.5-SNAPSHOT版本中，Tapestry还没有提供对中文的支持。查找了Tapestry的邮件列表，看到如下的解决办法。
首先，可以写一个UTF8properties的java文件。该文件可以到w3c的网站上找到，代码如下： 
  1. public class Utf8Properties extends Properties {   
  2.        
  3.     /**  
  4.      * use serialVersionUID from JDK 1.1.X for interoperability  
  5.      */  
  6.     private static final long serialVersionUID = 5907218757225133892L;       
  7.        
  8.     /**  
  9.      * Encoding used to read properties from a file  
  10.      */  
  11.     public static final String ENCODING                    = "UTF-8";   
  12.        
  13.     /**  
  14.      * Characters used to write comment lines in a property file  
  15.      */  
  16.     private static final String COMMENT                    = "#!";   
  17.        
  18.     /**  
  19.      * Possible Separator between key and value of a property in a property  
  20.      * file  
  21.      */  
  22.     private static final String keyValueSeparators       = "=: \t\r\n\f";       
  23.        
  24.     /**  
  25.      * Creates an empty property list with no default values.  
  26.      *   
  27.      * @see java.util.Properties#Properties()  
  28.      */  
  29.     public Utf8Properties() {   
  30.       this(null);   
  31.     }   
  32.        
  33.     /**  
  34.      * Creates an empty property list with the specified defaults.  
  35.      *  
  36.      * @param   defaults   the defaults.  
  37.      * @see java.util.Properties#Properties(java.util.Properties)  
  38.      */  
  39.     public Utf8Properties(Properties defaults) {   
  40.       this.defaults = defaults;   
  41.     }      
  42.        
  43.     /**  
  44.      * Reads a property list (key and element pairs) from the input  
  45.      * stream. The stream is assumed to be using the UTF-8  
  46.      * character encoding or compatible.  
  47.      * Characters can be written with their unicode escape sequence.  
  48.      *   
  49.      * @param      inStream   the input stream.  
  50.      * @exception IOException if an error occurred when reading from the  
  51.      *               input stream.  
  52.      * @throws        IllegalArgumentException if the input stream contains a  
  53.      *          malformed Unicode escape sequence.  
  54.      * @see java.util.Properties#load(java.io.InputStream)  
  55.      */  
  56.     public synchronized void load(InputStream inStream) throws IOException {   
  57.       BufferedReader in = new BufferedReader(new InputStreamReader(inStream, ENCODING));   
  58.       String line = in.readLine();   
  59.          
  60.       while(line != null) {          
  61.           line = removeWhiteSpaces(line);   
  62.           if(!line.equals("") && COMMENT.indexOf(line.charAt(0)) == -1) {   
  63.             // Removes the beginning separators   
  64.             String property = line;   
  65.             // Reads the whole property if it is on multiple lines   
  66.             while(continueLine(line)) {   
  67.                 property = property.substring(0, property.length() - 1);   
  68.                 line = in.readLine();   
  69.                 property += line;   
  70.             }   
  71.             //property = new String(property.getBytes(ENCODING), ENCODING);   
  72.                
  73.             if(!property.equals("")) {                  
  74.                 int endOfKey = 0;   
  75.                 // calculates the ending index of the key   
  76.                 while(endOfKey < property.length() &&   
  77.                    (keyValueSeparators.indexOf(property.charAt(endOfKey)) == -1)) {   
  78.                   endOfKey++;   
  79.                 }                  
  80.                 String key   = property.substring(0, endOfKey);   
  81.                 String value = property.substring(endOfKey + 1, property.length());   
  82.                    
  83.                 key   = loadConversion(key);                   
  84.                 value = loadConversion(removeWhiteSpaces(value));   
  85.                    
  86.                 put(key, value);   
  87.                 //// For debugging only   
  88.                 //System.out.println("key: " + key);   
  89.                 //System.out.println("value: " + value);   
  90.                 //System.out.println("-----------");                 
  91.             }   
  92.           }   
  93.           line = in.readLine();   
  94.       }   
  95.     }   
  96.        
  97.     /**  
  98.      * A simple method to remove white spaces  
  99.      * at the beginning of a String  
  100.      * @param       line  the String to treat  
  101.      * @return      the same String without white spaces at the beginning  
  102.      */  
  103.     public static String removeWhiteSpaces(String line) {   
  104.       int index = 0;   
  105.       while(index < line.length() && keyValueSeparators.indexOf(line.charAt(index)) != -1) {   
  106.           index++;   
  107.       }        
  108.       return line.substring(index, line.length());   
  109.     }   
  110.        
  111.     /**  
  112.      * Replaces all characters preceded by a '\' with the corresponding special  
  113.      * character and converts unicode escape sequences to their value  
  114.      * @param       line  the String to treat  
  115.      * @return      the converted line  
  116.      */  
  117.     private String loadConversion(String line) {   
  118.       StringBuffer val = new StringBuffer(line.length());    
  119.          
  120.       int index = 0;   
  121.          
  122.       // Replace all the "\." substrings with their corresponding escaped characters    
  123.       for(; index < line.length(); index++) {   
  124.           char currentChar = line.charAt(index);   
  125.           if(currentChar == '\\') {   
  126.             index++;   
  127.             currentChar = line.charAt(index);   
  128.             switch(currentChar) {   
  129.             case 't':   
  130.                 currentChar = '\t';   
  131.                 break;   
  132.             case 'r':   
  133.                 currentChar = '\r';   
  134.                 break;   
  135.             case 'n':   
  136.                 currentChar = '\n';   
  137.                 break;   
  138.             case 'f':   
  139.                 currentChar = '\f';   
  140.                 break;   
  141.             case 'u':   
  142.                 index++;   
  143.                 // Read the xxxx   
  144.                 int value=0;   
  145.                 for (int i=0; i<4; i++) {   
  146.                   currentChar = line.charAt(index++);   
  147.                   //System.out.println(currentChar);   
  148.                   switch (currentChar) {   
  149.                   case '0': case '1': case '2': case '3': case '4':   
  150.                   case '5': case '6': case '7': case '8': case '9':   
  151.                       value = (value << 4) + currentChar - '0';   
  152.                       break;   
  153.                   case 'a': case 'b': case 'c':   
  154.                   case 'd': case 'e': case 'f':   
  155.                       value = (value << 4) + 10 + currentChar - 'a';   
  156.                       break;   
  157.                   case 'A': case 'B': case 'C':   
  158.                   case 'D': case 'E': case 'F':   
  159.                       value = (value << 4) + 10 + currentChar - 'A';   
  160.                       break;   
  161.                   default:   
  162.                       throw new IllegalArgumentException(   
  163.                       "Malformed \\uxxxx encoding.");   
  164.                   }                    
  165.                 }   
  166.                 // index must point on the last character of the escaped   
  167.                 // sequence to avoid missing the next character   
  168.                 index--;   
  169.                 currentChar = (char) value;   
  170.             default:       
  171.                 break;   
  172.             }   
  173.           }   
  174.           val.append(currentChar);   
  175.       }   
  176.          
  177.       return val.toString();   
  178.     }   
  179.        
  180.     /**  
  181.      * Replaces special characters with their '2-chars' representation.<br/>  
  182.      * For example, '\n' becomes '\\' followed by 'n'  
  183.      * @param       line  the String to treat  
  184.      * @return      the resulting String  
  185.      */  
  186.     private String storeConversion(String line) {   
  187.       int length = line.length();   
  188.       StringBuffer outBuffer = new StringBuffer(length*2);   
  189.          
  190.       for(int i = 0; i < length; i++) {   
  191.           char currentChar = line.charAt(i);   
  192.           switch(currentChar) {   
  193.           case '\\':   
  194.             outBuffer.append('\\');   
  195.             outBuffer.append('\\');   
  196.             break;   
  197.           case '\t':   
  198.             outBuffer.append('\\');   
  199.             outBuffer.append('t');   
  200.             break;   
  201.           case '\n':   
  202.             outBuffer.append('\\');   
  203.             outBuffer.append('n');   
  204.             break;   
  205.           case '\r':   
  206.             outBuffer.append('\\');   
  207.             outBuffer.append('r');   
  208.             break;   
  209.           case '\f':   
  210.             outBuffer.append('\\');   
  211.             outBuffer.append('f');   
  212.             break;               
  213.           default:   
  214.             outBuffer.append(currentChar);   
  215.           break;   
  216.           }   
  217.       }       
  218.       return outBuffer.toString();   
  219.     }   
  220.        
  221.     /**  
  222.      * Indicates wether the property continues on the next line or not  
  223.      * @param       line  the beginning of the property that might be continued on the next line  
  224.      * @return      true if the propertiy continues on the following line, false otherwise  
  225.      */  
  226.     private boolean continueLine(String line) {   
  227.       if(line != null && !line.equals("")) {   
  228.           return line.charAt(line.length() - 1) == '\\';   
  229.       }   
  230.       return false;   
  231.     }   
  232.        
  233.     /**  
  234.      * The same method as java.util.Properties.store(...)  
  235.      *   
  236.      * @param out  an output stream  
  237.      * @param header      a description of the property list  
  238.      * @see java.util.Properties#store(java.io.OutputStream, java.lang.String)  
  239.      */  
  240.     public void store(OutputStream out, String header) throws IOException {   
  241.       BufferedWriter output;   
  242.       output = new BufferedWriter(new OutputStreamWriter(out, ENCODING));   
  243.       if (header != null) {   
  244.           output.write("#" + header);   
  245.           output.newLine();   
  246.       }            
  247.       output.write("#" + new Date());   
  248.       output.newLine();   
  249.       // we do not want that a Thread could modify this Utf8Properties   
  250.       // while storing it    
  251.       synchronized (this) {   
  252.           Enumeration e = keys();   
  253.           while(e.hasMoreElements()) {   
  254.             String key = storeConversion((String)e.nextElement());   
  255.             String val = storeConversion((String)get(key));   
  256.                
  257.             output.write(key + "=" + val);   
  258.             output.newLine();   
  259.           }   
  260.       }   
  261.       output.flush();   
  262.     }   
  263. }   
 
然后将该文件编译后放到org\apache\tapestry\util包内。
接下来就可以修改其原文件了。要修改的原文件是org.apache.tapestry.internal.services包下的MessagesSourceImpl类。将该类的readProperties(Resource resource)方法中的java.util.Properties类改为我们编写的Utf8properties类。然后再修改org.apache.tapestry.internal.services包下的RequestImpl和ResponseImpl类文件。
将RequestImpl类文件中的方法改为如下内容：
  1. public String getParameter(String name)   
  2.     {   
  3.         String param = _request.getParameter(name);   
  4.         if(param != null)   
  5.             try  
  6.             {   
  7.                 param = new String(param.getBytes("ISO-8859-1"),"utf-8");   
  8.             }   
  9.             catch (UnsupportedEncodingException ex)   
  10.             {   
  11.                 //won't error   
  12.             }   
  13.         return param;   
  14.     }   
  15.     
  16.     public String[] getParameters(String name)   
  17.     {   
  18.         String[] params = _request.getParameterValues(name);   
  19.         try  
  20.         {   
  21.             for(int i=params.length-1;i>=0;i--){   
  22.                 params[i] = new String(params[i].getBytes("ISO-8859-1"),"utf-8");   
  23.             }   
  24.         }   
  25.         catch (UnsupportedEncodingException ex)   
  26.         {   
  27.             //won't error   
  28.         }   
  29.         return params;   
  30. }   
将ResponseImpl类文件中的方法改为如下内容：
  1. public PrintWriter getPrintWriter(String contentType) throws IOException   
  2.     {   
  3.         notBlank(contentType, "contentType");   
  4.         if(contentType.matches("text/html.*"))   
  5.             _response.setCharacterEncoding("utf-8");   
  6.         _response.setContentType(contentType);   
  7.     
  8.         return _response.getWriter();   
  9.     }   
  10. public OutputStream getOutputStream(String contentType) throws IOException   
  11.     {   
  12.         notBlank(contentType, "contentType");   
  13.         if(contentType.matches("text/html.*"))   
  14.             _response.setCharacterEncoding("utf-8");   
  15.         _response.setContentType(contentType);   
  16.     
  17.         return _response.getOutputStream();   
  18.     }   
最后重新编译打包就可以了。最后要注意的是此时我们所有应用用到的文件都要以utf-8格式进行编码.
 
该问题由LinuxBoy在邮件列表中提出，并得到了解决。
https://issues.apache.org/jira/browse/TAPESTRY-1294

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 27 Jun 2007 10:29:11 +0800 http://chinajavawolf.javaeye.com/blog/94557 http://chinajavawolf.javaeye.com/blog/94557 (F1)Tapestry Upload:Tapestry Upload Component chinajavawolf 作者: chinajavawolf  链接：http://chinajavawolf.javaeye.com/blog/93398  发表时间: 2007年06月23日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本人翻译目的是用来学习Tapestry5的,共享出来希望大家批评指正。计划持续翻译。
chinajavawolf  
Tapestry 上传组件
Tapestry提供了一个基于Jakarata Commons FileUpload的文件上传组件。
用法
Upload组件支持默认值的绑定（基于id）和验证。
组件模板
  1. <t:form>  
  2.        <t:errors/>  
  3.        <input t:type="upload" t:id="file" validate="required"/>  
  4.        <br/>  
  5.        <input type="submit" value="Upload"/>  
  6.    </t:form>  
   
这里，因为value参数没有被绑定，这个组件使用它的容器的文件属性（因为组件的id是”file”）。如果你想要上传一个不同的属性，可以绑定value参数或改变组件的id.
 
页面类
  1. public class UploadExample   
  2.     {   
  3.         private UploadedFile _file;   
  4.     
  5.         public UploadedFile getFile()   
  6.         {   
  7.             return _file;   
  8.         }   
  9.     
  10.         public void setFile(UploadedFile file)   
  11.         {   
  12.             _file = file;   
  13.         }   
  14.     
  15.         public void onSuccess()   
  16.         {   
  17.             File copied = new File("/my/file/location/" + _file.getFileName());   
  18.                
  19.             _file.write(copied);   
  20.         }   
  21.     }   
   
潜在的问题
这个通用的文件上传库使用CommonsIO文件清除器服务在他们不再需要的时候移除临时文件。这个服务创建了一个线程来完成这个工作。如果commons-io库被共享在多个应用中（例如增加服务器CLASSPATH）。它可能为一个应用过早的对另一个应用终止这个线程并引发错误。（见Resource Cleanup工作组进行更多的讨论）
技术上文件清除服务不是Tapestry Upload必需的（在请求结尾处删除临时文件）。然而目前不可能去废除它（改进请求已经作为FILEUPLOAD-133提出）。

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 23 Jun 2007 12:41:00 +0800 http://chinajavawolf.javaeye.com/blog/93398 http://chinajavawolf.javaeye.com/blog/93398 Acegi(02): Acegi管理身份验证 chinajavawolf 作者: chinajavawolf  链接：http://chinajavawolf.javaeye.com/blog/87419  发表时间: 2007年06月06日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

2.管理身份验证
决定是否允许用户访问受保护资源的的第一步是判断用户的身份。在大多数应用系统中，这意味着用户在一个登录界面上提供用户名和密码。用户名告诉应用系统用户声明自己是谁。为了确保用户的身份，用户需要同时提供一个密码。如果应用系统的安全机制确认密码是正确的，则系统假设用户的实际身份与他声明的身份相同。
在Acegi中，是由认证管理器负责确定用户身份的。一个认证管理器由接口
  1. public interface AuthenticationManager {       
  2.     Authentication authenticate(Authentication authentication)   
  3.         throws AuthenticationException;   
  4. }  
认证管理器的authenticate()方法需要一个org.acegisecurity.Authentication对象（其中可能只包括用户名和密码）作为参数，它会尝试验证用户身份。如果认证成功，authenticate()方法返回一个Authentication对象，其中包括用户已被授权的权限（将由授权管理器使用）。如果认证失败，则它会抛出一个AuthenticationException 。
 
2.1配置ProviderManager
    ProviderManager是认证管理器的一个实现，它将验证身份的责任委托给一个或多个认证提供者。
ProviderManager:
DaoAuthenticationProvider
DaoAuthenticationProvider
JaasAuthenticationProvider
CasAuthenticationProvider
RemoteAuthenticationProvider
ProviderManager的思路是使你能够根据多个身份管理源来认证用户。它不是依靠自己实现身份验证，而是逐一遍历一个认证提供者的集合，直到某一个认证提供者能够成功地验证该用户的身份（或者已经尝试完了该集合中所有的认证提供者）。
你可以在Spring配置文件中按如下方式配置一个ProviderManager:
   
  1. <bean id="authenticationManager"  
  2.     class="org.acegisecurity.providers.ProviderManager">  
  3.     <property name="providers">  
  4.     <list>  
  5.         <ref bean="daoAuthenticationProvider"/>  
  6.         <ref bean="jaasAuthenticationProvider"/>  
  7.     list>  
  8.     property>  
  9. bean>  
   
通过providers属性可以为ProviderManager提供一个认证提供者的列表。通常你只需要一个认证提供者，但在某些情况下，提供由若干个认证提供者组成的列表是有用的。在这种情况下，如果一个认证提供者验证身份失败，可以尝试另一个认证提供者。一个认证提供者是由org.acegisecurity.providers.AuthenticationProvider接口定义的。Spring提供了若干个AuthenticationProvider的有用实现，如下所示：
认证提供者
目的
org.acegisecurity.adapters.
AuthByAdapterProvide
使用容器的适配器验证身份
org.acegisecurity.providers.cas.
CasAuthenticationProvider
根据Yale中心认证服务验证身份
org.acegisecurity.providers.dao.
DaoAuthenticationProvider
从数据库中获取用户信息，包括用户名和密码
org.acegisecurity.providers.jaas.
JaasAuthenticationProvider
从JAAS登录配置中获取用户信息
org.acegisecurity.providers.rcp.
RemoteAuthenticationProvider
根据远程服务验证用户身份
org.acegisecurity.runas. RunAsImplAuthenticationProvider
针对身份已经被运行身份管理器替换的用户进行认证
org.acegisecurity.providers. TestingAuthenticationProvider
用于单元测试。自动认为一个TestingAuthenticationToken是有效的。不应用于生产环境。
 
你可以认为一个AuthenticationProvider是一个下属的AuthenticationManager。事实上，AuthenticationProvider接口也有一个authenticate()方法，该方法的签名与AuthenticationManager的authenticate()方法完全一样。
下面我们关注三个最常用的认证提供者。首先从使用DaoAuthenticationProvider进行简单的基于数据库验证身份开始。
2.2根据数据库验证身份
    大多数应用系统将包括用户名和密码在内的用户信息保存在数据库中。如果这和你的情况相符，那么你可以使用DaoAuthenticationProvider。
    声明一个DAO认证提供者
    一个DaoAuthenticationProvider是一个简单的认证提供者，它使用DAO来从数据库中获取用户信息（包括用户的密码）。
    取得了用户名和密码之后，DaoAuthenticationProvider通过比较从数据库中获取的用户名和密码以及来自认证管理器的通过Authentication对象中传入的用户名和密码完成身份验证。如果用户名和密码与数据库中的信息匹配，则用户通过身份验证，同时返回给认证管理器一个已完全填充的Authentication对象。否则会抛出一个AuthenticationException，表明身份验证失败。
 
配置一个DaoAuthenticationProvider在简单不过了。下一段XML摘要显示了如何声明一个DaoAuthenticationProvider Bean，并且装配上它所依赖的DAO。    
  1. <bean id="authenticationProvider"  
  2.     class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">  
  3.     <property name="authenticationDao">  
  4.         <ref bean="authenticationDao"/>  
  5.     property>  
  6. bean>  
      
属性authenticationDao指定了一个用于从数据库中获取用户信息的Bean。这个属性期望赋予一个org.acegisecurity.providers.dao.DaoAuthenticationProvider的实例。接下来的问题就是该如何配置authenticationDao Bean了。
       Acegi提供了两个可供选择的AuthenticationDao的实例：InMemoryDaoImpl和JdbcDaoImpl。我们首先配置一个InMemoryDaoImpl作为authenticationDao Bean的实例，然后再使用更实用的JdbcDaoImpl替换它。
使用内存DAO
       尽管假定AuthenticationDao对象总是通过查询关系数据库获取用户信息是一种自然的想法，事实情形却不必总是如此。如果你的应用系统的身份验证需求是微不足道，或者是为了开发期间方便起见，也许更简单的做法是在Spring配置文件中直接配置你的用户信息。
       为此，Acegi提供了InMemoryDaoImpl，一个从Spring配置文件中获取用户信息的AuthenticationDao。你能够在Spring配置文件中通过以下方法配置一个InMemoryDaoImpl：
      
  1. <bean id="authenticationDao"  
  2.     class="org.acegisecurity.userdetails.memory.InMemoryDaoImpl">  
  3.     <property name="userMap">  
  4.         <value>  
  5.             palmerd=4moreyears,ROLE_PRESIDENT   
  6.             bauerj=ineedsleep,ROLE_FIELD_OPS,ROLE_DIRECTOR   
  7.             myersn=traitor,disabled,ROLE_CENTRAL_OPS   
  8.         value>  
  9.     property>  
  10. bean>  
      
属性userMap使用一个org.acegisecurity.userdetails.memory.UserMap对象来定义一组用户名、密码和权限。幸运的是，当装配一个InMemoryDaoImpl时，你不必为配置一个UserMap实例而操心，因为Acegi提供了一个属性编辑器，它能够帮你把一个字符串转化为一个UserMap对象。
       userMap字符串的每一行都是一个名字—值对，其中名字是用户名，值是一个由逗号分隔的列表，它以用户密码开头，后面跟着一个或多个赋予该用户的权限的名字（可以将权限看作角色）。
以上的 authenticationDao声明中定义了三个用户：palmerd、bauerj、myersn。这三个用户的密码分别是4moreyears,ineedsleep和traitor。用户palmerd被定义为拥有权限ROLE_PRESIDENT,bauerj被赋予权限ROLE_FIELD_OPS和ROLE_DIRECTOR,并且用户myersn被给予ROLE_CENTRAL_OPS授权。
       注意用户myersn的密码后面有disabled这个单词。这是一个特殊的标志，表明该用户已被禁用。
       InMemoryDaoImpl有明显的局限性。最主要的一点是，对安全性进行管理时要求你重新编辑Spring的配置文件并且重新部署应用。虽然在开发环境下这是可以接受的（而且可能还是有帮助的），但对于生产用途而言这种做法就太笨拙了。因此，我们强烈反对在生产环境下使用InMemoryDaoImpl，而是应该考虑使用JdbcDaoImpl。
 
声明一个JDBC DAO
JdbcDaoImpl是一个简单而灵活的认证DAO。以它最简单的形势，只需要一个javax.sql.DataSource对象的引用，可以通过以下方式在Spring配置文件中进行声明：
  1. <bean id="authenticationDao"  
  2.        class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">  
  3.        <property name="dataSource">  
  4.         <ref bean="dataSource"/>  
  5.        property>  
  6. bean>  
JdbcDaoImpl假设你在数据库中已经建立了某些用于存放用户信息的表。特别地，它假设有一张“Users”表和一张“授权”表，如图：
当JdbcDaoImpl查找用户信息时，它会使用“SELECT username,password,enabled FROM users WHERE username = ?”作为查询语句。类似地，当查找授权时，它会使用“SELECT username,authority FROM authorities WHERE username = ?”。
尽管JdbcDaoImpl假定的表结构非常直接，它们很可能与你已经为应用系统建立的表结构不一致。比如，在Spring培训应用中，Student表保存用户名(在login列中)和密码。是否这意味着你无法在Spring培训应用中使用JdbcDaoImpl来验证学生的身份？
       当然不是。但你必须通过设置usersByUserNameQuery属性告诉JdbcDaoImpl如何找到用户信息。下面是对authenticationDao Bean的调整使它更适合Spring培训应用：
  1. <bean id="authenticationDao"  
  2.        class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">  
  3.        <property name="dataSource">  
  4.         <ref bean="dataSource"/>  
  5.        property>  
  6.        <property name="usersByUserNameQuery">  
  7.         <value>  
  8.               SELECT login,password FROM student WHERE login=?   
  9.         value>  
  10.        property>  
  11. bean>  
现在JdbcDaoImpl知道如何在Student表中查找用户的认证信息了。但是，还有一件事遗漏了。Student表中没有标志表明用户是否被禁用。事实上，我们一直假设所有的学生都是未被禁用的。但我们如何告诉JdbcDaoImpl做同样的假设？
       JdbcDaoImpl还有一个usersByUserNameMapping属性，它引用一个MappingSqlQuery实例。MappingSqlQuery的mapRow()方法将一个ResultSet中的字段映射为一个领域对象。对于JdbcDaoImpl，提供给usersByUserNameMapping属性的MappingSqlQusery对象要求能够将一个ResultSet(通过执行用户查询获得)转化为一个
org.acegisecurity.userdetails.UserDetails对象。
       UsersByUserNameMapping显示了一个MappingSqlQuery的实现，它适合将学生用户表的一个查询结果转换为一个UserDetails对象。它从ResultSet中抽取出username和password，但总是设置enabled属性为true。
  1. public class UsersByUsernameMapping extends MappingSqlQuery{   
  2.        protected UsersByUsernameMapping(DataSource dataSource){   
  3.               super(dataSource,usersByUsernameQuery);   
  4.               declareParameter(new SqlParameter(Types.VARCHAR));   
  5.               compile();   
  6.        }   
  7.        protected Object mapRow(ResultSet rs,int rownum) throws SQLException{   
  8.               String username=rs.getString(1);   
  9.               String password=rs.getString(2);   
  10.     
  11.               UserDetails user=new User(username,password,true,   
  12.                      new GrantedAuthority[]{new GrantedAuthorityImpl("HOLDER")});   
  13.                return user;   
  14.        }   
  15. }   
 
剩下唯一需要做的事就是声明一个UsersByUsernameMapping Bean，并将它装配到usersByUserNameMapping属性中。以下的authenticationDao Bean的声明将一个内部Bean装配至usersByUserNameMapping属性中，从而可以应用新的用户映射：
  1. <bean id="authenticationDao"  
  2.     class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">  
  3.     <property name="dataSource">  
  4.       <ref bean="dataSource"/>  
  5.     </property>  
  6.     <property name="usersByUserNameQuery">  
  7.       <value>  
  8.         SELECT login,password FROM student WHERE login=?   
  9.       </value>  
  10.     </property>  
  11.     <property name="usersByUserNameMapping">  
  12.         <bean class="my.UsersByUsernameMapping"/>          
  13.     </property>  
  14. </bean>  
你也能改变 JdbcDaoImpl查询用户权限的方式。与属性usersByUserNameQuery和usersByUserNameMapping定义JdbcDaoImpl如何查询用户认证信息相同，属性authoritiesByUserNameQuery和authoritiesByUserNameMapping告诉JdbcDaoImpl如何查询用户的权限：例如，你可以使用以下代码从user_privileges表中查询已授予一个用户的权限。
  1. <bean id="authenticationDao"     
  2.     class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">     
  3.     <property name="dataSource">     
  4.       <ref bean="dataSource"/>     
  5.     </property>     
  6.     <property name="usersByUserNameQuery">     
  7.       <value>     
  8.         SELECT login,password FROM student WHERE login=?      
  9.       </value>     
  10.     </property>     
  11.     <property name="usersByUserNameMapping">     
  12.         <bean class="my.UsersByUsernameMapping"/>             
  13.     </property>     
  14.     <property name="authoritiesByUserNameQuery">     
  15.        <value>     
  16.         SELECT login,privilege FROM user_privileges where login=?      
  17.        </value>     
  18.     </property>     
  19. </bean>     
你可以将属性authoritiesByUserNameMapping设置成一个定制的MappingSqlQuery对象，从而可以定制权限查询的结果如何映射为一个org.acegisecurity.GrantedAuthority对象。但是，由于默认的MappingSqlQuery对上面给出的查询来说已经足够了，我们就不再画蛇添足了。
 
使用加密的密码
       默认地，DaoAuthenticationProvider假设用户的密码是以明文方式（未加密的方式）存储的。但在与数据库中取出的密码进