筆記

    數組可以裝基本類型或者引用，collections只能裝引用。
    通常有兩種方法可以擴展collection 來滿足一些需要：繼承某種集合類型和封裝某種集合類型。第一種的優點是初始化的時候在內存中只產生一個對象，這是繼承特性決定的。后者的優點是我們可以方便控制被封裝集合的各種屬性。
Whenever possible, it’s desirable to bury implementation details inside of a class rather than exposing client code to such details。例：
法1：
public class Student {
    private String name;
    private String studentId;  
    private ArrayList<TranscriptEntry> transcript; //成績報告單
    public void addTranscriptEntry(TranscriptEntry te) {   // 操作transcript達到記錄成績
        // Store the TranscriptEntry in our ArrayList.
        transcript.add(te);
    }
}
客戶端調用代碼：
Student s = new Student("1234567", "James Huddleston");
Course c = new Course("LANG 800", "Advanced Language Studies");
TranscriptEntry te = new TranscriptEntry(c, "Fall 2006", "B+");
s.addTranscriptEntry(te);
法2：
建立新對象，封裝一個ArrayList：
public class Transcript {
    private ArrayList<TranscriptEntry> transcriptEntries;
    public void courseCompleted(Course c, String semester, String grade) {
        // Instantiate and insert a brand-new TranscriptEntry object into the
        // ArrayList - details hidden away!
        transcriptEntries.add(new TranscriptEntry(c, semester, grade);
    }
}
public class Student {
    private String name;
    private String studentId;
    // This used to be declared as an ArrayList.
    private Transcript transcript;
    // etc.
}
客戶端代碼：
s.courseCompleted(c, "Spring 2006", "A+");
第二種方法使Student處理更少的細節，不用管transcripts怎么表達，看不到TranscriptEntry的存在。客戶端代碼更簡單。

Aggregation is a special form of association, alternatively referred to as the “consists of”, “is composed of”, or “has a” relationship.Like an association, an aggregation is used to represent a relationship between two classes, A and B. But, with an aggregation, we’re representing more than mere relationship: we’re stating that an object belonging to class A, known as an aggregate,is composed of, or contains, component objects belonging to class B.
  Note that these aggregation statements appear very similar to associations, where the name of the association just so happens to be is composed of or contains. That’s because an aggregation is an association in the broad sense of the term（aggregation 是association的一種特殊表現形式）!aggregation 和associations UML表現不同但最終代碼表現形式一樣
  Composition is a strong form of aggregation, in which the “parts” cannot exist without the “whole.” As an example, given the relationship “a Book is composed of many Chapters”, we could argue that a chapter cannot exist if the book to which it belongs ceases to exist; whereas given the relationship “a Car is composed of many Wheels”, we know that a wheel can be removed from a car and still serve a useful purpose. Thus, we’d categorize the Book–Chapter relationship as composition and the Car–Wheel relationship as aggregation.
繼承沒留意的好處：
• Best of all, we can derive a new class from an existing class even if we don’t own the source code for the latter! As long as we have the compiled bytecode version of a class, the inheritance mechanism works just fine; we don’t need the original source code of a class in order to extend it. This is one of the most dramatic ways to achieve productivity with an objectoriented language: find a class (either one written by someone else or one that is built into the language) that does much of what you need, and create a subclass of that class,adding just those features that you need for your own purposes.
• classification is the natural way that humans organize information; so, it only makes sense that we’d organize software along the same lines, making it much more intuitive and hence easier to develop, maintain,extend, and communicate with users about.
繼承與Association, aggregation異同（P186）：
Association, aggregation, and inheritance are all said to be relationships between classes. Where inheritance differs from association and aggregation is at the object level.inheritance is indeed a relationship between classes, but not between distinct objects.
注意：避免連鎖反應，Whenever possible, avoid adding features to non-leaf classes once they have been established in code form in an application, to avoid ripple effects throughout an inheritance hierarchy. 說比做容易，這就要求在編碼之前盡可多的花時間在需求分析和對象建模階段，雖然不能避免新需求出現，但至少避免忽視遺漏了當前的需求。
     Overriding:子類繼承父類，重寫唯一能改變的是方法的訪問控制，而且只能比父類更寬松，如父類用的是private，子類可以用public。參考了下thinking in java 4th P202 發現這種說法不對，而且是一個陷阱：父類的該方法根本對子類不可見！子類的該方法實際上是一個全新的方法，連重載都算不上。所以只能重寫non-private方法。遇到private方法你得小心，沒有編譯錯誤，但不會像你想象的工作，最好給方法重新取名，避免陷阱。

不要做的事情：
We shouldn’t change the semantics—that is, the intention, or meaning—of a feature.For example:
• If the print method of a superclass such as Student is intended to display the values of all of an object’s attributes in the command window, then the print method of a subclass such as GraduateStudent shouldn’t, for example, be overridden so that it directs all of its output to a file instead.
• If the name attribute of a superclass such as Person is intended to store a person’s name in “last name, first name” order, then the name attribute of a subclass such as Student should be used in the same fashion.
  We can’t physically eliminate features, nor should we effectively eliminate them by ignoring them. To attempt to do so would break the spirit of the “is a” hierarchy. By definition, inheritance requires that all features of all ancestors of a class A must also apply to class A itself in order for A to truly be a proper subclass. If a GraduateStudent could eliminate the degreeSought attribute that it inherits from Student, for example, is a GraduateStudent really a Student after all? Strictly speaking, the answer is no.
  進一步從實用角度說，如果我們重寫一個方法但不在這方法里做任何事情，其他繼承我們類的人就會出問題：他們覺得我們的方法是有意義的（特別是他們不能看到我們源代碼的時候）。而我們則打破了“is a” 原則，所以絕不要這樣做！
      protected關鍵字的運用，用于控制繼承的訪問控制。
     運用super(arguments) 減少子類構造函數重復父類構造函數代碼，和this類似必須在構造函數最開始調用。
Student s = new Student("Fred", "123-45-6789"); 執行這段代碼，Object的構造函數會自動執行，接著Student 的父類Person構造函數仔細，然后是我們調用的Student構造函數，如果調用的Student構造函數沒有顯示調用父類構造函數，則相當于默認調用super() 。
java沒有類的多繼承，多繼承很復雜的一點，如果兩個父類都有相同的方法，子類怎么處理？

We may wish to instantiate additional objects related to the Student object:
初始化與對象相關的一些額外對象：
public class Student() {
    // Every Student maintains a handle on his/her own individual Transcript object.
    private Transcript transcript;
    public Student() {
        // Create a new Transcript object for this new Student.
        transcript = new Transcript();
        // etc.
    }
}
讀取數據庫來初始化對象屬性：
public class Student {
    // Attributes.
    String studentId;
    String name;
    double gpa;
    // etc.
    // Constructor.
    public Student(String id) {
        studentId = id;
        // Pseudocode.
        use studentId as a primary key to retrieve data from the Student table of a
        relational database;
        if (studentId found in Student table) {
           retrieve all data in the Student record;
            name = name retrieved from database;
            gpa = value retrieved from database;
        // etc.
        }
    }
// etc.
}

和其他已存在的對象交流：
public class Student {
    // Details omitted.
    // Constructor.
    public Student(String major) {
        // Alert the student's designated major department that a new student has
        // joined the university.
        // Pseudocode.
        majorDept.notify(about this student ...);
    // etc.
    }
    // etc.
}

好習慣：如果需要有參數的構造函數，最好同時顯示聲明一個無參構造函數。
容易出現的bug：如果給構造函數加上void編譯會通過！不過會被當作方法而不是構造函數！
當有多個構造函數，而且都有共同的初始化內容時，就會出現很多重復的代碼，比如構造一個新學生，我們會做：
1 通知登記辦公室學生的存在
2 給學生創建學生成績報告單
重復引起以后修改必須修改多處，如果使用this 會得到改善

public class Student {
 // Attribute details omitted.
 // Constructor #1.
 public Student() {
// Assign default values to selected attributes ... details omitted.
// Do the things common to all three constructors in this first
// constructor ...
// Pseudocode.
alert the registrar's office of this student's existence
// Create a transcript for this student.
transcript = new Transcript();
}

 // Constructor #2.
 public Student(String s) {
  // ... then, REUSE the code of the first constructor within the second!
  this();
  // Then, do whatever else extra is necessary for constructor #2.
  this.setSsn(s);
 }

 // Constructor #3.
 public Student(String s, String n, int i) {
  // ... and REUSE the code of the first constructor within the third!
  this();
  // Then, do whatever else extra is necessary for constructor #3.
  this.setSsn(s);
  this.setName(n);
  this.setAge(i);
 }
 // etc.
}

注意：this必須在方法最前面調用

應用一：解決tomcat下中文亂碼問題（先來個簡單的） 

在tomcat下，我們通常這樣來解決中文亂碼問題：

過濾器代碼：

1. package filter;  
2.   
3. import java.io.*;  
4. import javax.servlet.*;  
5. import javax.servlet.http.*;  
6. import wrapper.GetHttpServletRequestWrapper;  
7.   
8. public class ContentTypeFilter implements Filter {  
9.   
10.     private String charset = "UTF-8";  
11.     private FilterConfig config;  
12.       
13.     public void destroy() {  
14.         System.out.println(config.getFilterName()+"被銷毀");  
15.         charset = null;  
16.         config = null;  
17.     }  
18.   
19.     public void doFilter(ServletRequest request, ServletResponse response,  
20.             FilterChain chain) throws IOException, ServletException {  
21.         //設置請求響應字符編碼  
22.         request.setCharacterEncoding(charset);  
23.         response.setCharacterEncoding(charset);  
24.           
25.         HttpServletRequest req = (HttpServletRequest)request;  
26.           
27.           
28.         System.out.println("----請求被"+config.getFilterName()+"過濾");  
29.         //執行下一個過濾器（如果有的話,否則執行目標servlet）  
30.         chain.doFilter(req, response);  
31.           
32.         System.out.println("----響應被"+config.getFilterName()+"過濾");  
33.   
34.     }  
35.   
36.     public void init(FilterConfig config) throws ServletException {  
37.             this.config = config;  
38.             String charset = config.getServletContext().getInitParameter("charset");    
39.             if( charset != null && charset.trim().length() != 0)  
40.             {  
41.                 this.charset = charset;  
42.             }  
43.     }  
44.   
45. }  

web.xml中過濾器配置
<!--將采用的字符編碼配置成應用初始化參數而不是過濾器私有的初始化參數是因為在JSP和其他地方也可能需要使用-->
 <context-param>
   <param-name>charset</param-name>
   <param-value>UTF-8</param-value>
 </context-param>

 <filter>
  <filter-name>ContentTypeFilter</filter-name>
  <filter-class>filter.ContentTypeFilter</filter-class>
 </filter>

 <filter-mapping>
  <filter-name>ContentTypeFilter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

equest.setCharacterEncoding(charset); 必須寫在第一次使用request.getParameter()之前，這樣才能保證參數是按照已經設置的字符編碼來獲取。
response.setCharacterEncoding(charset);必須寫在PrintWriter out = request.getWriter()之前，這樣才能保證out按照已經設置的字符編碼來進行字符輸出。

通過過濾器，我們可以保證在Servlet或JSP執行之前就設置好了請求和響應的字符編碼。

但是這樣并不能完全解決中文亂碼問題：

對于post請求，無論是“獲取參數環節”還是“輸出環節"都是沒問題的；

對于get請求，"輸出環節"沒有問題，但是"獲取參數環節"依然出現中文亂碼，所以在輸出時直接將亂碼輸出了。

 

原因是post請求和get請求存放參數位置是不同的：

post方式參數存放在請求數據包的消息體中。 get方式參數存放在請求數據包的請求行的URI字段中，以？開始以param=value&parame2=value2的形式附加在URI字段之后。而request.setCharacterEncoding(charset); 只對消息體中的數據起作用，對于URI字段中的參數不起作用，我們通常通過下面的代碼來完成編碼轉換：

 String paramValue = request.getParameter("paramName");
paramValue = new String(paramValue.trim().getBytes("ISO-8859-1"), charset);

但是每次進行這樣的轉換實在是很麻煩，有沒有統一的解決方案呢？

解決方案1: 在tomcat_home"conf"server.xml 中的Connector元素中設置URIEncoding屬性為合適的字符編碼

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               URIEncoding="UTF-8"
     />

這樣做的缺點是，同一個tomcat下的其他應用也將受到影響。而其每次部署時都需要類修改配置也很麻煩。

解決方案2:自定義請求包裝器包裝請求，將字符編碼轉換的工作添加到getParameter()方法中

 

修改過濾器的doFilter方法 代碼如下：

 

 

這樣一來，在servlet中調用包裝器的getParameters方法來獲取參數，就已經完成了字符編碼的轉換過程，我們就不需要在每次獲取參數時來進行字符編碼轉換了。
總結：自己寫類繼承HttpServletRequestWrapper，HttpServletRequestWrapper實現了HttpServletRequest接口。看tomcat的源代碼可以發現，ServletRequest作為一個Component ，ServletRequestWrapper作為一個比較標準的Decorator ，實現ServletRequest接口并把ServletRequest當作成員變量，其他繼承Decorator 的類（比如本例中的GetHttpServletRequestWrapper ）就可以很好的操控ServletRequest及其子類（比如本例中的HttpServletRequest），HttpServletRequest的很多方法就可以根據我們的需求做改變，比如設置字符，去掉空格。
參考：
http://www.javaeye.com/topic/483158
http://fishhappy365.javaeye.com/blog/484185
http://www.javaeye.com/topic/220230

1. HTTP 定義了與服務器交互的不同方法，最基本的方法是 GET 和 POST。事實上 GET 適用于多數請求，而保留 POST 僅用于更新站點。根據 HTTP 規范，GET 用于信息獲取，而且應該是 安全的和 冪等的。所謂安全的意味著該操作用于獲取信息而非修改信息。換句話說，GET 請求一般不應產生副作用。冪等的意味著對同一 URL 的多個請求應該返回同樣的結果。完整的定義并不像看起來那樣嚴格。從根本上講，其目標是當用戶打開一個鏈接時，她可以確信從自身的角度來看沒有改變資源。比如，新聞站點的頭版不斷更新。雖然第二次請求會返回不同的一批新聞，該操作仍然被認為是安全的和冪等的，因為它總是返回當前的新聞。反之亦然。POST 請求就不那么輕松了。POST 表示可能改變服務器上的資源的請求。仍然以新聞站點為例，讀者對文章的注解應該通過 POST 請求實現，因為在注解提交之后站點已經不同了（比方說文章下面出現一條注解）；
2. 在FORM提交的時候，如果不指定Method，則默認為GET請求，Form中提交的數據將會附加在url之后，以?分開與url分開。字母數字字符原樣發送，但空格轉換為“+“號，其它符號轉換為%XX,其中XX為該符號以16進制表示的ASCII（或ISO Latin-1）值。GET請求請提交的數據放置在HTTP請求協議頭中，而POST提交的數據則放在實體數據中；
3. GET方式提交的數據最多只能有1024字節，而POST則沒有此限制。

Web 上最常用的兩種 Http 請求就是 Get 請求和 Post 請求了。我們在做 java web 開發時，也總會在 servlet 中通過 doGet 和 doPost 方法來處理請求；更經常地，我們會在 doGet 方法的實現中調用 doPost 方法。盡管做了近兩年的 web 開發，我對諸如 Get 請求和 Post 請求的基本概念仍不是十分了解。近日閱讀《 javascript 高級程序設計》重新整理了一下 Get 請求和 Post 請求的概念，算是讀書筆記吧。

Get 是從服務器上獲取數據，這是最常見的請求類型。每次在瀏覽器中輸入 URL 打開頁面時，就是向服務器發送一個 Get 請求。 Get 請求的參數是用問號追加到 URL 結尾，后面跟著用＆連接起來的名稱／值對。比如網址 http://bt.neupioneer.com/viewthread.php?tid=87813 ，其中 tid 為參數名， 87813 為參數的值。在編程中，使用 Get 最多的地方就是超鏈接列表，其中的參數多是從數據庫讀出的字段拼接而成。在 Ajax 中，我們也經常使用 Get ，通過提取出頁面的標簽值，拼成串后構造一個 URL 。 Get 在使用上是有限制的， URL 的最大長度為 2KB ，因此，如果表單中包含textarea這樣的大文本段，就不要用Get了。對于表單來說， Get 是把參數數據隊列加到提交表單的 ACTION 屬性所指的 URL 中，值和表單內各個字段一一對應，通過 URL 可以看到中傳遞的參數。因此，相比于 Post ，它是不安全的。

Post 的使用場合多是在表單提交的地方，因為和 Get 相比， Post 可以發送更多的數據，《 javascript 高級程序設計》中說最多可以發送 2GB ，這多少讓我不太相信，網上一些文章說 IIS4 中最大量為 80KB ， IIS5 中為 100KB ，不知道 Tomcat 中的情況如何。 Post 是通過 HTTP Post 機制，將表單內各個字段與其內容放置在 HTML Header 內一起傳送到 ACTION 屬性所指的 URL 地址。 和 Get 相比， Post 的內容是不會在 URL 中顯現出來的，這多少是安全一些的。 我在做登錄這樣的表單時，只是將請求方式設為 Post ，使得用戶名和密碼信息不在瀏覽器中顯現，但不清楚的是，是否有更好的方法加密密碼等信息（實在不知道如果請求不傳到服務器的話，怎么對未知的請求加密，清楚的朋友不妨給個解決方案）。在 Ajax 中，如果要和服務器交互，記得加上 request.setRequestHeader(“Content-Type”,”application/x-www-urlencoded”); 這一腳本，盡管很多 Ajax 教材中都提到了這一點。另外要說的是，被傳遞的參數是要經過編碼的。在 javascript 中，編碼函數是 encodeURIComponent(xx) 。  
    以上轉自 http://blog.csdn.net/yoland/archive/2009/03/19/4005740.aspx
一個get的發送請求例子：
GET /select/selectBeerTaste.jsp?color=dark&taste=malty HTTP/1.1
Host: www.wickedlysmart.com
User-Agent: Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.4) Gecko/
20030624 Netscape/7.1
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/
plain;q=0.8,video/x-mng,image/png,image/jpeg,image/gif;q=0.2,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive

一個post的發送請求例子：
POST /advisor/selectBeerTaste.do HTTP/1.1
Host: www.wickedlysmart.com
User-Agent: Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.4) Gecko/
20030624 Netscape/7.1
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/
plain;q=0.8,video/x-mng,image/png,image/jpeg,image/gif;q=0.2,*/*;q=0.1
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive
color=dark&taste=malty (Request headers 后面有一個傳參數的body)
兩個例子的紅色的部分很好的看出了get和post傳參數區別

上面是CAS 基礎協議圖 

CAS 介紹

CAS 具有以下特點：

• 開源的企業級單點登錄解決方案。
• CAS Server 為需要獨立部署的 Web 應用。
• CAS Client 支持非常多的客戶端(這里指單點登錄系統中的各個 Web 應用)，包括 Java, .Net, PHP, Perl, Apache, uPortal, Ruby 等。

CAS 原理和協議

從結構上看，CAS 包含兩個部分： CAS Server 和 CAS Client。CAS Server 需要獨立部署，主要負責對用戶的認證工作；CAS Client 負責處理對客戶端受保護資源的訪問請求，需要登錄時，重定向到 CAS Server。

CAS Client 與受保護的客戶端應用部署在一起，以 Filter 方式保護受保護的資源。對于訪問受保護資源的每個 Web 請求，CAS Client 會分析該請求的 Http 請求中是否包含 Service Ticket，如果沒有，則說明當前用戶尚未登錄，于是將請求重定向到指定好的 CAS Server 登錄地址，并傳遞 Service （也就是要訪問的目的資源地址），以便登錄成功過后轉回該地址。用戶在第 3 步中輸入認證信息，如果登錄成功，CAS Server 隨機產生一個相當長度、唯一、不可偽造的 Service Ticket，并緩存以待將來驗證，之后系統自動重定向到 Service 所在地址，并為客戶端瀏覽器設置一個 Ticket Granted Cookie（TGC），CAS Client 在拿到 Service 和新產生的 Ticket 過后，在第 5，6 步中與 CAS Server 進行身份合適，以確保 Service Ticket 的合法性。

在該協議中，所有與 CAS 的交互均采用 SSL 協議，確保，ST 和 TGC 的安全性。協議工作過程中會有 2 次重定向的過程，但是 CAS Client 與 CAS Server 之間進行 Ticket 驗證的過程對于用戶是透明的。

另外，CAS 協議中還提供了 Proxy （代理）模式，以適應更加高級、復雜的應用場景，具體介紹可以參考 CAS 官方網站上的相關文檔。

在 Tomcat 上部署一個完整的 CAS Server 主要按照以下幾個步驟：

配置 Tomcat 使用 Https 協議

如果希望 Tomcat 支持 Https，主要的工作是配置 SSL 協議，其配置過程和配置方法可以參考 Tomcat 的相關文檔。不過在生成證書的過程中，會有需要用到主機名的地方，CAS 建議不要使用 IP 地址，而要使用機器名或域名。（項目過程中沒使用）

部署 CAS Server

CAS Server 是一個 Web 應用包，將前面下載的 cas-server-3.1.1-release.zip 解開，把其中的 cas-server-webapp-3.1.1.war 拷貝到 tomcat的 webapps 目錄，并更名為 cas.war。由于前面已配置好 tomcat 的 https 協議，可以重新啟動 tomcat，然后訪問：https://localhost:8443/cas（沒配置ssh應該是http://localhost:8080/cas） ，如果能出現正常的 CAS 登錄頁面，則說明 CAS Server 已經部署成功。

雖然 CAS Server 已經部署成功，但這只是一個缺省的實現，在實際使用的時候，還需要根據實際概況做擴展和定制，最主要的是擴展認證 (Authentication) 接口和 CAS Server 的界面。

參考http://www.ibm.com/developerworks/cn/opensource/os-cn-cas/index.html
項目也采用jdbc驗證,文章介紹了三個基于 JDBC 的 AuthenticationHandler，我使用的cas-server 3.3 多了一個AbstractJdbcUsernamePasswordAuthenticationHandler 直接使用。

部署客戶端應用

單點登錄的目的是為了讓多個相關聯的應用使用相同的登錄過程，使用的是cas-client-core- 3.1.9.jar 放入要使用單點登錄項目的lib下。cas客戶端使用的是過濾器，在web.xml配置。可以使用spring配置bean。官方網站http://www.ja-sig.org/wiki/display/CASC/Configuring+the+JA- SIG+CAS+Client+for+Java+using+Spring 有配置。
用類擴展 Cas20ProxyReceivingTicketValidationFilter復寫onSuccessfulValidation方法，寫入驗證成功后做的事情，比如把用戶信息放入session。寫了一個a.jsp用于跳轉，過濾器針對他，訪問這個頁面的時候，會到cas服務器端，如果成功的話，返回到a.jsp，這個頁面用sendRedirect調用了一個action方法處理登錄成功后直接進入項目首頁。

posted @ 2009-11-12 20:57 yuxh 閱讀(1267) | 評論 (0) | 編輯 收藏

synchronized(getServletContext()) {
     getServletContext().setAttribute(“foo”, “22”);
     getServletContext().setAttribute(“bar”, “42”);
     out.println(getServletContext().getAttribute(“foo”));
     out.println(getServletContext().getAttribute(“bar”));
 }