笔记

    数组可以装基本类型或者引用，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 阅读(1250) | 评论 (0) | 编辑 收藏

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