而在其它的编辑器中，默认保存的内容都是GB2312或者GBK（NOTEPAD中对应ANSI）.而根据前面所说的UTF-8和GBK,GB2312等的编码值是不同的这一点，可以知道，如果文件使用了UTF-8，那么字符编码就必须使用UTF-8，否则编码值的不同就可能造成乱码。而这也就是为什么那么多的人使用了UTF-8编码后还会产生乱码的根本原因。（JS和JSP都是这个道理）

3、JSP,STRUTS等的中文乱码解决方案
     其实解决的方法只有一个：

 request.setCharacterEncoding(encoding);

   方法只有一种，但处理方式就多种多样了，初学者会在JSP页面上直接使用，而有经验的程序员会使用过滤器。而现在所要说的方法也是过滤器。这里以统一使用UTF-8作为编码作为例子说明。具体过程就不多说了，网上有很多教程。偷懒一点的，到TOMCAT中复制就行了。在TOMCAT的目录下的\webapps\jsp-examples\WEB-INF\classes\filters\找到SetCharacterEncodingFilter.java 这个类，放到你的程序中并配置好映射路径。配置好后基本上你的乱码问题就解决了。但要映射路径中需要注意的就是不能使用 '*'

   < filter-mapping >
     < filter-name > Set Character Encoding </ filter-name >
     < servlet-name > * </ servlet-name >
   </ filter-mapping >

像上面这样配置的话(可能也是网上大多教程的做法，想当年也是害苦了我)，可能你只有JSP的乱码解决了，要解决STRUTS的乱码需要映射 *.do 或者 servletActionName。然后在初始化参数中设置encoding的值就行了。

< init-param >
       < param-name > encoding </ param-name >
       < param-value > UTF-8 </ param-value >
</ init-param >

当然，最重要的是要记得根据前面所说的方法，改变你所使用的编辑器保存文件的编码要与使用的字符编码一致。
而在JSP内容中，还是使用如网上教程所说的那种技俩，在所有页面的页首加入：

<% @ page language = "java" contentType = " text / html; charset = UTF - 8 "
    pageEncoding = "UTF - 8 " %>

xmlhttp.open( "post", url, async );
xmlhttp.setRequestHeader( "Content-Type", "text/html" );
xmlhttp.send( params );

通过前面的说明，不知道你现在看出端倪了没有。不知道是受了网上教程的影响还是其它方面影响，setRequestHeader并是万年不变的，也没人想过去改它，而问题就正好出在这个地方。回想一个JSP页面内容的编码设置，其中有这么一节：

contentType="text/html; charset=UTF-8"

现在知道问题了吧，所以我们要把第二句代码改为：

xmlhttp.setRequestHeader( "Content-Type", "text/html;charset=UTF-8" );

最后别忘了在返回数据时也设置上：

response.setContentType( "text/xml" );
response.setCharacterEncoding( "UTF-8" );

是不是很简单，一点都不麻烦呢？
如果要问为什么的话，其实我们可以把xmlhttp看成是一个临时页面，它由浏览器动态生成，主要作用是在后台获得请求的数据（可以看成是一个高级的iframe）。所以对于普通页面设置的编码，对它也要同样设置。而在servlet中返回数据为什么要设置contentType和encoding其道理也是一样的。众所周知，jsp的最后形态就是servlet，而jsp页首设置的那个内容其实也就是让生成的servlet中生成这么两句话：

response.setContentType( "text/html" );
response.setCharacterEncoding( "UTF-8" );

而pageEncoding则是跟jvm说明了这个页面的内容要使用什么编码保存（这跟之后生成的CLASS有关系）。所以在servlet设置response的编码也是理所当然的了。

一口气把自己一年以来遇到的乱码问题和解决的方案写出来了，希望对你有所帮助。

 contextLoader的源码
 public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
   throws BeansException {

  long startTime = System.currentTimeMillis();
  if (logger.isInfoEnabled()) {
   logger.info("Root WebApplicationContext: initialization started");
  }
  servletContext.log("Loading Spring root WebApplicationContext");

  try {
   // Determine parent for root web application context, if any.
   ApplicationContext parent = loadParentContext(servletContext);

   WebApplicationContext wac = createWebApplicationContext(servletContext, parent);
   servletContext.setAttribute(
     WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);

   if (logger.isInfoEnabled()) {
    logger.info("Using context class [" + wac.getClass().getName() +
      "] for root WebApplicationContext");
   }
   if (logger.isDebugEnabled()) {
    logger.debug("Published root WebApplicationContext [" + wac +
      "] as ServletContext attribute with name [" +
      WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
   }

   if (logger.isInfoEnabled()) {
    long elapsedTime = System.currentTimeMillis() - startTime;
    logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
   }

   return wac;
  }
  catch (RuntimeException ex) {
   logger.error("Context initialization failed", ex);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
   throw ex;
  }
  catch (Error err) {
   logger.error("Context initialization failed", err);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
   throw err;
  }
 }
 注意WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,这里面放了WebApplicationContext,需要使用时从ServletContext取出
 可以使用WebApplicationContextUtils得到WebApplicationContext
 public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
  Object attr = sc.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
  if (attr == null) {
   return null;
  }
  if (attr instanceof RuntimeException) {
   throw (RuntimeException) attr;
  }
  if (attr instanceof Error) {
   throw (Error) attr;
  }
  if (!(attr instanceof WebApplicationContext)) {
   throw new IllegalStateException("Root context attribute is not of type WebApplicationContext: " + attr);
  }
  return (WebApplicationContext) attr;
 }
 关键的问题在于struts如何启动的spring的,ContextLoaderPlugIn的源码
 
 // Publish the context as a servlet context attribute.
  String attrName = getServletContextAttributeName();
  getServletContext().setAttribute(attrName, wac);
 
 public String getServletContextAttributeName() {
  return SERVLET_CONTEXT_PREFIX + getModulePrefix();
 }
 不同加载的Key竟然不同,原因就是WebApplicationContext放在那里的问题,可spring调用的时候会根据WebApplicationContext里面定义的那个名字去找的,问题出在这里

 在struts-config.xml中配置
    <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
      <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
    </plug-in>

    <controller>
        <set-property property="processorClass" value="org.springframework.web.struts.DelegatingRequestProcessor" />
    </controller>

 原理是这样的,Struts虽然只能有一个ActionServlet实例,但是对于不同的子应用分别能有自己的RequestProcessor实例每个RequestProcessor实例分别对应不同的struts配置文件。
   子应用的ProcessorClass类必须重写一般就是继承RequestProcessor类，然后再其配置文件的controller元素中的<processorClass>属性中作出修改。那么当
  getRequestProcessor(getModuleConfig(request)).process(request,response);就能根据request选择相应的moduleconfig,再根据其<processorClass>属性选择相应的RequestProcessor子类来处理相应的请求了。

ServletContext 被 Servlet 程序用来与 Web 容器通信。例如写日志，转发请求。每一个 Web 应用程序含有一个Context，被Web应用内的各个程序共享。因为Context可以用来保存资源并且共享，所以我所知道的 ServletContext 的最大应用是Web缓存----把不经常更改的内容读入内存，所以服务器响应请求的时候就不需要进行慢速的磁盘I/O了。

import User; //my own class
import DatabaseManager; // my own class
import javax.servlet.ServletContext;
import javax.servlet.ServletContextListener;

public class MyContextListener

	implements ServletContextListener {
	private ServletContext context = null;

	public void contextInitialized(ServletContextEvent event) {
		context = event.getServletContext();
		User user = DatabaseManager.getUserById(1);
		context.setAttribute("user1", user);
	}

	public void contextDestroyed(ServletContextEvent event) {
		User user = (User)context.getAttribute("user1");
		DatabaseManager.updateUserData(user);
		this.context = null;
	}
}

<listener>
	<listener-class>MyServletContextListener</listener-class>
</listener>

图三 deploytool的启动画面

图四 新建一个Application

图五 将.class文件添加到SecurityJar中

图六 将ClientCode目录下的文件添加到SecurityJar中

图七 SecurityApp的JNDI Names标签页的设置

图八 SecurityApp的Web Context标签页的设置

图九 发布完成后的Deployment Progress

图十 运行效果第一个页面（加密/解密请求窗）


图十一 运行效果第二个页面（加密/解密结果显示页）

SQL语句：
是对数据库(数据)进行操作的惟一途径；
消耗了70%~90%的数据库资源；独立于程序设计逻辑，相对于对程序源代码的优化，对SQL语句的优化在时间成本和风险上的代价都很低；
可以有不同的写法；易学，难精通。

SQL优化：
固定的SQL书写习惯，相同的查询尽量保持相同，存储过程的效率较高。
应该编写与其格式一致的语句，包括字母的大小写、标点符号、换行的位置等都要一致

ORACLE优化器：
在任何可能的时候都会对表达式进行评估，并且把特定的语法结构转换成等价的结构，这么做的原因是
要么结果表达式能够比源表达式具有更快的速度
要么源表达式只是结果表达式的一个等价语义结构
不同的SQL结构有时具有同样的操作（例如：= ANY (subquery) and IN (subquery)），ORACLE会把他们映射到一个单一的语义结构。

1 常量优化：
常量的计算是在语句被优化时一次性完成，而不是在每次执行时。下面是检索月薪大于2000的的表达式：
sal > 24000/12
sal > 2000
sal*12 > 24000
如果SQL语句包括第一种情况，优化器会简单地把它转变成第二种。
优化器不会简化跨越比较符的表达式，例如第三条语句，鉴于此，应尽量写用常量跟字段比较检索的表达式，而不要将字段置于表达式当中。否则没有办法优化，比如如果sal上有索引，第一和第二就可以使用，第三就难以使用。

2 操作符优化：
优化器把使用LIKE操作符和一个没有通配符的表达式组成的检索表达式转换为一个“=”操作符表达式。
例如：优化器会把表达式ename LIKE 'SMITH'转换为ename = 'SMITH'
优化器只能转换涉及到可变长数据类型的表达式，前一个例子中，如果ENAME字段的类型是CHAR(10)， 那么优化器将不做任何转换。
一般来讲LIKE比较难以优化。

其中：
~~ IN 操作符优化：
优化器把使用IN比较符的检索表达式替换为等价的使用“=”和“OR”操作符的检索表达式。
例如，优化器会把表达式ename IN ('SMITH','KING','JONES')替换为
ename = 'SMITH' OR ename = 'KING' OR ename = 'JONES‘

~~ ANY和SOME 操作符优化:
优化器将跟随值列表的ANY和SOME检索条件用等价的同等操作符和“OR”组成的表达式替换。
例如，优化器将如下所示的第一条语句用第二条语句替换：
sal > ANY (:first_sal, :second_sal)
sal > :first_sal OR sal > :second_sal
优化器将跟随子查询的ANY和SOME检索条件转换成由“EXISTS”和一个相应的子查询组成的检索表达式。
例如，优化器将如下所示的第一条语句用第二条语句替换：
x > ANY (SELECT sal FROM emp WHERE job = 'ANALYST')
EXISTS (SELECT sal FROM emp WHERE job = 'ANALYST' AND x > sal)

~~ ALL操作符优化:
优化器将跟随值列表的ALL操作符用等价的“=”和“AND”组成的表达式替换。例如：
sal > ALL (:first_sal, :second_sal)表达式会被替换为：
sal > :first_sal AND sal > :second_sal
对于跟随子查询的ALL表达式，优化器用ANY和另外一个合适的比较符组成的表达式替换。例如
x > ALL (SELECT sal FROM emp WHERE deptno = 10) 替换为：
NOT (x <= ANY (SELECT sal FROM emp WHERE deptno = 10))
接下来优化器会把第二个表达式适用ANY表达式的转换规则转换为下面的表达式：
NOT EXISTS (SELECT sal FROM emp WHERE deptno = 10 AND x <= sal)

~~ BETWEEN 操作符优化:
优化器总是用“>=”和“<=”比较符来等价的代替BETWEEN操作符。
例如：优化器会把表达式sal BETWEEN 2000 AND 3000用sal >= 2000 AND sal <= 3000来代替。

~~ NOT 操作符优化:
优化器总是试图简化检索条件以消除“NOT”逻辑操作符的影响，这将涉及到“NOT”操作符的消除以及代以相应的比较运算符。
例如，优化器将下面的第一条语句用第二条语句代替：
NOT deptno = (SELECT deptno FROM emp WHERE ename = 'TAYLOR')
deptno <> (SELECT deptno FROM emp WHERE ename = 'TAYLOR')
通常情况下一个含有NOT操作符的语句有很多不同的写法，优化器的转换原则是使“NOT”操作符后边的子句尽可能的简单，即使可能会使结果表达式包含了更多的“NOT”操作符。
例如，优化器将如下所示的第一条语句用第二条语句代替：
NOT (sal < 1000 OR comm IS NULL)
NOT sal < 1000 AND comm IS NOT NULL sal >= 1000 AND comm IS NOT NULL

如何编写高效的SQL:
当然要考虑sql常量的优化和操作符的优化啦，另外，还需要：

1 合理的索引设计：
例：表record有620000行，试看在不同的索引下，下面几个SQL的运行情况：
语句A
SELECT count(*) FROM record
WHERE date >'19991201' and date < '19991214‘ and amount >2000

语句B
SELECT count(*) FROM record
WHERE date >'19990901' and place IN ('BJ','SH')

语句C
SELECT date,sum(amount) FROM record
group by date
1 在date上建有一个非聚集索引
A：(25秒)
B：(27秒)
C：(55秒)
分析：
date上有大量的重复值，在非聚集索引下，数据在物理上随机存放在数据页上，在范围查找时，必须执行一次表扫描才能找到这一范围内的全部行。
2 在date上的一个聚集索引
A：（14秒）
B：（14秒）
C：（28秒）
分析：
在聚集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范围扫描，提高了查询速度。
3 在place，date，amount上的组合索引
A：（26秒）
C：（27秒）
B：（< 1秒）
分析：
这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条SQL没有引用place，因此也没有利用上索引；第三个SQL使用了place，且引用的所有列都包含在组合索引中，形成了索引覆盖，所以它的速度是非常快的。
4 在date，place，amount上的组合索引
A： (< 1秒)
B：（< 1秒）
C：（11秒）
分析：
这是一个合理的组合索引。它将date作为前导列，使每个SQL都可以利用索引，并且在第一和第三个SQL中形成了索引覆盖，因而性能达到了最优。

总结1
缺省情况下建立的索引是非聚集索引，但有时它并不是最佳的；合理的索引设计要建立在对各种查询的分析和预测上。一般来说：
有大量重复值、且经常有范围查询（between, >,< ，>=,< =）和order by、group by发生的列，考虑建立聚集索引；
经 常同时存取多列，且每列都含有重复值可考虑建立组合索引；在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要建立索引。比如在雇员 表的“性别”列上只有“男”与“女”两个不同值，因此就无必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度。
组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。

2 避免使用不兼容的数据类型：
例如float和INt、char和varchar、bINary和varbINary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。例如:
SELECT name FROM employee WHERE salary ＞ 60000
在这条语句中,如salary字段是money型的,则优化器很难对其进行优化,因为60000是个整型数。我们应当在编程时将整型转化成为钱币型,而不要等到运行时转化。

3 IS NULL 与IS NOT NULL：
不 能用null作索引，任何包含null值的列都将不会被包含在索引中。即使索引有多列这样的情况下，只要这些列中有一列含有null，该列就会从索引中排 除。也就是说如果某列存在空值，即使对该列建索引也不会提高性能。任何在WHERE子句中使用is null或is not null的语句优化器是不允 许使用索引的。

4 IN和EXISTS：
EXISTS要远比IN的效率高。里面关系到full table scan和range scan。几乎将所有的IN操作符子查询改写为使用EXISTS的子查询。
例子：
语句1
SELECT dname, deptno FROM dept
WHERE deptno NOT IN
(SELECT deptno FROM emp);
语句2
SELECT dname, deptno FROM dept
WHERE NOT EXISTS
(SELECT deptno FROM emp
WHERE dept.deptno = emp.deptno);
明显的，2要比1的执行性能好很多
因为1中对emp进行了full table scan,这是很浪费时间的操作。而且1中没有用到emp的INdex，
因为没有WHERE子句。而2中的语句对emp进行的是range scan。

5 IN、OR子句常会使用工作表，使索引失效：
如果不产生大量重复值，可以考虑把子句拆开。拆开的子句中应该包含索引。

6 避免或简化排序：
应当简化或避免对大型表进行重复的排序。当能够利用索引自动以适当的次序产生输出时，优化器就避免了排序的步骤。以下是一些影响因素：
索引中不包括一个或几个待排序的列；
group by或order by子句中列的次序与索引的次序不一样；
排序的列来自不同的表。
为了避免不必要的排序，就要正确地增建索引，合理地合并数据库表（尽管有时可能影响表的规范化，但相对于效率的提高是值得的）。如果排序不可避免，那么应当试图简化它，如缩小排序的列的范围等。

7 消除对大型表行数据的顺序存取：
在 嵌套查询中，对表的顺序存取对查询效率可能产生致命的影响。比如采用顺序存取策略，一个嵌套3层的查询，如果每层都查询1000行，那么这个查询就要查询 10亿行数据。避免这种情况的主要方法就是对连接的列进行索引。例如，两个表：学生表（学号、姓名、年龄??）和选课表（学号、课程号、成绩）。如果两个 表要做连接，就要在“学号”这个连接字段上建立索引。
还可以使用并集来避免顺序存取。尽管在所有的检查列上都有索引，但某些形式的WHERE子句强迫优化器使用顺序存取。下面的查询将强迫对orders表执行顺序操作：
SELECT ＊ FROM orders WHERE (customer_num=104 AND order_num>1001) OR order_num=1008
虽然在customer_num和order_num上建有索引，但是在上面的语句中优化器还是使用顺序存取路径扫描整个表。因为这个语句要检索的是分离的行的集合，所以应该改为如下语句：
SELECT ＊ FROM orders WHERE customer_num=104 AND order_num>1001
UNION
SELECT ＊ FROM orders WHERE order_num=1008
这样就能利用索引路径处理查询。

8 避免相关子查询：
一个列的标签同时在主查询和WHERE子句中的查询中出现，那么很可能当主查询中的列值改变之后，子查询必须重新查询一次。查询嵌套层次越多，效率越低，因此应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的行。

9 避免困难的正规表达式：
MATCHES和LIKE关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗费时间。例如：SELECT ＊ FROM customer WHERE zipcode LIKE “98_ _ _”
即使在zipcode字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如果把语句改为SELECT ＊ FROM customer WHERE zipcode >“98000”，在执行查询时就会利用索引来查询，显然会大大提高速度。
另外，还要避免非开始的子串。例如语句：SELECT ＊ FROM customer WHERE zipcode[2，3] >“80”，在WHERE子句中采用了非开始子串，因而这个语句也不会使用索引。

10 不充份的连接条件：
例：表card有7896行，在card_no上有一个非聚集索引，表account有191122行，在account_no上有一个非聚集索引，试看在不同的表连接条件下，两个SQL的执行情况：
SELECT sum(a.amount) FROM account a,card b WHERE a.card_no = b.card_no
（20秒）
将SQL改为：
SELECT sum(a.amount) FROM account a,card b WHERE a.card_no = b.card_no and a.account_no=b.account_no
（< 1秒）
分析：
在第一个连接条件下，最佳查询方案是将account作外层表，card作内层表，利用card上的索引，其I/O次数可由以下公式估算为：
外层表account上的22541页+（外层表account的191122行*内层表card上对应外层表第一行所要查找的3页）=595907次I/O
在第二个连接条件下，最佳查询方案是将card作外层表，account作内层表，利用account上的索引，其I/O次数可由以下公式估算为：
外层表card上的1944页+（外层表card的7896行*内层表account上对应外层表每一行所要查找的4页）= 33528次I/O
可见，只有充份的连接条件，真正的最佳方案才会被执行。
多表操作在被实际执行前，查询优化器会根据连接条件，列出几组可能的连接方案并从中找出系统开销最小的最佳方案。连接条件要充份考虑带有索引的表、行数多的表；内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，乘积最小为最佳方案。
不可优化的WHERE子句
例1
下列SQL条件语句中的列都建有恰当的索引，但执行速度却非常慢：
SELECT * FROM record WHERE substrINg(card_no,1,4)='5378'
(13秒)
SELECT * FROM record WHERE amount/30< 1000
（11秒）
SELECT * FROM record WHERE convert(char(10),date,112)='19991201'
（10秒）
分析：
WHERE子句中对列的任何操作结果都是在SQL运行时逐列计算得到的，因此它不得不进行表搜索，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那么就可以被SQL优化器优化，使用索引，避免表搜索，因此将SQL重写成下面这样：
SELECT * FROM record WHERE card_no like '5378%'
（< 1秒）
SELECT * FROM record WHERE amount< 1000*30
（< 1秒）
SELECT * FROM record WHERE date= '1999/12/01'
（< 1秒）

11 存储过程中，采用临时表优化查询：
例
1．从parven表中按vendor_num的次序读数据：
SELECT part_num，vendor_num，price FROM parven ORDER BY vendor_num
INTO temp pv_by_vn
这个语句顺序读parven（50页），写一个临时表（50页），并排序。假定排序的开销为200页，总共是300页。
2．把临时表和vendor表连接，把结果输出到一个临时表，并按part_num排序：
SELECT pv_by_vn，＊ vendor.vendor_num FROM pv_by_vn，vendor
WHERE pv_by_vn.vendor_num=vendor.vendor_num
ORDER BY pv_by_vn.part_num
INTO TMP pvvn_by_pn
DROP TABLE pv_by_vn
这 个查询读取pv_by_vn(50页)，它通过索引存取vendor表1.5万次，但由于按vendor_num次序排列，实际上只是通过索引顺序地读 vendor表（40＋2=42页），输出的表每页约95行，共160页。写并存取这些页引发5＊160=800次的读写，索引共读写892页。
3．把输出和part连接得到最后的结果：
SELECT pvvn_by_pn.＊，part.part_desc FROM pvvn_by_pn，part
WHERE pvvn_by_pn.part_num=part.part_num
DROP TABLE pvvn_by_pn
这样，查询顺序地读pvvn_by_pn(160页)，通过索引读part表1.5万次，由于建有索引，所以实际上进行1772次磁盘读写，优化比例为30∶1。

好了，搞定。
其实sql的优化，各种数据库之间都是互通的

影响SQL server性能的关键三个方面(转贴)

关键词：Sql Server

转贴自:http://202.200.129.193/
1 逻辑数据库和表的设计
数据库的逻辑设计、包括表与表之间的关系是优化关系型数据库性能的核心。一个好的逻辑数据库设计可以为

优化数据库和应用程序打下良好的基础。

标准化的数据库逻辑设计包括用多的、有相互关系的窄表来代替很多列的长数据表。下面是一些使用标准化

表的一些好处。

A:由于表窄，因此可以使排序和建立索引更为迅速

B:由于多表，所以多镞的索引成为可能

C:更窄更紧凑的索引

D:每个表中可以有少一些的索引，因此可以提高insert update delete等的速度，因为这些操作在索引

多的情况下会对系统性能产生很大的影响

E:更少的空值和更少的多余值，增加了数据库的紧凑性

由于标准化，所以会增加了在获取数据时引用表的数目和其间的连接关系的复杂性。太多的表和复杂的连接关系会降低服务器的性能，因此在这两者之间需要综合考虑。
定义具有相关关系的主键和外来键时应该注意的事项主要是：用于连接多表的主键和参考的键要有相同的数据类型。

2 索引的设计
A:尽量避免表扫描
检查你的查询语句的where子句，因为这是优化器重要关注的地方。包含在where里面的每一列（column)都是可能的侯选索引，为能达到最优的性能，考虑在下面给出的例子：对于在where子句中给出了column1这个列。
下面的两个条件可以提高索引的优化查询性能！
第一：在表中的column1列上有一个单索引
第二：在表中有多索引，但是column1是第一个索引的列
避免定义多索引而column1是第二个或后面的索引，这样的索引不能优化服务器性能
例如：下面的例子用了pubs数据库。
SELECT au_id, au_lname, au_fname FROM authors
WHERE au_lname = 'White'
按下面几个列上建立的索引将会是对优化器有用的索引
?au_lname
?au_lname, au_fname
而在下面几个列上建立的索引将不会对优化器起到好的作用
?au_address
?au_fname, au_lname
考虑使用窄的索引在一个或两个列上，窄索引比多索引和复合索引更能有效。用窄的索引，在每一页上
将会有更多的行和更少的索引级别（相对与多索引和复合索引而言），这将推进系统性能。
对于多列索引，SQL Server维持一个在所有列的索引上的密度统计（用于联合）和在第一个索引上的
histogram（柱状图）统计。根据统计结果，如果在复合索引上的第一个索引很少被选择使用，那么优化器对很多查询请求将不会使用索引。
有用的索引会提高select语句的性能，包括insert,uodate,delete。
但是，由于改变一个表的内容，将会影响索引。每一个insert,update,delete语句将会使性能下降一些。实验表明，不要在一个单表上用大量的索引，不要在共享的列上（指在多表中用了参考约束）使用重叠的索引。
在某一列上检查唯一的数据的个数，比较它与表中数据的行数做一个比较。这就是数据的选择性，这比较结果将会帮助你决定是否将某一列作为侯选的索引列，如果需要，建哪一种索引。你可以用下面的查询语句返回某一列的不同值的数目。
select count(distinct cloumn_name) from table_name
假设column_name是一个10000行的表，则看column_name返回值来决定是否应该使用，及应该使用什么索引。
Unique values Index

5000 Nonclustered index
20 Clustered index
3 No index

镞索引和非镞索引的选择

<1:>镞索引是行的物理顺序和索引的顺序是一致的。页级，低层等索引的各个级别上都包含实际的数据页。一个表只能是有一个镞索引。由于update,delete语句要求相对多一些的读操作，因此镞索引常常能加速这样的操作。在至少有一个索引的表中，你应该有一个镞索引。
在下面的几个情况下，你可以考虑用镞索引：
例如： 某列包括的不同值的个数是有限的（但是不是极少的）
顾客表的州名列有50个左右的不同州名的缩写值，可以使用镞索引。
例如： 对返回一定范围内值的列可以使用镞索引，比如用between,>,>=,<,<=等等来对列进行操作的列上。
select * from sales where ord_date between '5/1/93' and '6/1/93'
例如： 对查询时返回大量结果的列可以使用镞索引。
SELECT * FROM phonebook WHERE last_name = 'Smith'

当有大量的行正在被插入表中时，要避免在本表一个自然增长（例如，identity列）的列上建立镞索引。如果你建立了镞的索引，那么insert的性能就会大大降低。因为每一个插入的行必须到表的最后，表的最后一个数据页。
当一个数据正在被插入（这时这个数据页是被锁定的），所有的其他插入行必须等待直到当前的插入已经结束。
一个索引的叶级页中包括实际的数据页，并且在硬盘上的数据页的次序是跟镞索引的逻辑次序一样的。

<2:>一个非镞的索引就是行的物理次序与索引的次序是不同的。一个非镞索引的叶级包含了指向行数据页的指针。
在一个表中可以有多个非镞索引，你可以在以下几个情况下考虑使用非镞索引。
在有很多不同值的列上可以考虑使用非镞索引
例如：一个part_id列在一个part表中
select * from employee where emp_id = 'pcm9809f'
查询语句中用order by 子句的列上可以考虑使用镞索引

3 查询语句的设计

SQL Server优化器通过分析查询语句，自动对查询进行优化并决定最有效的执行方案。优化器分析查询语句来决定那个子句可以被优化，并针对可以被优化查询的子句来选择有用的索引。最后优化器比较所有可能的执行方案并选择最有效的一个方案出来。
在执行一个查询时，用一个where子句来限制必须处理的行数，除非完全需要，否则应该避免在一个表中无限制地读并处理所有的行。
例如下面的例子，
select qty from sales where stor_id=7131
是很有效的比下面这个无限制的查询
select qty from sales
避免给客户的最后数据选择返回大量的结果集。允许SQL Server运行满足它目的的函数限制结果集的大小是更有效的。
这能减少网络I/O并能提高多用户的相关并发时的应用程序性能。因为优化器关注的焦点就是where子句的查询，以利用有用的索引。在表中的每一个索引都可能成为包括在where子句中的侯选索引。为了最好的性能可以遵照下面的用于一个给定列column1的索引。
第一：在表中的column1列上有一个单索引
第二：在表中有多索引，但是column1是第一个索引的列不要在where子句中使用没有column1列索引的查询语句，并避免在where子句用一个多索引的非第一个索引的索引。
这时多索引是没有用的。
For example, given a multicolumn index on the au_lname, au_fname columns of the authors table in
the pubs database,
下面这个query语句利用了au_lname上的索引
SELECT au_id, au_lname, au_fname FROM authors
WHERE au_lname = 'White'
AND au_fname = 'Johnson'
SELECT au_id, au_lname, au_fname FROM authors
WHERE au_lname = 'White'
下面这个查询没有利用索引，因为他使用了多索引的非第一个索引的索引
SELECT au_id, au_lname, au_fname FROM authors
WHERE au_fname = 'Johnson'

/**
* Members
*/

public class Members implements java.io.Serializable {

  // Fields  

  private Integer id;
  private String name;
  private String password;
  private String sex;
  private String mail;

  // Constructors

  /** default constructor */
  public Members() {
  }

     /** minimal constructor */
  public Members(String name) {
    this.name = name;
  }
 
  /** full constructor */
  public Members(String name, String password, String sex, String mail) {
    this.name = name;
    this.password = password;
    this.sex = sex;
    this.mail = mail;
  }

 
  // Property accessors

  public Integer getId() {
    return this.id;
  }
 
  public void setId(Integer id) {
    this.id = id;
  }

  public String getName() {
    return this.name;
  }
 
  public void setName(String name) {
    this.name = name;
  }

  public String getPassword() {
    return this.password;
  }
 
  public void setPassword(String password) {
    this.password = password;
  }

  public String getSex() {
    return this.sex;
  }
 
  public void setSex(String sex) {
    this.sex = sex;
  }

  public String getMail() {
    return this.mail;
  }
 
  public void setMail(String mail) {
    this.mail = mail;
  }
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
  <class name="com.yang.product.booksonline.dao.Members" table="members" catalog="books">
    <id name="id" type="integer">
        <column name="id" />
        <generator class="native" />
    </id>
    <property name="name" type="string">
        <column name="name" length="20" not-null="true" unique="true" />
    </property>
    <property name="password" type="string">
        <column name="password" length="20" />
    </property>
    <property name="sex" type="string">
        <column name="sex" length="10" />
    </property>
    <property name="mail" type="string">
        <column name="mail" length="50" />
    </property>
  </class>
</hibernate-mapping>

package com.yang.product.booksonline.dao;

import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.hibernate.criterion.Example;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
* Data access object (DAO) for domain model class Members.
* @see com.yang.product.booksonline.dao.Members
* @author lanxincao
*/
public class MembersDAO extends HibernateDaoSupport {

  private static final Log log = LogFactory.getLog(MembersDAO.class);

     protected void initDao() {
           //do nothing
     }
 
  public void save(Members transientInstance) {
    log.debug("saving Members instance");
    try {
        getHibernateTemplate().saveOrUpdate(transientInstance);
        log.debug("save successful");
    } catch (RuntimeException re) {
        log.error("save failed", re);
        throw re;
    }
  }
 
     public void delete(Members persistentInstance) {
    log.debug("deleting Members instance");
    try {
        getHibernateTemplate().delete(persistentInstance);
        log.debug("delete successful");
    } catch (RuntimeException re) {
        log.error("delete failed", re);
        throw re;
    }
  }
 
  public Members findById( java.lang.Integer id) {
    log.debug("getting Members instance with id: " + id);
    try {
        Members instance = (Members) getHibernateTemplate()
            .get("com.yang.product.booksonline.dao.Members", id);
        return instance;
    } catch (RuntimeException re) {
        log.error("get failed", re);
        throw re;
    }
  }
 
 
  public List findByExample(Members instance) {
    log.debug("finding Members instance by example");
    try {
        List results = getSession()
            .createCriteria("com.yang.product.booksonline.dao.Members")
            .add(Example.create(instance))
        .list();
        log.debug("find by example successful, result size: " + results.size());
        return results;
    } catch (RuntimeException re) {
        log.error("find by example failed", re);
        throw re;
    }
  }  
 
  public Members merge(Members detachedInstance) {
    log.debug("merging Members instance");
    try {
        Members result = (Members) getHibernateTemplate()
            .merge(detachedInstance);
        log.debug("merge successful");
        return result;
    } catch (RuntimeException re) {
        log.error("merge failed", re);
        throw re;
    }
  }

  public void attachDirty(Members instance) {
    log.debug("attaching dirty Members instance");
    try {
        getHibernateTemplate().saveOrUpdate(instance);
        log.debug("attach successful");
    } catch (RuntimeException re) {
        log.error("attach failed", re);
        throw re;
    }
  }
 
  public void attachClean(Members instance) {
    log.debug("attaching clean Members instance");
    try {
        getHibernateTemplate().lock(instance, LockMode.NONE);
        log.debug("attach successful");
    } catch (RuntimeException re) {
        log.error("attach failed", re);
        throw re;
    }
  }
 
  public List findByMembersName(String name){
       log.debug("finding by members' name.");
       try {
             return getHibernateTemplate().find("from Members as members where members.name = ?"
                         ,new String[]{name});
       } catch (RuntimeException re) {
             log.error("finding by members' name failed",re);
             throw re;
       }
  }

     public static MembersDAO getFromApplicationContext(ApplicationContext ctx) {
       return (MembersDAO) ctx.getBean("MembersDAO");
     }
}

三，spring配置
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
           <property name="driverClassName">
                 <value>com.mysql.jdbc.Driver</value>
           </property>
           <property name="url">
                 <value>jdbc:mysql://localhost:3306/books</value>
           </property>
           <property name="username">
                 <value>root</value>
           </property>
           <property name="password">
                 <value>snrdcqmq</value>
           </property>
     </bean>
     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
           <property name="dataSource">
                 <ref bean="dataSource" />
           </property>
           <property name="hibernateProperties">
                 <props>
                       <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                 </props>
           </property>
           <property name="mappingResources">
                 <list>
                       <value>com/yang/product/booksonline/dao/Members.hbm.xml</value>
                 </list>
           </property>
     </bean>
     <bean id="MembersDAO" class="com.yang.product.booksonline.dao.MembersDAO">
           <property name="sessionFactory">
                 <ref bean="sessionFactory" />
           </property>
     </bean>
    
     <bean name="/members" class="com.yang.product.booksonline.action.MembersAction">
           <property name="membersDAO">
                 <ref bean="MembersDAO"/>
           </property>
     </bean>
</beans>
四，struts配置及action类
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<struts-config>
<data-sources />
<form-beans >
  <form-bean name="membersForm" type="org.apache.struts.validator.DynaValidatorForm">
    <form-property name="sex" type="java.lang.String" />
    <form-property name="password" type="java.lang.String" />
    <form-property name="mail" type="java.lang.String" />
    <form-property name="name" type="java.lang.String" />
  </form-bean>

</form-beans>

<global-exceptions />
<global-forwards />
<action-mappings >
  <action
    attribute="membersForm"
    name="membersForm"
    parameter="action"
    path="/members"
    scope="request"
    type="org.springframework.web.struts.DelegatingActionProxy" >
    <forward name="loginSuccess" path="/index.jsp" />
    <forward name="registerSuccess" path="/index.jsp" />
    <forward name="logoutSuccess" path="/index.jsp" />
  </action>

</action-mappings>

<message-resources parameter="com.yang.product.booksonline.ApplicationResources" />
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
  <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
  <set-property property="stopOnFirstError" value="true" />
</plug-in>
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  <set-property property="contextConfigLocation" value="/WEB-INF/springContext.xml" />
</plug-in>

</struts-config>

package com.yang.product.booksonline.action;

import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;
import org.apache.struts.actions.DispatchAction;

import com.yang.product.booksonline.dao.Members;
import com.yang.product.booksonline.dao.MembersDAO;

/**
* XDoclet definition:
* @struts.action path="/members" name="membersForm" parameter="action" scope="request" validate="true"
*/
public class MembersAction extends DispatchAction {
     private MembersDAO membersDAO;

     public MembersDAO getMembersDAO() {
           return membersDAO;
     }

     public void setMembersDAO(MembersDAO membersDAO) {
           this.membersDAO = membersDAO;
     }
    
     public ActionForward login (ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) {
//            String url = request.getParameter("url");
           String name = (String)((DynaActionForm)form).get("name");
           String password = (String)((DynaActionForm)form).get("password");
           List members = membersDAO.findByMembersName(name);
           if (members != null && members.size() >0) {
                 Members member = (Members)members.get(0);
                 if (password.equals(member.getPassword())) {
                       request.getSession().setAttribute("member",name);
                       //return new ActionForward(url);
                       return mapping.findForward("loginSuccess");
                 } else {
                       return null;
                 }
           } else {
                 return null;
           }
     }

     public ActionForward logout (ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) {
           request.getSession().removeAttribute("member");
           return mapping.findForward("logoutSuccess");
     }

     public ActionForward register (ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response) {
           String name = (String)((DynaActionForm)form).get("name");
           String password = (String)((DynaActionForm)form).get("password");
           String sex = (String)((DynaActionForm)form).get("sex");
           String mail = (String)((DynaActionForm)form).get("mail");
           List members = membersDAO.findByMembersName(name);
           if (members != null && members.size() >0) {
                 return null;
           } else {
                 Members member = new Members();
                 member.setName(name);
                 member.setPassword(password);
                 member.setSex(sex);
                 member.setMail(mail);
                 membersDAO.save(member);
                 return mapping.findForward("registerSuccess");
           }
     }
}

注意到，这里使用了dispatchaction。
五，三个jsp部分内容
index.jsp
<body>
<logic:notPresent name="member" scope="session">
     Welcome,you have not <html:link href="login.jsp">login</html:link>. <br>
</logic:notPresent>
<logic:present name="member" scope="session">
     Welcome,<bean:write name="member" scope="session"/>.<html:link href="members.do?action=logout">Logout</html:link>
</logic:present>
</body>
login.jsp
<body>
  If you haven't registered the system,please <html:link href="register.jsp">register</html:link>
  <html:form action="/members.do?action=login" method="post" focus="name">
    <table border="0">
    <tr>
      <td><bean:message key="members.form.name.label"/>:</td>
      <td><html:text property="name" /></td>
    </tr>
    <tr>
      <td><bean:message key="members.form.password.label"/>:</td>
      <td><html:password property="password" /></td>
    </tr>
    <tr>
      <td colspan="2" align="center"><html:submit><bean:message key="members.form.login.label"/></html:submit></td>
    </tr>
    </table>
  </html:form>
</body>
register.jsp
<body>
  Welcome to register the books online. <br>
  <html:form action="/members.do?action=register" method="POST">
  <bean:message key="members.form.name.label"/>:<html:text property="name"/><br>
  <bean:message key="members.form.password.label"/>:<html:password property="password"/><br>
  <bean:message key="members.form.sex.label"/>:
  <html:select property="sex">
       <html:option key="members.form.sex.male" value="male" />
       <html:option key="members.form.sex.female" value="female" />
  </html:select><br>
  <bean:message key="members.form.mail.label"/>:<html:text property="mail"/><br>
  <html:submit><bean:message key="members.form.register.label"/></html:submit>
  </html:form>
</body>

注意：在开发过程中，本想加上输入验证的，因为前面己经有了这方面的例子，为了不重复，这里就有意去掉了这部分，但要运行这个例子，还是你自己加上validation.xml、validator-rules.xml两个文件，不然会出错。

------------显示哪些人相同，相同的数量是多少？

select convert(int,SQRT(count(*))) as countU ,a.username from Company_Info a left join Company_Info b on

a.username=b.username and a.password=b.password

group by a.username having SQRT(count(*)) >1

----------取出所有相同的记录到一个表MyRepeat

select c.* into MyRepeat from Company_Info c where c.username in(
select a.username from Company_Info a left join Company_Info b on
a.username=b.username and a.password=b.password
group by a.username having SQRT(count(*)) >1)

-----------在表MyRepeat中找出每个相同记录的除最大id之外

select a.id from MyRepeat a where id not in(select max(b.id) from MyRepeat b group by b.username)--得出所有需要删除的id

-----------
最后得出

delete Company_Info where id in (select h.id from (select c.* from Company_Info c where c.username in(select a.username from Company_Info a left join Company_Info b on a.username=b.username and a.password=b.password group by a.username having SQRT(count(*)) >1) ) h where h.id not in( select max(l.id) from (select k.id,username from (select f.* from Company_Info f where f.username in(select g.username from Company_Info g left join Company_Info o on g.username=o.username and g.password=o.password group by g.username having SQRT(count(*)) >1)) k ) l group by l.username))

[概述]

Taglib是JSP比较高级的技术。做为JSP开发人员来讲，不了解taglib是可以接受的。因为JSP的风格或者JAVA的风格就是一种简洁的美。如果技术太过复杂或者繁琐，就会在技术的汪洋中失去自我。

但是，当我们的项目变得越来越大，或者团队有了一些技术积累之后，很自然就会有将我们的开发工作提高一个层次的需要。当我们面对一些非常类似的界面或者程序单元的时候，我们会想到把这样的工作成果直接用于下一个项目。这样的问题可以由taglib来解决。

到此还没有真正说明一下taglib是什么。只要你从事过JSP的开发工作，你就已经使用过taglib了。只不过是在不知不觉中使用的。你一定不会忘记 <jsp:include />标记。实际上这就是一个taglib。Taglib直译做标记库，是JSP定义给开发人员可以使用自行定义的标记体系。也就是说，开发人员可以在JSP中使用自己定义的特殊标记。而该标记可以用作特定的用途。比如显示一个每个页都需要的公司版权信息。就可以不用复制粘贴相同的代码到每个页去了。

但是taglib可以完成的工作远远不止这些。由于每个自定义标记一定是一个完全的JAVA类，我们可以定义非常丰富的一组行为，并且可以通过自定义的attribute来控制它。

[实例]

我习惯用实例来说明问题。大家也许都对用户会话状态的检查不陌生。当用户登录到系统后，我们希望自动保持用户的登录状态。而这个过程在每个需要认证用户才能访问的程序单元都需要实现。通常我们需要访问预定义的session服务器变量，当这个变量不满足某值时即判定改用户为非法访问或者会话状态丢失。

我们来看一下使用taglib如何实现。我们需要编写一个仅处理该逻辑的标记。实现的最简单的逻辑：检查用户状态session值，不满足某值时即将用户转向一个预先设置的报错页。

以下是源码(CheckSessionTag.java)：
(省略了细节)

public class CheckSessionTag extends TagSupport
{
    public  int  doEndTag()
    {
         try
        {
            String member_id  =  (String) pageContext.getSession().getAttribute( " member_id " );
             if (member_id  ==   null   ||  member_id.equals( "" ))
            {
                pageContext.forward( " /home/check_session_fail.jsp " );
            }
        }
         catch (Exception e)
        {
             //  报告异常过程省略.
        }
         return  EVAL_PAGE;
    }
}

[分析]

在以上源码中，我们在使tag自动检查用户session变量中的"member_id"值，如果该值为空，则立即判定用户没有访问权限，则立即将流程导向一个预先设定的报错页：/home/check_session_fail.jsp.

类CheckSessionTag派生自：TagSupport(javax.servlet.jsp.tagext.TagSupport). 是一个从JAVA 1.3就开始支持的类库，位于servlet.jar包。java文档给出的描述是：

A base class for defining new tag handlers implementing Tag. The TagSupport class is a utility class intended to be used as the base class for new tag handlers. The TagSupport class implements the Tag and IterationTag interfaces and adds additional convenience methods including getter methods for the properties in Tag. TagSupport has one static method that is included to facilitate coordination among cooperating tags. Many tag handlers will extend TagSupport and only redefine a few methods.
(该类为所有taglib的基类。该类定义了实现标记的一系列接口。)

在实例CheckSessionTag类中，我们仅仅重写了doEndTag方法。没有向其容器：jsp页输出任何东西。但是该类在实际应用中是切实可行的。

以下是在一个成品项目中的某jsp中截取的片断：
<logic:checkSession />

当我们直接使用输入url的方式访问本页时，我们被立即带到了报告：用户会话状态丢失或者未经登录的页。
这就省却了我们习以为常的一项工作：以前我们必须复制相同的scriplet到每个jsp页。（实际上，也可以使用类似intercept filter的模式来处理此需求）。这使我们的开发工作变得reusable, flexiable, 和extendable。可以想象，如果我们想改变检查session的逻辑，则可以仅仅通过改变CheckSessionTag内部的逻辑就可以通盘改变。并且我们可以通过给logic:checkSession标记加上类似target=admin的attribute来限定只有管理员才可以访问的区域。这就是形成组件化开发的基本过程。

如何实施呢?


[实施过程]

我们需要做一系列工作来将taglib引入我们的工程。

web.xml
为了使jsp解析器可以识别我们的taglib必须将其配置在web.xml内。web.xml位于/WEB-INF目录内。
使用特定语法来配置我们的taglib:
web.xml(片断)

< web-app >

     < taglib >
         < taglib-uri > /WEB-INF/logic.tld </ taglib-uri >
         < taglib-location > /WEB-INF/logic.tld </ taglib-location >
     </ taglib >

< web-app >

该语法告诉容器到什么地方去寻找所有logic:开头的tag.

tld是taglib defination的缩写。即taglib定义。该文件定义了我们使用的标记，Java类如何加载，并且该标记如何工作。让我们来看一段实际的tld:
logic.tld(片断)

<? xml version="1.0" encoding="ISO-8859-1" ?>
<! DOCTYPE taglib
     PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2/EN"
     "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd" >

< taglib >
     < tlib-version > 1.0 </ tlib-version >
     < jsp-version > 1.2 </ jsp-version >
     < short-name > logic </ short-name >
     < uri > /taglibs/logic </ uri >

     < tag >
        < name > checkSession </ name >
        < tag-class > mbajob.common.tags.logic.CheckSessionTag </ tag-class >
        < body-content > empty </ body-content >
     </ tag >

我们注意到taglib标记内.
1． short-name: 标记的prefix名。
2． uri: 识别该taglib的名称。

tag标记：
1． name: 标记名（prefix:之后）
2． tag-class：类名（包含包名）
3． body-content: 标记内容模式，如果该标记没有内容则为empty.

将logic.tld放置在/WEB-INF下，此时确保编译好的CheckSessionTag类可以被容器访问到。即可完成配置。必须注意的是，不同的jsp容器的配置可能有差别。本文的配置是基于Resin 2.1.11

[应用]

建立一个jsp页。在源码的开头加入如下的预编译指令：(page)
<%@ taglib prefix="logic" uri="/WEB-INF/logic.tld" %>

此指令告诉编译器到哪里去寻找所有以logic:开头的标记的定义。

接下来在任意位置加入标记：<logic:checkSession />即可以工作了。当标记被实例化后，即自动执行doEndTag过程，检查session服务器变量值，之后将页过程跳转。


[深入一些：attribute]

有时候我们希望可以对标记进行一些定制。依旧拿checkSession做例：现在我们要限制两类用户访问系统：某
些部分仅允许具有管理员权限的用户访问。这样我们设想可以在<logic:checkSession target=admin />进行进一步定义。这需要在CheckSessionTag类中增加一些额外的逻辑。检查的过程很简单，取决于你的安全系统的分析，但是，我们写了target attribute如何是类可以得到该数据，这是一个关键的问题。

为了实现对tag增加可用的attribute, 需要做如下工作：
1． 为类增加相应的成员及相应读写器：
CheckSessionTag.java(片断): 

public class CheckSessionTag extends TagSupport
{
     private String target;

     public  void  setTarget(String t)
     {
         this .target  =  t;
     }

     public String getTarget()
     {
         return   this .target;
     }

    public  int  doEndTag()
    {
        
    }

2． 更改logic.tld:

.

     < tag >
        < name > checkSession </ name >
        < tag-class > mbajob.common.tags.logic.CheckSessionTag </ tag-class >
        < body-content > empty </ body-content >
        < attribute >
           < name > title </ name >
           < required > true </ required >
        </ attribute >
     </ tag >

为tag标记增加arrtibute节点，语法如下：

name: attribute名
required: 是否为必须的attribute

幸运的是，jsp内置地将attribute解释为java类的成员，我们无需显式地获取该值，即可直接使用。也就是说，我们只要在tag内指定了target=admin, 那么，CheckSessionTag在活着的时候就自动获取该值，可以在逻辑中直接使用。

这样，我们就可以给tag增加任意的attribute.


[入门以后]

到此为止，我么就可以写一些类似的简单的tag了。根据不同的需求，完成不同的逻辑。当我们开发一个新的tag的时候，我们在logic.tld里增加一个tag子标记。设置好相应的类型。如果需要，我们可以把我们已经写好的tag们完全的移植到第二个项目中使用，仅仅做很少的更改。而更改也仅仅限于对java源代码。

在我和我的团队的实际经验中，taglib最多的应用还是在设计一系列特殊的UI. 例如类似于选择省市多级行政区域的选择器。为了放置在HTML中嵌入过多scriplet和脚本，我们的做法通常是将其写在组装好的tag里；为了形成整个应用一致的外观，我们设计了一套用于组装页构图的框架；为了向jsp输出集合数据，我们设计了可以绑定数据的呈现器。经过很长一个时期的工作，我们发现我们的项目中jsp页内仅有很少的html, 而完全是有taglib组成的。最终，我们的taglib按照layout, logic, element, form分类，已经形成了比较大的规模。我们甚至完成了apache的struts框架完成的一部分工作。甚至做得更灵活。所有这些工作中积累的思想甚至影响到我在.NET平台下的技术思路。

为了不使篇幅太长，我不准备在本文再做深入的探索。仅仅介绍taglib入门级的一些东西。有时间的话，可能会再次写一些高级一些的taglib的设计方法。


[与ASP.NET Web Custom Control]

不能说taglib与ASP.NET Web Custom Control有什么可比性。但是我习惯将二者放到一起看。因为因为在某些实际项目中，我确实从二者之间找到一些共性。甚至有时候创作一些组件的时候实现是完全相同的。
1． 二者都定义了当标记输出开始标记和结束标记时的过程。
2． 二者都可以跨应用使用。
3． 可以使用相同的HTML和脚本。

但比较起来，ASP.NET Web Custom Control更高级一些。可以在容器中直接以对象的形式访问。并且可以定义方法，事件。意即可以完全控制一个控件。

而taglib同样有优点，例如可以嵌套使用，开发成本低等。最关键的是，taglib具有做为java产品的精细，小巧和活泼。他们分别是有着不同风格的优秀技术。

参考文档
taglib最佳实践(IBM developerWorks中文站)
http://www-900.ibm.com/developerWorks/cn/java/j-jsp07233/

肖菁，软件工程师，IBM developerWorks/Bea dev2dev/sun 技术开发者撰稿人，主要研究J2EE、web services以及他们在websphere、weblogic平台上的实现，拥有IBM的 Developing With Websphere Studio证书。您可以通过guilaida@163.com和作者取得联系，或者查看作者的主页获取更多信息。

文章摘要

Cache是一种用于提高系统响应速度、改善系统运行性能的技术。尤其是在Web应用中，通过缓存页面的输出结果，可以很显著的改善系统运行性能。本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。通过应用OSCache，我们不但可以实现通常的Cache功能，还能够改善系统的稳定性。

1 面临的问题

1.1 需要处理的特殊动态内容

在信息系统建设过程中我们通常会遇到这样的问题：

1. 基础数据的变更问题

信息系统中需要处理的基础数据的内容短时间内是不会发生变化的，但是在一个相对长一些的时间里，它却可能是动态增加或者减少的。

举个例子：电子商务中关于送货区域的定义，可能短时间内不会发生变化，但是随着电子商务企业业务的扩大，系统中需要处理的送货区域就可能增加。所以我们的系统中不得不在每次向客户展示送货区域信息的时候都和数据库（假设送货区域信息保存在数据库中，这也是通常采用的处理方法）进行交互。

2. 统计报表（不仅限于统计报表）的问题

一般来说，统计报表是一个周期性的工作，可能是半个月、一个月或者更长的时间才会需要更新一次，然而统计报表通常是图形显示或者是生成pdf、word、excel等格式的文件，这些图形内容、文件的生成通常需要消耗很多的系统资源，给系统运行造成很大的负担。

1.2 问题的共同点

通过比较分析，不难发现这两类问题有一些共同点：

1、被处理的内容短时间不变，所以短时间内可以作为静态内容进行处理

2、在一个不太长的时间内，被处理的内容可能或者必定产生变化，所以必须将他们作为动态内容进行处理

3、在合理的时间区段内可以忽略被处理内容变化后带来的影响

4、对这些内容的处理动作比较消耗系统性能，影响系统响应时间

1.3 解决方法

缓存技术可以帮助我们很好的解决这个问题：

1、缓存信息

当上述的基础数据或者统计报表第一次被访问时，被处理的内容被当作动态信息，基础数库从数据库中获得，统计报表也会被生成符合要求的图形、文件，然后这些信息都会被放入缓存信息中。

2、响应信息由缓存提供

当上述的基础数据或者统计报表继续被访问时，系统将会首先检查缓存信息中是否有对应的内容和我们设定的缓存规则，如果符合缓存信息存在而且符合缓存规则，给出的响应将来自于缓存信息，如果没有或者缓存信息已经不符合设定的要求，系统将重复上一步的动作。

很显然，上面的步骤2中，多数情况下，当用户请求到达时，被处理的内容将来自于缓存，所以大大的减少了与数据库的交互，或者不再需要为每个请求都生成一次报表图形或者文件，这部分工作的减少对于降低系统性能消耗、提高系统稳定性和并发处理能力是非常有益的。

2 OSCache简介

OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件，它的出现解决了我们面临的问题。 OSCache目前最新的稳定版本是2.0，本文中的例子都是基于这个版本的，如果大家运行例子的过程中发生问题，请首先确认是否采用了正确的软件版本。

2.1 主要特征

1. 兼容多种支持JSP的web服务器

已经通过兼容测试的web服务器包括OrionServer (1.4.0或者以上版本) 、Macromedia JRun (3.0或者以上版本) 、BEA Weblogic (7.x或者以上版本) 、IBM Websphere (5.0版本)、Silverstream (3.7.4版本)、Caucho Resin (1.2.3或者以上版本)、Tomcat (4.0或者以上版本) ，其他支持servlet2.3、jsp1.2的web服务器应该都是完全兼容OSCache的。

2. 可选的缓存区

你可以使用内存、硬盘空间、同时使用内存和硬盘或者提供自己的其他资源（需要自己提供适配器）作为缓存区。

• 使用内存作为缓存区将可以提供更好的性能
• 使用硬盘作为缓存区可以在服务器重起后迅速恢复缓存内容
• 同时使用内存和硬盘作为缓存区则可以减少对内存的占用

3. 灵活的缓存系统

OSCache支持对部分页面内容或者对页面级的响应内容进行缓存，编程者可以根据不同的需求、不同的环境选择不同的缓存级别。

4. 容错

在一般的web应用中，如果某个页面需要和数据库打交道，而当客户请求到达时，web应用和数据库之间无法进行交互，那么将返回给用户"系统出错"或者类似的提示信息，如果使用了OSCache的话，你可以使用缓存提供给用户，给自己赢得维护系统或者采取其他补救的时间。

其它特性还包括对集群的支持、缓存主动刷新等特性，大家可以参考OpenSymphony网站上的其他资源获取更多的信息。

3 OSCache组件的安装

OSCache是一个基于web应用的组件，他的安装工作主要是对web应用进行配置，大概的步骤如下：

1. 下载、解压缩OSCache

请到OSCache的主页http://www.opensymphony.com/oscache/download.html下载Oscache的最新版本，作者下载的是OSCache的最新稳定版本2.0。

将下载后的。Zip文件解压缩到c:\oscache（后面的章节中将使用%OSCache_Home%来表示这个目录）目录下

2. 新建立一个web应用

3. 将主要组件%OSCache_Home%\oscache.jar放入WEB-INF\lib目录

4. commons-logging.jar、commons-collections.jar的处理

• OSCache组件用Jakarta Commons Logging来处理日志信息，所以需要commons-logging.jar的支持，请将%OSCache_Home%\lib\core\commons-logging.jar放入classpath（通常意味着将这个文件放入WEB-INF\lib目录）
• 如果使用JDK1.3,请将%OSCache_Home%\lib\core\commons-collections.jar放入classpath，如果使用JDK1.4或者以上版本，则不需要了

5. 将oscache.properties、oscache.tld放入WEB-INF\class目录

• %OSCache_Home%\oscache.properties包含了对OSCache运行特征值的设置信息
• %OSCache_Home%\oscache.tld包含了OSCache提供的标签库的定义内容

6. 修改web.xml文件

在web.xml文件中增加下面的内容，增加对OSCache提供的taglib的支持：

<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/ oscache.tld</taglib-location>
</taglib> 

4 开始使用OSCache中的缓存组件

OSCache中按照缓存范围的不同分为两种不同的方式：一种是缓存JSP页面中部分或者全部内容，一种是基于整个页面文件的缓存。

4.1 JSP部分内容缓存

4.1.1 Cache-OSCache提供的缓存标签

这是OSCache提供的标签库中最重要的一个标签，包括在标签中的内容将应用缓存机制进行处理，处理的方式将取决于编程者对cache标签属性的设置。

第一次请求到达时，标签中的内容被处理并且缓存起来，当下一个请求到达时，缓存系统会检查这部分内容的缓存是否已经失效，主要是以下几项：

• 1. 缓存时间超过了cache标签设置的time或者duration属性规定的超时时间
• 2. cron属性规定的时间比缓存信息的开始时间更晚
• 3. 标签中缓存的内容在缓存后又被重新刷新过
• 4. 其他缓存超期设定

如果符合上面四项中的任何一项，被缓存的内容视为已经失效，这时被缓存的内容将被重新处理并且返回处理过后的信息，如果被缓存的内容没有失效，那么返回给用户的将是缓存中的信息。

cache标签的属性说明:

key - 标识缓存内容的关键词。在指定的作用范围内必须是唯一的。默认的key是被访问页面的URI和后面的请求字符串。

你可以在同一个页面中使用很多cache标签而不指定他的key属性，这种情况下系统使用该页面的URI和后面的请求字符串，另外再自动给这些key增加一个索引值来区分这些缓存内容。但是不推荐采用这样的方式。

scope - 缓存发生作用的范围，可以是application或者session

time - 缓存内容的时间段，单位是秒，默认是3600秒，也就是一个小时，如果设定一个负值，那么这部分被缓存的内容将永远不过期。

duration - 指定缓存内容失效的时间，是相对time的另一个选择，可以使用简单日期格式或者符合USO-8601的日期格式。如：duration='PT5M' duration='5s'等

refresh - false 或者true。

如果refresh属性设置为true，不管其他的属性是否符合条件，这部分被缓存的内容都将被更新，这给编程者一种选择，决定什么时候必须刷新。

mode - 如果编程者不希望被缓存的内容增加到给用户的响应中，可以设置mode属性为"silent"

其它可用的属性还包括：cron 、groups、language、refreshpolicyclass、refreshpolicyparam。

上面的这些属性可以单独使用，也可以根据需要组合使用，下面的例子将讲解这些常用属性的使用方式。

4.1.2 Cache标签实例分析:

1. 最简单的cache标签用法

使用默认的关键字来标识cache内容，超时时间是默认的3600秒

<cache:cache>
<%
//自己的JSP代码内容
%>
</cache:cache> 

2. 用自己指定的字符串标识缓存内容，并且设定作用范围为session。

<cache:cache key="foobar" scope="session">
<%
//自己的JSP代码内容
%>
</cache:cache> 

3.动态设定key值，使用自己指定的time属性设定缓存内容的超时时间，使用动态refresh值决定是否强制内容刷新。

因为OSCache使用key值来标识缓存内容，使用相同的key值将会被认为使用相同的的缓存内容，所以使用动态的key值可以自由的根据不同的角色、不同的要求决定使用不同的缓存内容。

<cache:cache key="<%= product.getId() %>" time="1800" refresh="<%= needRefresh %>">
<%
//自己的JSP代码内容
%>
</cache:cache> 

4. 设置time属性为负数使缓存内容永不过期

<cache:cache time="-1">
<%
//自己的JSP代码内容
%>

5. 使用duration属性设置超期时间

<cache:cache  duration='PT5M'>
<%
//自己的JSP代码内容
%>

6. 使用mode属性使被缓存的内容不加入给客户的响应中

<cache:cache  mode='silent'>
<%
//自己的JSP代码内容
%>

4.2 用CashFilter实现页面级缓存

在OSCache组件中提供了一个CacheFilter用于实现页面级的缓存，主要用于对web应用中的某些动态页面进行缓存，尤其是那些需要生成pdf格式文件/报表、图片文件等的页面，不仅减少了数据库的交互、减少数据库服务器的压力，而且对于减少web服务器的性能消耗有很显著的效果。

这种功能的实现是通过在web.xml中进行配置来决定缓存哪一个或者一组页面，而且还可以设置缓存的相关属性，这种基于配置文件的实现方式对于J2EE来说应该是一种标准的实现方式了。

[注] 只有客户访问时返回http头信息中代码为200（也就是访问已经成功）的页面信息才能够被缓存

1. 缓存单个文件

修改web.xml，增加如下内容，确定对/testContent.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对/testContent.jsp页面内容进行缓存-->
      <url-pattern>/testContent.jsp</url-pattern>
</filter-mapping>

2. 缓存URL pattern

修改web.xml，增加如下内容，确定对*.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
      <url-pattern>*.jsp</url-pattern>
</filter-mapping>

3. 自己设定缓存属性

在页面级缓存的情况下，可以通过设置CacheFilter的初始属性来决定缓存的一些特性：time属性设置缓存的时间段，默认为3600秒，可以根据自己的需要只有的设置，而scope属性设置，默认为application，可选项包括application、session

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
	<init-param>
         <param-name>time</param-name>
         <param-value>600</param-value>
      </init-param>
      <init-param>
         <param-name>scope</param-name>
         <param-value>session</param-value>
      </init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
<url-pattern>*.jsp</url-pattern>
</filter-mapping>

5 性能测试结果

5.1 测试环境

系统平台：windows 2000 高级服务器/ P3 800 /512M内存

web服务器：websphere 5.0

数据库服务器：mysql 4.0.18-nt

性能测试用工具：apache Jmeter

5.2 测试计划

这次性能测试对比方为使用缓存和不使用缓存两种，他们的访问代码都是一样的：通过数据源从本地mysql数据库中获取person表的所有记录，然后显示在页面上。

测试中将模仿10个用户，每个用户发起5次请求，然后统计所有访问花费的时间。

5.3 测试结果

使用缓存后的测试结果 不使用缓存时的测试结果

所有请求花费的总时间(毫秒) 20569 22870

性能测试的详细结果请大家查看下载内容中的《不使用cache时的系统性能测试结果.txt》和《使用cache后系统性能测试结果.txt》

6 总结

在J2EE系统中，我们经常需要处理一些特殊的动态内容，这些内容在一个时间段内的变更非常有限，但是又不得不将他们确定为动态内容进行输出，而且非常消耗数据库系统资源或者web服务器的资源，这时我们就可以采用Cache----一种用于提高系统响应速度、改善系统运行性能的技术----来优化我们的系统。尤其是在Web应用中，这种处理可以很显著的改善系统运行性能。

本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。它提供了在J2EE系统中实现缓存需要的丰富的功能。通过应用OSCache，我们不但可以实现通常的Cache功能、自由的设定cache的相关特性比如缓存时间段/缓存内容等，提升系统性能，而且还能有效的改善系统的稳定性。除此之外，OSCache组件还提供了更多的特性比如集群、容错、灵活的缓存区选择等。

作者根据自己的使用经验给大家提供了一些简单的例子，他们部分演示了如何使用OSCache组件提供的丰富特性，OSCache提供的特性远不止这些，需要大家在今后的时间里深入的研究，同时也希望大家通过E-mail和作者贡献研究成果。

1、POJO 缓存
这种方式的缓存直接调用OSCache的API进行，主要用于处理页面内容会根据参数动态改变，可以将参数设置为key值来保存数据：
首先，声明成员变量：
 // OSCache Adminitrator instance
 private static GeneralCacheAdministrator cacheAdmin = null;
其次，进行初始化：
 public RingArtistAction() {
  cacheAdmin = new GeneralCacheAdministrator();
 }
将POJO进行缓存：
  // Cache data key and refresh period
  String key = sex + ":" + place;
  int refreshPeriod = Constants.getIntegerValue(Constants.OSCACHE_REFRESH_PERIOD).intValue();
  try {
      // Get from the cache
   artists = (Map) cacheAdmin.getFromCache(key, refreshPeriod);
  } catch (NeedsRefreshException nre) {
      try {
          // Get the value (probably from the database)
    int count = getArtistCount(sex, place, errors);
    artists = getArtistData(sex, place, count, errors);
          // Store in the cache
    cacheAdmin.putInCache(key, artists);
      } catch (Exception ex) {
          // We have the current content if we want fail-over.
    artists = (Map) nre.getCacheContent();
          // It is essential that cancelUpdate is called if the
          // cached content is not rebuilt
    cacheAdmin.cancelUpdate(key);
    ex.printStackTrace();
      }
  }
 
2、HTTP Response 缓存
这种方式的缓存用来处理整个页面的内容固定，不会根据参数动态改变：
首先在web.xml中配置CacheFilter：
 <filter>
  <filter-name>CacheFilter</filter-name>
  <filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
  <init-param>
   <param-name>time</param-name>
   <param-value>86400</param-value>
  </init-param>
  <init-param>
   <param-name>scope</param-name>
   <param-value>application</param-value>
  </init-param>
 </filter>
将所有需要缓存的页面加入filter-mapping：
 <filter-mapping>
  <filter-name>Set Character Encoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
注意，只有返回状态为200（HttpServletResponse.SC_OK）的内容才会被缓存

3、JSP Tag 缓存
JSP Tag缓存主要用于缓存JSP页面的局部内容：
  <cache:cache key="especialcategory" cron="* 5 * * *">
  <jsp:include page="/ringcategory.do" flush="true" >
    <jsp:param name="ringType" value="1"/>
  </jsp:include>
  </cache:cache>

4、O/R Data Access 缓存
请阅读参考资料的内容获取详情。

参考资料：
Taking the load off: OSCache helps databases cope：http://www.theserverside.com/articles/article.tss?l=OSCacheHelpsDatabases

○用二分钟配置：

将下载的oscache-2.1.1-full.zip解压，你会看到oscache-2.1.1.jar 及一些目录 docs、etc、lib、src。
现在将 etc目录下oscache.properties 、oscache.tld 及 oscache-2.1.1.jar 文件复制到你的应用服务器目录下

使用tomcat，jdk1.4 配置例：
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\lib\oscache-2.1.1.jar
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\classes\oscache.properties
         D:\Tomcat 5.0\webapps\ROOT\WEB-INF\classes\oscache.tld

oscache.properties 文件配置参数说明：
cache.memory
值为true 或 false ，默认为在内存中作缓存，
如设置为false，那cache只能缓存到数据库或硬盘中，那cache还有什么意义：）
cache.capacity
缓存元素个数
cache.persistence.class
持久化缓存类，如此类打开，则必须设置cache.path信息
cache.cluster 相关
为集群设置信息。如
cache.cluster.multicast.ip为广播IP地址
cache.cluster.properties为集群属性

再将 D:\Tomcat 5.0\webapps\ROOT\WEB-INF\web.xml 文件中添加如下代码
<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/oscache.tld</taglib-location>
</taglib>

就是这么简单，OSCache就配置好了。

○再用二分钟测试一下：

编写jsp文件
======================cache1.jsp 内容如下=================
<%@ page contentType="text/html;charset=GBK"%>
<%@ page import="java.util.*" %>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
没有缓存的日期: <%= new Date() %><p>
<!--自动刷新-->
<cache:cache time="30">
每30秒刷新缓存一次的日期: <%= new Date() %> <p>
</cache:cache>

<!--手动刷新-->
<cache:cache key="testcache">
手动刷新缓存的日期: <%= new Date() %> <p>
</cache:cache>
<a href="http://dev.csdn.net/article/"cache2.jsp">手动刷新</a></body>
</html>
=========================================================

====================cache2.jsp 执行手动刷新页面如下===========
<%@ page contentType="text/html;charset=GBK"%>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>缓存已刷新...<p>

<cache:flush key="testcache" scope="application"/>

<a href="http://dev.csdn.net/article/"cache1.jsp">返回</a></body>
</html>
==========================================================       

其他： 缓存过滤器 CacheFilter
可以让你所有.jsp页面自动缓存。

你可以在web.xml中定义缓存过滤器，定义特定资源的缓存。
<filter>
<filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
<init-param>
<param-name>time</param-name>
<param-value>60</param-value>
</init-param>
<init-param>
<param-name>scope</param-name>
<param-value>session</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
上面定义将缓存所有.jsp页面，缓存刷新时间为60秒，缓存作用域为Session

注意，CacheFilter只捕获Http头为200的页面请求，即只对无错误请求作缓存，
而不对其他请求（如500,404,400）作缓存处理

此文完。。谢谢观看。

在smarty的模板设计部分我简单的把smarty在模板中的一些常用设置做了简单的介绍，这一节主要来介绍一下如何在smarty中开始我们程

序设计。

    新闻编号：1<br>
    新闻内容：第1条新闻<br><hr>

    新闻编号：2<br>
    新闻内容：第2条新闻<br><hr>

    新闻编号：3<br>
    新闻内容：第3条新闻<br><hr>

    新闻编号：4<br>
    新闻内容：第4条新闻<br><hr>

    新闻编号：5<br>
    新闻内容：第5条新闻<br><hr>

    新闻编号：6<br>
    新闻内容：第6条新闻<br><hr>
     </body>
   </html>

   foreach还可以用foreachelse来匹配，用foreachelse来表示当传递给foreach的数组为空值时程序要执行的操作，具体的使用方法，请参考

手册的说明。

   2. section:
     section的产生是为解决foreach的不足的，与foreach一样，它用于设计模板内的循环块，它较为复杂，可极大程序上满足程序需要，所

以在程序中我习惯使用它而不使用foreach,基本原形为：

     {section name = name loop = $varName[, start = $start, step = $step, max = $max, show = true]}

     name: section的名称，不用加$
     $loop: 要循环的变量，在程序中要使用assign对这个变量进行操作。
     $start: 开始循环的下标，循环下标默认由0开始
     $step:  每次循环时下标的增数
     $max:   最大循环下标
     $show:  boolean类型，决定是否对这个块进行显示，默认为true

     这里有个名词需要说明：
         循环下标：实际它的英文名称为index，是索引的意思，这里我将它译成"下标"，主要是为了好理解。它表示在显示这个循环块时当

前的循环索引，默认从0开始，受$start的影响，如果将$start设为5，它也将从5开始计数，在模板设计部分我们使用过它，这是当前

{section}的一个属性，调用方式为Smarty.section.sectionName.index,这里的sectionName指的是函数原型中的name属性。
    {section}块具有的属性值，分别为：
      1. index:      上边我们介绍的"循环下标"，默认为0
      2. index_prev: 当前下标的前一个值，默认为-1
      3. index_next: 当前下标的下一个值，默认为1
      4. first:      是否为第一下循环
      5. last:       是否为最后一个循环
      6. iteration:  循环次数
      7. rownum:     当前的行号，iteration的另一个别名
      8. loop:       最后一个循环号，可用在section块后统计section的循环次数
      9. total: 循环次数，可用在section块后统计循环次数
      10. show: 在函数的声明中有它，用于判断section是否显示

      它们的具体属性大家可以参考手册，在程序中可灵活使用它的这些属性，模板部分我就使用过index属性，大家可以回过头去看看。

      同样，{section}也可以配合使用{sectionelse}，用来表示传入的数组变量为空时对模板进行的处理。

      我们把上边的那个例子使用{section}来替代{foreach}来实现现样的功能，注意，在这个例子中我只将tpl模板中的{foreach}用

{section}来实现，php程序文件中没有任何改动，同时加了{sectionelse}处理块：

  ===========================================
    example7.tpl
  ===========================================
  <html>
    <head><title>这是一个foreach使用的例子</title></head>
    <body>
       这里将输出一个数组：<br>
       {section name=loop, loop=$News}
         新闻编号：{$News[loop].newsID}<br>
         新闻标题：{$News[loop].newsTitle}<br><hr>
       {sectionelse}
         对不起，没有任何新闻输入！
       {/section}
    </body>
  </html>
  
  ==========================================
  example6.php
  ==========================================
  <?php
     /*********************************************
      *
      * 文件名： example7.php
      * 作  用： 显示实例程序2
      *
      * 作  者： 大师兄
      * Email：  teacherli@163.com
      *
      *********************************************/
      include_once("./comm/Smarty.class.php");

      $smarty = new Smarty();  
      $smarty->templates("./templates");
      $smarty->templates_c("./templates_c");
      $smarty->cache("./cache");
      $smarty->cache_lifetime  = 0;
      $smarty->caching         = true;
      $smarty->left_delimiter  = "{";
      $smarty->right_delimiter = "}";
      
      $array[] = array("newsID"=>1, "newsTitle"=>"第1条新闻");
      $array[] = array("newsID"=>2, "newsTitle"=>"第2条新闻");
      $array[] = array("newsID"=>3, "newsTitle"=>"第3条新闻");
      $array[] = array("newsID"=>4, "newsTitle"=>"第4条新闻");
      $array[] = array("newsID"=>5, "newsTitle"=>"第5条新闻");
      $array[] = array("newsID"=>6, "newsTitle"=>"第6条新闻");

      $smarty->assign("newsArray", $array);

      //编译并显示位于./templates下的index.tpl模板
      $smarty->display("example6.tpl");
   ?>

   =================================================
   example7.php 输出文件
   =================================================
   <html>
     <head><title>foreach使用的例子</title></head>
     <body>
        这里将输出一个数组：<br>

    新闻编号：1<br>
    新闻内容：第1条新闻<br><hr>

    新闻编号：2<br>
    新闻内容：第2条新闻<br><hr>

    新闻编号：3<br>
    新闻内容：第3条新闻<br><hr>

    新闻编号：4<br>
    新闻内容：第4条新闻<br><hr>

    新闻编号：5<br>
    新闻内容：第5条新闻<br><hr>

    新闻编号：6<br>
    新闻内容：第6条新闻<br><hr>
     </body>
   </html>

   这里的{section}块的对于变量的命名方式感觉有些别扭，不过没关系，你只要记住模板变量使用：
   $loopName[name].var这种模式就行了，loopName为loop处赋予的变量名，[name]为name处赋予的字符串，.后为为你要在程序数组中设定要

与值相对应的下标名称就行了。

  
   好了，smarty学习指南---程序设计篇就写到这里，对于一般的应用，这些知识已经够用了，其它的一些高级技巧大家请参看手册中的例子

，下一节将讲讲Smarty在实际应用中的例子，将分别以php内置的mysql语句，phplib中的DB类，ADODB，Pear中DB类来分别讲一下各个类库在同一个例子中的实现。

正则表达式语法

一个正则表达式就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

这里有一些可能会遇到的正则表达式示例：

下表是元字符及其在正则表达式上下文中的行为的一个完整列表：

　　我在一网页向另一网页POST数据name，为什么输出$name时却得不到任何值?

在PHP4.2以后的版本中register_global默认为off
　　若想取得从另一页面提交的变量:

　　方法一:在PHP.ini中找到register_global，并把它设置为on.
　　方法二:在接收网页最前面放上这个extract($_POST);extract($_GET);(注意extract($_SESSION)前必须要有Session_Start()).
　　方法三:一个一个读取变量$a=$_GET["a"];$b=$_POST["b"]等，这种方法虽然麻烦，但比较安全.

　　2：调试你的程序

　　在运行时必须知道某个变量为何值。我是这样做的，建立一文件debug.php,其内容如下:

　　PHP代码:

　　<?PHP
　　Ob_Start();
　　Session_Start();
　　Echo "<pre>";

　　Echo "本页得到的_GET变量有:";
　　Print_R($_GET);

　　Echo "本页得到的_POST变量有:";
　　Print_R($_POST);

　　Echo "本页得到的_COOKIE变量有:";
　　Print_R($_COOKIE);

　　Echo "本页得到的_SESSION变量有:";
　　Print_R($_SESSION);

　　Echo "</pre>";
　　?>

　　然后在php.ini中设置：include_path = "c:/php"，并将debug.php放在此文件夹,以后就可以在每个网页里包含此文件，查看得到的变量名和值.

　　3：如何使用session

　　凡是与session有关的,之前必须调用函数session_start();

　　为session付值很简单,如:

　　PHP代码:

　　<?php
　　Session_start();
　　$Name = "这是一个Session例子";
　　Session_Register("Name");//注意,不要写成：Session_Register("$Name");
　　Echo $_SESSION["Name"];
　　//之后$_SESSION["Name"]为"这是一个Session例子"
　　?>

　　在php4.2之后,可以为session直接付值:

　　PHP代码:

　　<?PHP
　　Session_Start();
　　$_SESSION["name"]="value";
　　?>

　　取消session可以这样:

PHP代码:

　　<?php
　　session_start();
　　session_unset();
　　session_destroy();
　　?>

　　取消某个session变量在php4.2以上还有BUG.

　　注意:

　　1:在调用Session_Start()之前不能有任何输出.例如下面是错误的.
　　==========================================
　　1行
　　2行 3行 Session_Start();//之前在第一行已经有输出
　　4行 .....
　　5行 ?>
　　==========================================

　　提示1:

　　凡是出现" ........headers already sent.......... ",就是Session_Start()之前向浏览器输出信息.去掉输出就正常,（COOKIE也会出现这种错误,错误原因一样）

　　提示2:

　　如果你的Session_Start()放在循环语句里,并且很难确定之前哪里向浏览器输出信息,可以用下面这种方法:
　　1行 <?PHP Ob_Start(); ?>
　　........这里是你的程序......

　　2:这是什么错误

　　Warning: session_start(): open(/tmp\sess_7d190aa36b4c5ec13a5c1649cc2da23f, O_RDWR) failed:....
因为你没有指定session文件的存放路径.

　　解决方法:
　　(1)在c盘建立文件夹tmp
　　(2)打开php.ini,找到session.save_path,修改为session.save_path= "c:/tmp"

4:为什么我向另一网页传送变量时,只得到前半部分,以空格开头的则全部丢失

　　PHP代码:

　　<?php
　　$Var="hello php";//修改为$Var="     hello php";试试得到什么结果
　　$post= "receive.php?Name=".$Var;
　　header("location:$post");
　　?>

　　receive.php的内容:

　　PHP代码:

　　<?PHP
　　Echo "<pre>";
　　Echo   $_GET["Name"];
　　Echo "</pre>";
　　?>

　　正确的方法是:

　　PHP代码:

　　<?php
　　$Var="hello php";
　　$post= "receive.php?Name=".urlencode($Var);
　　header("location:$post");
　　?>

　　在接收页面你不需要使用Urldecode(),变量会自动编码.
5:如何截取指定长度汉字而不会出现以"?>"结尾,超出部分以"..."代替

　　一般来说,要截取的变量来自Mysql,首先要保证那个字段长度要足够长,一般为char(200),可以保持100个汉字，包括标点.

　　PHP代码:

　　<?PHP
　　$str="这个字符好长呀,^_^";
　　$Short_Str=showShort($str,4);//截取前面4个汉字,结果为:这个字符...
　　Echo   "$Short_Str";
　　Function csubstr($str,$start,$len)
　　{
　　$strlen=strlen($str);
　　$clen=0;
　　for($i=0;$i<$strlen;$i++,$clen++)
　　{
　　if ($clen>=$start+$len)
　　break;
　　if(ord(substr($str,$i,1))>0xa0)
　　{
　　if ($clen>=$start)
　　$tmpstr.=substr($str,$i,2);
　　$i++;
　　}
　　else
　　{
　　if ($clen>=$start)
　　$tmpstr.=substr($str,$i,1);
　　}
　　}

　　return $tmpstr;
　　}
　　Function showShort($str,$len)
　　{
　　$tempstr = csubstr($str,0,$len);
　　if ($str<>$tempstr)
　　$tempstr .= "..."; //要以什么结尾,修改这里就可以.

　　return $tempstr;
　　}

　　6:规范你的SQL语句

　　在表格，字段前面加上"`",这样就不会因为误用关键字而出现错误，当然我并不推荐你使用关键字.

　　例如
　　$Sql="INSERT INTO `xltxlm` (`author`, `title`, `id`, `content`, `date`) VALUES ('xltxlm', 'use`', 1, 'criterion your sql string ', '2003-07-11 00:00:00')"

　　"`"怎么输入? 在TAB键上面.

　　7:如何使Html/PHP格式的字符串不被解释,而是照原样显示

　　PHP代码:

　　<?PHP
　　$str="<h1>PHP</h1>";
　　Echo "被解释过的: ".$str."<br>经过处理的:";
　　Echo   htmlentities(nl2br($str));
　　?>

　　8:怎么在函数里取得函数外的变量值

　　PHP代码:

　　<?PHP
　　$a="PHP";
　　foo();
　　Function foo()
　　{
　　 global $a;//删除这里看看是什么结果
　　 Echo "$a";
　　}
　　?>

9:我怎么知道系统默认支持什么函数

　　PHP代码:

　　<?php
　　$arr = get_defined_functions();
　　Function php() {
　　}
　　echo   "<pre>";
　　Echo   "这里显示系统所支持的所有函数,和自定以函数php\n";
　　print_r($arr);
　　echo   "</pre>";
　　?> 

　　10:如何比较两个日期相差几天

　　PHP代码:

　　<?PHP
　　$Date_1="2003-7-15";//也可以是:$Date_1="2003-7-15 23:29:14";
　　$Date_2="1982-10-1";
　　$d1=strtotime($Date_1);
　　$d2=strtotime($Date_2);
　　$Days=round(($d1-$d2)/3600/24);
　　Echo   "偶已经奋斗了 $Days 天^_^";
　　?>

　　11:为什么我升级PHP后,原来的程序出现满屏的 Notice: Undefined variable:

　　这是警告的意思,由于变量未定义引起的.
　　打开php.ini,找到最下面的error_reporting,修改为error_reporting = E_ALL & ~E_NOTICE

　　对于Parse error错误
　　error_reporting(0)无法关闭.
　　如果你想关闭任何错误提示,打开php.ini,找到display_errors,设置为display_errors = Off.以后任何错误都不会提示.

　　那什么是error_reporting?

　　12:我想在每个文件最前，最后面都加上一文件.但一个一个添加很麻烦

　　1:打开php.ini文件
　　设置 include_path= "c:"

　　2:写两个文件
　　auto_prepend_file.php 和 auto_append_file.php 保存在c盘,他们将自动依附在每个php文件的头部和尾部.

　　3:在php.ini中找到:
　　Automatically add files before or after any PHP document.
　　auto_prepend_file = auto_prepend_file.php;依附在头部
　　auto_append_file = auto_append_file.php;依附在尾部

　　以后你每个php文件就相当于

　　PHP代码:

　　<?php
　　Include "auto_prepend_file.php" ;

　　.......//这里是你的程序

　　Include "auto_append_file.php";
　　?>

　　13:如何利用PHP上传文件

　　PHP代码:

　　<html><head>
　　<title>上载文件表单</title></head>
　　<body>
　　<form enctype="multipart/form-data" action="" method="post">
　　请选择文件： <br>
　　<input name="upload_file" type="file"><br>
　　<input type="submit" value="上传文件">
　　</form>
　　</body>
　　</html>

<?
　　$upload_file=$_FILES['upload_file']['tmp_name'];
　　$upload_file_name=$_FILES['upload_file']['name'];

　　if($upload_file){
　　$file_size_max = 1000*1000;// 1M限制文件上传最大容量(bytes)
　　$store_dir = "d:/";// 上传文件的储存位置
　　$accept_overwrite = 1;//是否允许覆盖相同文件
　　// 检查文件大小
　　if ($upload_file_size > $file_size_max) {
　　echo "对不起，你的文件容量大于规定";
　　exit;
　　}

　　// 检查读写文件
　　if (file_exists($store_dir . $upload_file_name) && !$accept_overwrite) {
　　Echo   "存在相同文件名的文件";
　　exit;
　　}

　　//复制文件到指定目录
　　if (!move_uploaded_file($upload_file,$store_dir.$upload_file_name)) {
　　echo "复制文件失败";
　　exit;
　　}

　　}

　　Echo   "<p>你上传了文件:";
　　echo  $_FILES['upload_file']['name'];
　　echo "<br>";
　　//客户端机器文件的原名称。

　　Echo   "文件的 MIME 类型为:";
　　echo $_FILES['upload_file']['type'];
　　//文件的 MIME 类型，需要浏览器提供该信息的支持，例如“image/gif”。
　　echo "<br>";

　　Echo   "上传文件大小:";
　　echo $_FILES['upload_file']['size'];
　　//已上传文件的大小，单位为字节。
　　echo "<br>";

　　Echo   "文件上传后被临时储存为:";
　　echo $_FILES['upload_file']['tmp_name'];
　　//文件被上传后在服务端储存的临时文件名。
　　echo "<br>";

　　$Erroe=$_FILES['upload_file']['error'];
　　switch($Erroe){
        　　case 0:
            　Echo   "上传成功"; break;
        　　case 1:
            　Echo   "上传的文件超过了 php.ini 中 upload_max_filesize 选项限制的值."; break;
        　　case 2:
            　Echo   "上传文件的大小超过了 HTML 表单中 MAX_FILE_SIZE 选项指定的值。";    break;
        　　case 3:
            　Echo   "文件只有部分被上传";break;
        　　case 4:
            　Echo   "没有文件被上传";break;
　　}
　　?>

　　14:如何配置GD库

　　下面是我的配置过程
　　1:用dos命令(也可以手动操作,拷贝dlls文件夹里所有dll文件到system32目录下) copy c:\php\dlls\*.dll c:\windows\system32\
　　2:打开php.ini
　　设置extension_dir = "c:/php/extensions/";
　　3:
　　extension=php_gd2.dll;把extension前面的逗号去掉，如果没有php_gd2.dll，php_gd.dll也一样,保证确实存在这一文件c:/php/extensions/php_gd2.dll
　　4:运行下面程序进行测试

　　PHP代码:

　　<?php
　　Ob_end_flush();
　　//注意,在此之前不能向浏览器输出任何信息,要注意是否设置了 auto_prepend_file.
　　header ("Content-type: image/png");
　　$im = @imagecreate (200, 100)
    　or die ("无法创建图像");
　　$background_color = imagecolorallocate ($im, 0,0, 0);
　　$text_color = imagecolorallocate ($im, 230, 140, 150);
　　imagestring ($im, 3, 30, 50,  "A Simple Text String", $text_color);
　　imagepng ($im);
　　?>

　　点击这里查看结果

　　15:什么是UBB代码

　　UBB代码是HTML的一个变种,是Ultimate Bulletin Board (国外一个BBS程序，国内也有不少地方使用这个程序)采用的一种特殊的TAG.
　　即使禁止使用 HTML，你也可以用 UBBCode? 来实现.也许你更希望使用 UBBCode? 而不是 HTML, 即使论坛允许使用 HTML, 因为使用起来代码较少也更安全.

[回顾]:上集介绍了"调试程序","如何使用session","规范SQL语句"等15个问题（Php高手带路--问题汇总解答[1]）。本集继续作出16条常见问题的解答。

16:我想修改MySQL的用户,密码
　　首先要声明一点，大部分情况下，修改MySQL是需要有mysql里的root权限的，

　　所以一般用户无法更改密码，除非请求管理员.

　　方法一

　　使用phpmyadmin，这是最简单的了，修改mysql库的user表，

　　不过别忘了使用PASSWORD函数。

　　方法二

　　使用mysqladmin，这是前面声明的一个特例。

　　mysqladmin -u root -p password mypasswd

　　输入这个命令后，需要输入root的原密码，然后root的密码将改为mypasswd。

　　把命令里的root改为你的用户名，你就可以改你自己的密码了。

　　当然如果你的mysqladmin连接不上mysql server，或者你没有办法执行mysqladmin，

　　那么这种方法就是无效的。

　　而且mysqladmin无法把密码清空。
　　下面的方法都在mysql提示符下使用，且必须有mysql的root权限：

　　方法三

　　mysql> INSERT INTO mysql.user (Host,User,Password)

　　VALUES('%','jeffrey',PASSWORD('biscuit'));

　　mysql> FLUSH PRIVILEGES

　　确切地说这是在增加一个用户，用户名为jeffrey，密码为biscuit。

　　在《mysql中文参考手册》里有这个例子，所以我也就写出来了。

　　注意要使用PASSWORD函数，然后还要使用FLUSH PRIVILEGES。

方法四

　　和方法三一样，只是使用了REPLACE语句

　　mysql> REPLACE INTO mysql.user (Host,User,Password)

　　VALUES('%','jeffrey',PASSWORD('biscuit'));

　　mysql> FLUSH PRIVILEGES

　　方法五

　　使用SET PASSWORD语句，

　　mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('biscuit');

　　你也必须使用PASSWORD()函数，

　　但是不需要使用FLUSH PRIVILEGES。

　　方法六

　　使用GRANT ... IDENTIFIED BY语句

　　mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'biscuit';

　　这里PASSWORD()函数是不必要的，也不需要使用FLUSH PRIVILEGES。
　　注意： PASSWORD() [不是]以在Unix口令加密的同样方法施行口令加密。

17:我想知道他是通过哪个网站连接到本页
　　PHP代码:

　　<?php

　　//必须通过超级连接进入才有输出

　　Echo $_SERVER['HTTP_REFERER'];

　　?>

18:数据放入数据库和取出来显示在页面需要注意什么
　　入库时

　　$str=addslashes($str);

　　$sql="insert into `tab` (`content`) values('$str')";

　　出库时

　　$str=stripslashes($str);

　　显示时

　　$str=htmlspecialchars(nl2br($str)) ;
　　<?php

　　//$content来自数据库

　　$content=nl2br(htmlspecialchars($content));

　　$content=str_replace(" ","&nbsp;",$content);

　　$content=str_replace("\n","<br>\n",$content);

　　?>

19:如何读取当前地址栏信息
　　PHP代码:

　　<?php

　　$s="http://{$_SERVER['HTTP_HOST']}:{$_SERVER["SERVER_PORT"]}{$_SERVER['SCRIPT_NAME']}";

　　$se='';
　　foreach ($_GET as $key => $value) {
　　$se.=$key."=".$value."&";
　　}
　　$se=Preg_Replace("/(.*)&$/","$1",$se);
　　$se?$se="?".$se:"";
　　echo $s."?$se";
　　?>

20:我点击后退按钮,为什么之前填写的东西不见
　　这是因为你使用了session.

　　解决办法:
　　PHP代码:

　　<?php session_cache_limiter('private, must-revalidate');session_start();
　　.....................?>

21:怎么在图片里显示IP地址

　　PHP代码:

　　<? Header("Content-type: image/png");

　　$img = ImageCreate(180,50);
　　$ip = $_SERVER['REMOTE_ADDR'];

　　 ImageColorTransparent($img,$bgcolor);

　　$bgColor = ImageColorAllocate($img, 0x2c,0x6D,0xAF); // 背景颜色

　　$shadow = ImageColorAllocate($img, 250,0,0); // 阴影颜色

　　$textColor = ImageColorAllocate($img, oxff,oxff,oxff); // 字体颜色

　　ImageTTFText($img,10,0,78,30,$shadow,"d:/windows/fonts/Tahoma.ttf",$ip);
//显示背景

　　ImageTTFText($img,10,0,25,28,$textColor,"d:/windows/fonts/Tahoma.ttf","your ip is".$ip);

 // 显示IP 　　　

　　ImagePng($img); 　　　

　　imagecreatefrompng($img);
　　ImageDestroy($img);　　　　　　

　　?>

22:如何取得用户的真实IP

　　PHP代码:

　　<? function iptype1 () {

　　 if (getenv("HTTP_CLIENT_IP"))

　　 {
　　return getenv("HTTP_CLIENT_IP");

　　}

　　else

　　{

　　return "none";
　　}

　　}

　　function iptype2 () {

　　if (getenv("HTTP_X_FORWARDED_FOR"))

　　{

　　 return
　　getenv("HTTP_X_FORWARDED_FOR");

　　}

　　else {

　　return "none";
　　}

　　}

function iptype3 () {

　　if (getenv("REMOTE_ADDR"))

　　{

　　 return getenv("REMOTE_ADDR");
　　}

　　 else {

　　return "none";

　　 }

　　 }

　　function ip() {

　　 $ip1 = iptype1();

　　 $ip2 = iptype2();

　　$ip3 = iptype3();

　　if (isset($ip1) && $ip1 != "none" && $ip1 != "unknown")

　　{

　　return $ip1;

　　}

　　 elseif (isset($ip2) && $ip2 != "none" && $ip2 != "unknown")
　　{

　　return $ip2;

　　}

　　elseif (isset($ip3) && $ip3 != "none" && $ip3 != "unknown")

　　 {

　　return $ip3;

　　}

　　 else

　　{ return "none"; }

　　}

　　 Echo ip();

　　?>

23:如何从数据库读取三天内的所有记录
　　首先表格里要有一个DATETIME字段记录时间,

　　格式为'2003-7-15 16:50:00'
　　SELECT * FROM `xltxlm` WHERE TO_DAYS(NOW()) - TO_DAYS(`date`) <= 3;

24:如何远程链接Mysql数据库

　　在增加用户的mysql表里有一个host字段，修改为"%",或者指定允许连接的ip地址,这样，你就可以远程调用了。
　　$link=mysql_connect("192.168.1.80:3306","root","");

25:正则到底怎么用

正则表达式中的特殊字符

26:用Apache后,主页出现乱码

　　方法一:

　　AddDefaultCharset ISO-8859-1 改为 AddDefaultCharset off
　　方法二:

　　AddDefaultCharset GB2312

27:为什么单引号,双引号在接受页面变成(\'\")
　　解决方法:

　　方法一:在php.ini中设置:magic_quotes_gpc = Off

　　方法二: $str=stripcslashes($str)

28:怎么让程序一直运行下去,而不是超过30秒就停止
　　set_time_limit(60)//最长运行时间一分钟

　　set_time_limit(0)//运行到程序自己结束,或手动停止

29:计算当前在线人数
　　例子一:用文本实现
　　PHP代码:

　　<?php

　　//首先你要有读写文件的权限

　　//本程序可以直接运行,第一次报错,以后就可以

　　 $online_log = "count.dat"; //保存人数的文件,

　　 $timeout = 30;//30秒内没动作者,认为掉线

　　 $entries = file($online_log);
　　 $temp = array();

for ($i=0;$i<count($entries);$i++) {

　　 $entry = explode(",",trim($entries[$i]));

　　 if (($entry[0] != getenv('REMOTE_ADDR')) && ($entry[1] > time()))
{

　　 array_push($temp,$entry[0].",".$entry[1]."\n"); //取出其他浏览者的信息,并去掉超时者,保存进$temp

　　 }

　　 }
　　 array_push($temp,getenv('REMOTE_ADDR').",".(time() + ($timeout))."\n");
//更新浏览者的时间

　　 $users_online = count($temp); //计算在线人数
　　 $entries = implode("",$temp);

　　 //写入文件

　　 $fp = fopen($online_log,"w");

　　 flock($fp,LOCK_EX); //flock() 不能在NFS以及其他的一些网络文件系统中正常工作

　　 fputs($fp,$entries);

　　 flock($fp,LOCK_UN);

　　 fclose($fp);
　　 echo "当前有".$users_online."人在线";
　　?>

30:什么是模板,怎么用
　　我用的是phplib模板

　　下面是其中几个函数的使用
　　$T->Set_File("随便定义","模板文件.tpl");
　　$T->Set_Block("在set_file中定义的","<!-- 来自模板 -->","随便定义");

　　$T->Parse("在Set_Block中定义的","<!-- 来自模板 -->",true);

　　$T->Parse("随便输出结果","在Set_File中定义的");
　　设置循环格式为:
　　<!--(多于一个空格) BEGIN $handle(多于一个空格)-->
　　如何将模板生成静态网页

　　PHP代码:

　　<?php

　　//这里使用phplib模板

　　............

　　............

　　$tpl->parse("output","html");

　　$output = $tpl->get("output");// $output 为整个网页内容

　　function wfile($file,$content,$mode='w') {

　　$oldmask = umask(0);

　　$fp = fopen($file, $mode);

　　if (!$fp) return false;

　　fwrite($fp,$content);

　　fclose($fp);

　　umask($oldmask);

　　return true;

　　}

　　// 写到文件里

　　Wfile($FILE,$output);

　　header("location:$FILE");//重定向到生成的网页

　　}

　　?>
　　phplib下载地址 smarty下载地址

31:怎么用php解释字符　　　

　　比如:输入2+2*(1+2),自动输出8　　可以用eval函数

　　PHP代码:

　　<form method=post action="">

　　<input type="text" name="str"><input type="submit">

　　</form>

　　<?php

　　$str=$_POST['str'];

　　eval("\$o=$str;");

　　Echo "$o";

　　?>

　　到此，php的问题解答就为大家介绍完毕，希望能对各位有所帮助。

子选择器:
相对来说，简化html文件的代码更加重要，因此在css中使用子选择器非常有益，同时也使css代码更加容易理解。比如下面的代码：
<div id="sub_nav">
<ul>
<li> <a href="#">Item 1</a></li>>
<li> <a href="#">Item 2</a></li>
<li> <a href="#">Item 3</a></li>
</ul>
</div>
如果div li a都有各自的式样,采用子选择器,可以省略代码中li 和a 的class属性，从而简化代码：
#sub_nav { /* Some styling */ }
#sub_nav li { /* Some styling */ }
#sub_nav a { /* Some styling */ }
组选择器：
当一些元素类型、class或者id都有共同的一些属性，你就可以使用组选择器来避免多次的重复定义。这可以节省不少字节。
例如：定义所有标题的字体、颜色和margin，你可以这样写：
h1,h2,h3,h4,h5,h6 {
font-family:"Lucida Grande",Lucida,Arial,Helvetica,sans-serif;
color:#333;
margin:1em 0;
}
如果在使用时，有个别元素需要定义独立样式，你可以再加上新的定义，可以覆盖老的定义，例如：
h1 { font-size:2em; }
h2 { font-size:1.6em; }
重用、子选择器和组选择器的灵活使用可以非常有效的减少代码，同时非常有利的增加代码的可读性，具体的应用需要在具体编写过程中体会。