public class BaseCache extends GeneralCacheAdministrator {
// 过期时间(单位为秒);
 private int refreshPeriod;
 

 public BaseCache(int refreshPeriod){
    super();
    this.refreshPeriod=refreshPeriod;
 }
// 添加被缓存的对象;
 public void put(String key,Object value){
    this.putInCache(key,value);
 }
// 删除被缓存的对象;
 public void remove(String key){
    this.flushEntry(key);
 }
// 删除所有被缓存的对象;
 public void removeAll(Date date){
    this.flushAll(date);
 }

 public void removeAll(){
    this.flushAll();
   
 }
// 获取被缓存的对象;
 public Object get(String key) throws Exception{
    try{
     return this.getFromCache(key,this.refreshPeriod);
    } catch (NeedsRefreshException e) {
     this.cancelUpdate(key);
          throw e;
    }
   }
}
2.执行方法:
在方法里,indexCache = new BaseCache(3600),hii = new cache.Hits(hits),这个类是自己写的,下面的详细代码,然后调用put(String key,Object value)方法,key是关键字.下次取的时候就直接get(key),key我是用的查询参数组成的,只要下次当别人用到相同条件搜索时,就可以直接从缓存读数据,这里所提到的是org.apache.lucene.search.Hits这个对像是不能被缓存的,没有被序例化,我查了下源码,也不能被继承,所以大家自己写个类implements Serializable

public class Hits implements Serializable   {
  private  org.apache.lucene.search.Hits hits;
  private  Document[] docs=null;
  private boolean flag=true;
 
 /**
  * sundc 2007-11-20
  */
 public Hits(org.apache.lucene.search.Hits hits) {
  this.docs=new Document[hits.length()];
  int length=0;
//我这里是定义记录有只缓存前710多记录,如果大于710还是查lucene,大家都知道搜索用户访问都是几页,大家可以针对自己项目进行规化..
if(hits.length()>=710){
   length=710;
  }
  else{
   length=hits.length(); 
  }
   for(int i=0;i<length;i++){
   try {
    this.docs[i]=hits.doc(i);
   } catch (CorruptIndexException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }

 
 public Hits( Document[] doc){
  this.docs=doc;
 }
 public  Document doc(int i){
  if(!this.flag){
   try {
    return this.hits.doc(i);
   } catch (CorruptIndexException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
  }
  return this.docs[i];
 }

 public  int length(){
  if(this.flag){
   return  docs.length;
  }
  return this.hits.length();
 }
 
 public  Document[] getDocs() {
  return this.docs;
 }

 public  void setDocs(Document[] docs) {
  this.docs = docs;
 }

 public org.apache.lucene.search.Hits getHits() {
  return this.hits;
 }

 public void setHits(org.apache.lucene.search.Hits hits) {
  this.hits = hits;
 }
}
我这里是如果有缓存数据,就读缓存,没有,就lucene然后放在缓存里.大家可以调用indexCache.get(key),大家每一次访问的时候会相对很慢.如果缓存已经建立了,那么速度会很快,大家在用的时候,针对自己项目的数据要求,进行缓存.下面介绍内存缓存.
  2.内存缓存可以相对要快点.但是针对服务器的本身内存大小,大家针对自己的项目和服务器的配置选择好的缓存方式.,把cache.memory=true,这样就可以了.
3.还可以实现页面级缓存
你可以在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）作缓存处理.
我这里介绍的不全,只是我在项目中用到了这些.如果有什么问题,虚心接受....

 import java.util.Date;                                          
 public final class BrokenPerson                                
 {                                                              
  private String firstName;                                    
  private String lastName;                                     
  private Date dob;                                            
                                         
  public BrokenPerson( String firstName,                   public BetterPerson( String firstName,
    String lastName, Date dob)                                             String lastName, Date dob)          
  {                                                                                      {                                     
   this.firstName = firstName;                                             this.firstName = firstName;         
   this.lastName = lastName;                                             this.lastName = lastName;           
   this.dob = dob;     //error               this.dob = new Date( dob.getTime() ); //correct
  }                                                                                       }                                      
                                                             
  public String getFirstName()
  {
   return this.firstName;
  }
  public String getLastName()
  {
   return this.lastName;
  }
  public Date getDOB()                                               public Date getDOB()                     
  {                                                                                    {                                      
   return this.dob;    //error                  return new Date( this.dob.getTime() );//correct
  }                                                                                     }                                      
 }
  4. jdk的可变类和不可变类

primitive变量: boolean,byte, char, double ,float, integer, long, short
jdk的不可变类：jdk的java.lang包中 Boolean, Byte, Character, Double, Float, Integer, Long, Short, String.
 
  StringBuffer 可变类
  java.util.Date 可变类

本示例代码引用了以下两个包：
dom4j-1.6.1.jar
jaxen-1.1-beta-6.jar

下载与安装
  dom4j是sourceforge.net上的一个开源项目，主要用于对XML的解析。dom4j专门针对Java开发，使用起来非常简单、直观。
  可以到http://sourceforge.net/projects/dom4j下载其最新版。
  dom4j1.6解压后有一个dom4j-1.6.1.jar文件，这就是应用时需要引入的类包，另外还有一个jaxen-1.1-beta-6.jar 文件，需要引入，否则执行时可能抛java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常

代码如下:
package com.tl.common.util;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * @author zhangql
 *
 * To change this generated comment edit the template variable "typecomment":
 * Window>Preferences>Java>Templates. To enable and disable the creation of type
 * comments go to Window>Preferences>Java>Code Generation.
 */
public final class ConfigtUtil
{
  
   
    /**
     * 空方法，未实现
     */
    public void getRootNodeAttribute()
    {
        //TODO
    }
   
    /** 返回节点路径
     * @param rootNodeName
     * @param childNodeName
     * @return String
     */
    public String getNodePath(String rootNodeName,String childNodeName)
    {
        String result = null;
        if(rootNodeName== "" || rootNodeName == null ||
                childNodeName == "" || childNodeName == null)
        {
            return result;
        }
        result = getNodePath(rootNodeName,childNodeName,null);
        return result;
    }
   
    /**
     * 返回节点路径
     * @param rootNodeName
     * @param childNodeName
     * @param childAttributeName
     * @return String
     */
    public String getNodePath(String rootNodeName,String childNodeName,String childAttributeName)
    {
        String result = null;
        if(rootNodeName== "" || rootNodeName == null ||
                childNodeName == "" || childNodeName == null )
        {
            return result;
        }
        String dima = "/";
        StringBuffer nodePath = new StringBuffer();
        nodePath.append(rootNodeName);
        nodePath.append(dima).append(childNodeName);
        if(childAttributeName != null && childAttributeName != "")
        {
            nodePath.append(dima).append("@");
            nodePath.append(childAttributeName);
        }
       
        result = nodePath.toString();
        return result;
    }
   
    /**
     * 更新子节点属性值
     * @param filePathAndName
     * @param rootNodeName
     * @param childNodeName
     * @param childAttributeName
     * @param childAttributeValue
     * @return boolean
     * @throws DocumentException
     * @throws IOException
     */
    public boolean updateChildNodeAttributeValue(String filePathAndName, String rootNodeName,
            String childNodeName,String childAttributeName,
            String childAttributeValue) throws DocumentException, IOException
    {
        boolean result = false;
        if(filePathAndName == "" || filePathAndName == null ||
                rootNodeName== "" || rootNodeName == null ||
                childNodeName == "" || childNodeName == null ||
                childAttributeName == "" || childAttributeName == null ||
                childAttributeValue == "" || childAttributeValue == null)
        {
            return result;
        }
       
       String nodePath = getNodePath(rootNodeName,childNodeName,childAttributeName);
       Document document = getDocument(filePathAndName);       
       List list = getListByDocument(document,nodePath);
       for(Iterator iter = list.iterator();iter.hasNext();)
       {
           Attribute attribute = (Attribute) iter.next();
           attribute.setValue(childAttributeValue);
       }
       result = writerConfigFileByFormat(filePathAndName,document);
       return result;
    }
   
    /**
     * 取得Document中指定节点下的所有节点集合
     * @param document
     * @param nodeName
     * @return List
     */
    public List getListByDocument(Document document,String nodeName)
    {
        if(document == null || nodeName == null || nodeName == "")
        {
            return null;
        }
        List list = null;
        list = document.selectNodes(nodeName);
        return list;
    }
   
    /**
     *  获取Document
     * @param filePathAndName
     * @return Document
     * @throws DocumentException
     */
    public Document getDocument(String filePathAndName)
            throws DocumentException
    {
        Document document = null;
        if (filePathAndName == null || filePathAndName == "")
        {
            return document;
        }
        SAXReader saxReader = new SAXReader();
        document = saxReader.read(new File(filePathAndName));
        return document;
    }

    /**
     * 获取根节点下的子节点集合
     * @param filePathAndName
     * @param rootNodeName
     * @param childNodeName
     * @return List
     * @throws DocumentException
     */
    public List getRootListByChildNode(String filePathAndName, String rootNodeName,
            String childNodeName) throws DocumentException
    {
        List  result = null;
        if (filePathAndName == null || filePathAndName == "" ||
                rootNodeName == null || rootNodeName == "" ||
                childNodeName == null || childNodeName =="")
        {
            return result;
        }
        String nodePath = getNodePath(rootNodeName,childNodeName);
        result = getRootNodeList(filePathAndName,nodePath);
        return result;
    }
   
    /**
     * 获取根节点集合
     * @param filePathAndName
     * @param rootNodeName
     * @return List
     * @throws DocumentException
     */
    public List getRootNodeList(String filePathAndName, String rootNodeName)
            throws DocumentException
    {
        List list = null;
        if (filePathAndName == null || filePathAndName == "" ||
                rootNodeName == null || rootNodeName == "")
        {
            return list;
        }
        list = getNodeList(filePathAndName,rootNodeName);
        return list;
    }
   
    /**
     * 取得节点集合
     * @param filePathAndName
     * @param nodePath
     * @return List
     * @throws DocumentException
     */
    public List getNodeList(String filePathAndName, String nodePath) throws DocumentException
    {
        List list = null;
        if (filePathAndName == null || filePathAndName == "" ||
                nodePath == null || nodePath == "")
        {
            return list;
        }
        list = getListByDocument(getDocument(filePathAndName),nodePath);
        return list;
    }

    /**
     * 获取节点的值
     * @param filePathAndName
     * @param rootNodeName
     * @param nodeName
     * @return String
     * @throws DocumentException
     */
    public String getNodeValue(String filePathAndName, String rootNodeName,
            String nodeName) throws DocumentException
    {
        String result = null;
        if (filePathAndName == null || filePathAndName == ""
                || rootNodeName == null || rootNodeName == ""
                || nodeName == null || nodeName == "")
        {
            return result;
        }
        List list = getRootNodeList(filePathAndName, rootNodeName);
        result = getNodeValue(list, nodeName);
        return result;
    }
   
    /**
     * 获取子节点值
     * @param list
     * @param childNodeName
     * @return String
     */
    public String getChildNodeValue(List list,String childNodeName)
    {
       String result = null;
       if(list.isEmpty() || childNodeName == "" || childNodeName == null)
       {
           return result;
       }
       result = getNodeValue(list,childNodeName);
       return result;
    }

    /**
     * 获取子节点值
     * @param list
     * @return String
     */
    public String getChildNodeValue(List list)
    {
       String result = null;
       if(list.isEmpty())
       {
           return result;
       }
       for(Iterator iter = list.iterator();iter.hasNext();)
       {
           Element element = (Element)iter.next();
           result = element.getText();
       }
        return result;
    }
   
    /**
     * 取得子节点的属性值
     * @param filePathAndName
     * @param rootNodeName
     * @param childNodeName
     * @param childAttributeName
     * @return String
     * @throws DocumentException
     */
    public String getChildNodeAttributeValue(String filePathAndName,
            String rootNodeName, String childNodeName, String childAttributeName)
            throws DocumentException
    {
        String result = null;
        if(filePathAndName == "" || filePathAndName == null ||
                rootNodeName == "" || rootNodeName == null ||
                childNodeName == "" || childNodeName == null ||
                childAttributeName == null || childAttributeName == "")
        {
            return result;
        }

        String nodePath = getNodePath(rootNodeName, childNodeName,childAttributeName);
        List list = getNodeList(filePathAndName, nodePath);
        result = getChildNodeAttributeValue(list);

        return result;
    }
   
    /**
     * 此方法未实现
     * @param list
     * @param nodeName
     * @param attributeName
     * @return
     */
    public String getChildNodeAttributeValue(List list,String nodeName,String attributeName)
    {
        String result = null;
        if(list.isEmpty() || nodeName == null || nodeName =="" ||
                attributeName == null || attributeName =="")
        {
            return result;
        }
        //TODO
//        String nodePath = getNodePath(nodeName,attributeName);
//       
//        for (Iterator iter = list.iterator(); iter.hasNext();)
//        {
//            Element element = (Element) iter.next();
//            System.out.println("---->"+element.selectNodes(nodeName).size());
//            System.out.println("---->"+element.selectNodes(nodePath).size());
//            for(Iterator elementIter = element.selectNodes(nodeName).iterator();elementIter.hasNext();)
//            {
//                Attribute attribute = (Attribute)elementIter.next();
//                System.out.println("---->"+attribute.getValue());
//            }
////            result = getChildNodeAttributeValue(element.selectNodes(nodeName));          
//        }
       
        return result;
    }
   
    /**
     * 获取子节点属性的值
     * @param list
     * @param childNodeAttributeName
     * @return String
     */
    public String getChildNodeAttributeValue(List list,String childNodeAttributeName)
    {
        String result = null;
        if(list.isEmpty() || childNodeAttributeName == null || childNodeAttributeName =="")
        {
            return result;
        }
        result = getNodeValue(list,childNodeAttributeName);
        return result;
    }
   
    /**
     * 获取子节点属性的值
     * @param list
     * @return String
     */
    public String getChildNodeAttributeValue(List list)
    {
        String result = null;
        if(list.isEmpty())
        {
            return result;
        }    
        for(Iterator iter = list.iterator();iter.hasNext();)
        {
            Attribute attribute = (Attribute)iter.next();
            result = attribute.getValue();
        }      
        return result;
    }
   
    /**
     * 获取节点值
     * @param nodeList
     * @param nodeName
     * @return String
     */
    public String getNodeValue(List nodeList, String nodeName)
    {
        String result = null;
        if (nodeList.isEmpty())
        {
            return result;
        }

        for (Iterator iter = nodeList.iterator(); iter.hasNext();)
        {
            Element element = (Element) iter.next();
            for (Iterator it = element.selectNodes(nodeName).iterator(); it.hasNext();)
            {
                result = ((Element) it.next()).getText();
            }
        }
        return result;
    }

    /**
     * 更新节点值
     * @param filePathAndName
     * @param rootNodeName
     * @param nodeName
     * @param NodeVlaue
     * @return boolean
     * @throws Exception
     */
    public boolean updateNodeValue(String filePathAndName, String rootNodeName,
            String nodeName, String NodeVlaue) throws Exception
    {
        boolean result = false;       
        Document document = getDocument(filePathAndName);
        List list = document.selectNodes(rootNodeName);       
        for (Iterator iter = list.iterator(); iter.hasNext();)
        {
            Element element = (Element) iter.next();
            for (Iterator childIterator = element.selectNodes(nodeName)
                    .iterator(); childIterator.hasNext();)
            {
                Element childElement = (Element) childIterator.next();
                childElement.setText(NodeVlaue);
            }
        }
        /** 将document中的内容写入文件中 */
        result = writerConfigFileByFormat(filePathAndName,document);       
        return result;
    }
  
    /**
     * 创建XMLWriter
     * @param filePathAndName
     * @return XMLWriter
     * @throws IOException
     */
    private XMLWriter createXMLWriter(String filePathAndName) throws IOException
    {
        XMLWriter writer = null;
        writer = new XMLWriter(new FileWriter(new File(filePathAndName)));
        return writer;
    }
   
    /**
     * 创建XMLWriter
     * @param filePathAndName
     * @param outputFormat
     * @return XMLWriter
     * @throws IOException
     */
    private XMLWriter createXMLWriter(String filePathAndName,OutputFormat outputFormat) throws IOException
    {
        XMLWriter writer = null;
        writer = new XMLWriter(new FileWriter(new File(filePathAndName)), outputFormat);
        return writer;
    }
   
    /**
     * 以GBK格式化写文件
     * @param filePathAndName
     * @param document
     * @return boolean
     */
    public boolean writerConfigFileByFormat(String filePathAndName,Document document)
    {
        boolean result = false;
        try
        {                       
            result = writerConfigFileByFormat(filePathAndName,document,"GBK");
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return result;
    }
   
    /**
     * 格式化写文件
     * @param filePathAndName
     * @param document
     * @param encoding
     * @return boolean
     */
    public boolean writerConfigFileByFormat(String filePathAndName,Document document,String encoding)
    {
        boolean result = false;
        try
        {           
            XMLWriter writer = null;
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding(encoding);
            writer = createXMLWriter(filePathAndName, format);
            writerConfigFile(writer,document);
            result = true;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return result;
    }
   
   
    /**
     * 写文件
     * @param filePathAndName
     * @param document
     * @return boolean
     * @throws IOException
     */
    public boolean writerConfigFile(String filePathAndName,Document document) throws IOException
    {
        boolean result = false;
        XMLWriter writer = createXMLWriter(filePathAndName);
        writerConfigFile(writer,document);
        result = true;
        return result;
    }
   
    /**
     * 写文件    
     * @param xmlWriter
     * @param document
     * @return boolean
     * @throws IOException
     */
    public boolean  writerConfigFile(XMLWriter xmlWriter,Document document) throws IOException
    {
        boolean result = false;
        xmlWriter.write(document);
        xmlWriter.close();
        result = true;
        return result;
    }
   
    /**
     * 此方法为网上转载，临时加入到本类，未作代码验证
     * 建立一个XML文档,文档名由输入属性决定
     * @param filename 需建立的文件名
     * @return 返回操作结果, 0表失败, 1表成功
     */
    public int createXMLFile(String filename)
    {
       /** 返回操作结果, 0表失败, 1表成功 */
       int returnValue = 0;
       /** 建立document对象 */
       Document document = DocumentHelper.createDocument();
       /** 建立XML文档的根books */
       Element booksElement = document.addElement("books");
       /** 加入一行注释 */
       booksElement.addComment("This is a test for dom4j, holen, 2004.9.11");
       /** 加入第一个book节点 */
       Element bookElement = booksElement.addElement("book");
       /** 加入show属性内容 */
       bookElement.addAttribute("show","yes");
       /** 加入title节点 */
       Element titleElement = bookElement.addElement("title");
       /** 为title设置内容 */
       titleElement.setText("Dom4j Tutorials");      
       /** 类似的完成后两个book */
       bookElement = booksElement.addElement("book");
       bookElement.addAttribute("show","yes");
       titleElement = bookElement.addElement("title");
       titleElement.setText("Lucene Studing");
       bookElement = booksElement.addElement("book");
       bookElement.addAttribute("show","no");
       titleElement = bookElement.addElement("title");
       titleElement.setText("Lucene in Action");      

       /** 加入owner节点 */
       Element ownerElement = booksElement.addElement("owner");
       ownerElement.setText("O'Reilly");
       try
       {
           /** 将document中的内容写入文件中 */
           XMLWriter writer = new XMLWriter(new FileWriter(new File(filename)));
           writer.write(document);
           writer.close();
           /** 执行成功,需返回1 */
           returnValue = 1;

       }
       catch(Exception ex)
       {
           ex.printStackTrace();
       }
       return returnValue;
    } 
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=959095

--------------------------------------------------------

附：

一、如何设置上传文件语言

把FCKeditor根目录下面的fckconfig.js文件里

var _FileBrowserLanguage    = 'asp' ;    // asp | aspx | cfm | lasso | perl | php | py
var _QuickUploadLanguage    = 'asp' ;    // asp | aspx | cfm | lasso | php

这两行中改成您所需要调用的编辑器语言，如用asp.net则改为aspx；

二、解决中文的问题:
在web.config中加入:
<globalization requestEncoding="GB2312" responseEncoding="GB2312"/>
这样设置后可以显示中文的文件，但URL地址也是中文的；
如果服务器对中文地址的解析不好，可能导致图片无法浏览；
所以修改：editor\filemanager\browser\default\frmresourceslist.html
中的OpenFile函数，把
window.top.opener.SetUrl( fileUrl ) ;
修改为:
window.top.opener.SetUrl( escape(fileUrl) ) ;

三.设置上传的目录：
1:在web.config中设置:
 <appSettings>
     <add key="FCKeditor:UserFilesPath" value="/fck/UpLoad/" />
 </appSettings>

2:在Session中设置:
在editor\filemanager\browser\default\connectors\aspx\connector.aspx中加入以下代码:
<script runat="server" language="C#">
 protected override void OnInit(EventArgs e)
 {
  Session["FCKeditor:UserFilesPath"] = "/fck/UpLoad1/";
 }
</script>

附：如何在asp.net中动态设置上传图片的路径？

1.在javascript中修改FCKConfig.ImageBrowserURL的值，修改方式如下：
 FCKConfig.ImageBrowserURL += "?Path=要上传的文件路径";
 如:要把文件上传到站点根目录的UploadFile文件夹中，则设置为：
 FCKConfig.ImageBrowserURL += "?Path=/UploadFile";
2.在"editor\filemanager\browser\default\connectors\aspx\connector.aspx"文件最后中增加以下程序：
<script runat="server" language="C#">
    protected override void OnInit(EventArgs e)
    {
 if( Request.QueryString["Path"]==null ){
  Session["FCKeditor:UserFilesPath"] = "/UpLoadFiles/"; //设置默认值
 }else{
  Session["FCKeditor:UserFilesPath"] = Request.QueryString["Path"];
 }
    }
</script>

posted on 2007-08-22 10:56 春风依旧 阅读(13) 评论(1)  编辑 收藏 引用 网摘 所属分类: 前台脚本

先完成代码编写，如下：

package com.emailtest;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.SimpleEmail;

public class EmailUtil {
 Log log = LogFactory.getLog("Send E-mail");
 public static String charsetname = "ISO8859_1";//字符集，用于中文处理
 public static String fromeaddr = "simplelife@126.com";//发件人邮箱地址
 public static String username = "simplelife";//发件人邮箱用户名
 public static String password = "xxxxxx";//发件人邮箱密码
 public static String sendname = "hilor";//发件人名称
 public static String emailServer = "smtp.126.com";//邮件服务器
 
 /**
  *
  * @param emailaddr 收件人邮箱地址
  * @param ename 收件人姓名
  * @param subject 邮件主题
  * @param mailcontent 邮件内容
  * @return 邮件发送是否成功
  *
  */
 public boolean sendMail(String emailaddr,String ename,String subject,String mailcontent) throws Exception {
  SimpleEmail email = new SimpleEmail();
  
  //设置发件人用户名、密码认证
  email.setAuthentication(EmailUtil.username,EmailUtil.password);
  
  //设置发送邮件所使用的邮件服务器
  email.setHostName(EmailUtil.emailServer);
  try{
   //添加收件人信息
   email.addTo(emailaddr, ename);
   
   //添加发件人信息
   email.setFrom(EmailUtil.fromeaddr, EmailUtil.sendname);
   
   //添加邮件主题
   email.setSubject(subject);
   
   //添加邮件内容
   email.setMsg(mailcontent);
   
   //发送邮件
   email.send();
   
   //记录日志
   log.info("Send Mail Successfully!");
   return true;
  }catch(EmailException e){
   log.error(e.getMessage());
   return false;
  }
 }
 /**
  *
  * 测试主程序
  */
 public static void main(String[] args) {
  EmailUtil email = new EmailUtil();
  try{
   email.sendMail("xxx@xxxxx.com","xxx","测试邮件",new String("发送测试邮件！\n发送测试邮件！\n发送测试邮件！\n发送测试邮件!".getBytes(),EmailUtil.charsetname));
 
  }catch(Exception e){
   e.printStackTrace();
  }
 }

}

这个EmailUtil类只实现了一个用来发送邮件的方法，还有一个是静态的main()测试主程序。在这个例子中只用到commons-email包里的SimpleEmail类。利用commons-email实现邮件功能，在类路径中不但要包含commons-email提供的jar包，还必须包含sun的javamail提供的两个与邮件相关的jar包（activation.jar，mail.jar）。

程序中日志记录是利用commons-logging和log4j结合来实现的，需要加入两个jar包（log4j-1.2.11.jar，commons-logging-1.0.4.jar）。然后添加log4j.properties配置文件，文件内容如下：

log4j.rootLogger=info, dest1

log4j.appender.dest1=org.apache.log4j.ConsoleAppender
log4j.appender.dest1.layout=org.apache.log4j.PatternLayout
log4j.appender.dest1.layout.ConversionPattern=%d %-5p %-5c{3} %x -> %m%n

log4j配置文件细节请参考log4j参考手册，在这里不做太多解释。

如果只是想做测试，也可以把程序中相关部分用System.out.print()替换掉，无须加入日志相关的jar包和log4j配置文件。

        fu.setSizeThreshold(4096);              //设置缓冲大小.

        fu.setRepositoryPath(dir+"/ball/news/images");      //设置临时目录.
 
        List fileItems = fu.parseRequest(request);  //解析请求,返回一个集合.
       

        Iterator i = fileItems.iterator();
        String fieldvalue="";
        String ff = "";
  String picname="false";
  Object tt = "";
  Vector v = new Vector();
  
        while(i.hasNext())
     {
    
         FileItem fi = (FileItem)i.next();
 
    if(fi.isFormField())                        //这是用来确定是否为文件属性,
     {
     
     String fieldName = fi.getFieldName();     //这里取得表单名
     fieldvalue=fi.getString();        //这里取得表单值
     
  v.addElement(fieldvalue);
    
     }
 
     else                                           //这里开始外理文件
  {
  
   File fullFile = new File(fi.getName());
   ff = fullFile.getName();
   String rr = "";

   java.util.Date date2 = new java.util.Date();
   SimpleDateFormat formatter = new SimpleDateFormat ("yyyyMMddHHmmss");   //取得时间
      String str2 = formatter.format(date2);
   StringTokenizer st = new StringTokenizer(ff,".");
         if (st.hasMoreTokens()){
          String test12 = st.nextToken();
          rr = st.nextToken();
          //System.out.println(rr);
         }
         if (rr.equals("")&&!rr.equals("gif")&&!rr.equals("jpg")&&!rr.equals("jpeg"))
      {
    picname = "false";
   }
   
   else
      {
             picname = str2+"."+rr;     //以时间为图片名称

                File savedFile = new File(getServletContext().getRealPath("/ball/news/images/"),picname);
  
                fi.write(savedFile);     //上传到服务器
            }
   //System.out.println("picname------------------------"+picname);
     }
  //System.out.println("v------------------------"+v);
   }
    String[] flag = {"<temp_title>","<temp_date>","<temp_author>","<temp_content>","<str_Temp>","<temp_picture>"};

    //将数据写入到数据库
    Object newtype1 = v.elementAt(0);
       String t = newtype1.toString();
    int newtype = Integer.parseInt(t);
    Object rowid1 = v.elementAt(1);
    String rowid = rowid1.toString();
    Object title1 = v.elementAt(2);
    String title = title1.toString();
    Object content1 = v.elementAt(3);
    String content = content1.toString();
   // System.out.println(down);
    java.util.Date date = new java.util.Date();
       String strdate = date.toLocaleString();

 java.util.Date StrDate1 = new java.util.Date();
 String StrDate = StrDate1.toLocaleString();   // 新闻发布时间
 //String newtype="0";
 conn.openDB();
 String sql = "select top 5 * from b_news where newtype="+newtype+" order by id desc";
 String strTemp="<tr><td>相关新闻</td></tr>";
 ResultSet rs = conn.executeQuery(sql);
 while (rs.next())
    {
   String t2 = rs.getString(2);
   String t4 = rs.getString(4);
   strTemp += "<tr><td>";
   strTemp +="<a href=../../../"+t4+">";
   strTemp += t2;
   strTemp +="</a>";
   }
    strTemp +="</td></tr>";
    rs.close();

 
 //读取模板

 String filePath = "";
 filePath = request.getRealPath("\\ball\\news\\pnews.template");
 String templateContent = null;
 try{
  templateContent = ReadTemplates.getTlpContent(filePath);
  System.out.println(templateContent);
 }
 catch(Exception e)
  {
   System.out.println("error to template!");
  }
 //替换模板中的内容
 //System.out.println("picname--------------------------------"+picname);
   
 templateContent = ReplaceAll.replace(templateContent,flag[0],title);
 templateContent = ReplaceAll.replace(templateContent,flag[1],StrDate);
 //templateContent = ReplaceAll.replace(templateContent,flag[2],editer);
 templateContent = ReplaceAll.replace(templateContent,flag[3],content);
 templateContent = ReplaceAll.replace(templateContent,flag[4],strTemp);
 templateContent = ReplaceAll.replace(templateContent,flag[5],picname);

 // 根据时间得文件名与路径名
 
 Calendar calendar = Calendar.getInstance();
 String fileName = String.valueOf(calendar.getTimeInMillis()) +".html";
 String pathName = request.getRealPath("ball/news")+"\\"+ calendar.get(Calendar.YEAR) + "\\"+ (calendar.get(Calendar.MONTH)+1) +"\\"+ calendar.get(Calendar.DAY_OF_MONTH)+"\\"; 
 String url = calendar.get(Calendar.YEAR) + "/"+ (calendar.get(Calendar.MONTH)+1) +"/"+ calendar.get(Calendar.DAY_OF_MONTH)+"/";
 url +=fileName;
 //System.out.println(url);

 try{
  WriteHtml.save(templateContent,pathName,fileName);
 }catch(Exception e){
 System.out.println("error to html!-----------"+e.getMessage());
 }

 
   //写入数据库
   String sqlInsert = null;
    if (!picname.equals("false")){
     sqlInsert = "insert into b_news (title,content,url,picture,newtype,addtime,rowid) values ('"+title+"','"+content+"','"+url+"','"+picname+"','"+newtype+"',getdate(),'"+rowid+"')";
    }
 else
 {
   picname="images/"+picname;
   sqlInsert = "insert into b_news (title,content,url,newtype,addtime,rowid) values ('"+title+"','"+content+"','"+url+"','"+newtype+"',getdate(),'"+rowid+"')";
 }
 //System.out.println("sql insert---------------"+sqlInsert);
 conn.executeUpdate (sqlInsert);
   }
   catch(Exception e)
    {
    System.out.println("upload error------------------"+e.getMessage());
     }
   
 
   
%>
<%out.println("新闻生成html成功了！");%>

1.buildhtml.jsp

<%@ page contentType="text/html; charset=gb2312" import="java.util.*,java.io.*"%>
<%
try{
 String title="This is Title";
 String content="This is Content Area";
 String editer="LaoMao";
 String filePath = "";
 filePath = request.getRealPath("/")+"test/template.htm";
 //out.print(filePath+"<br>");
 String templateContent="";
 FileInputStream fileinputstream = new FileInputStream(filePath);//读取模块文件
 int lenght = fileinputstream.available();
 byte bytes[] = new byte[lenght];
 fileinputstream.read(bytes);
 fileinputstream.close();
 templateContent = new String(bytes);
 //out.print(templateContent);
 templateContent=templateContent.replaceAll("###title###",title);
 templateContent=templateContent.replaceAll("###content###",content);
 templateContent=templateContent.replaceAll("###author###",editer);//替换掉模块中相应的地方
 //out.print(templateContent);
 // 根据时间得文件名
 Calendar calendar = Calendar.getInstance();
 String fileame = String.valueOf(calendar.getTimeInMillis()) +".html";
 fileame = request.getRealPath("/")+fileame;//生成的html文件保存路径
 FileOutputStream fileoutputstream = new FileOutputStream(fileame);//建立文件输出流
 byte tag_bytes[] = templateContent.getBytes();
 fileoutputstream.write(tag_bytes);
 fileoutputstream.close();
}
catch(Exception e){
 out.print(e.toString());
}

%>

2. template.htm

<html>
<head>
<title>###title###</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<LINK href="../css.css" rel=stylesheet type=text/css>
</head>

<body>
<table width="500" border="0" align="center" cellpadding="0" cellspacing="2">
  <tr>
    <td align="center">###title###</td>
  </tr>
  <tr>
    <td align="center">author：###author###&nbsp;&nbsp;</td>
  </tr>
  <tr>
    <td>###content###
 </td>
 
  </tr>

</table>
</body>
</html>

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

tomcat 安装好之后，只需要把你的程序包放到$Tomcat_Home$/webapps下就可以直接使用了。这样会使webapps越来越大就需要设置虚拟目录：
1.单个应用设置：
 在<Host>和</host>之间加上
 <Context path="/site" docBase="d:\site" reloadable="true" debug="0">
 </Context>
 参数:path 表示在浏览器中输入http://localhost:8080/site
     docBase表示你的程序包的物理绝对路径，默认的绝对路径是$Tomcat_Home$/webapps
 这样设定了之后会在$tomcat_home$/conf/catalina/localhost目录下生成一个site.xml文件，此文件的内容就是刚才设置的内容。
2. 通过前面我们知道了在$tomcat_home$/conf/catalina/localhost目录下会生成相应的配置文件，因此我们可以直接在$ tomcat_home$/conf/catalina/localhost目录下写配置文件文件名任意取，最好是跟你的web应用相同便于管理，如 site.xml内容同上
<Context path="/site" docBase="d:\site" reloadable="true" debug="0">
 </Context>
3.更改整个根目录：
  找到<Host name="localhost" debug="0" appBase="webapps" 
  unpackWARs="true" autoDeploy="true">
 将appBase的设置成期望的路径（绝对路径）
 出现的问题：输入：http://localhost:8080/没有出现默认的页面
 原因当然是更改了路径造成的。解决也很简单了，把文件拷过来，或者再把原来默认的设成虚拟路径。

XML processing                         http://java.sun.com/jstl/xml        x        <x:tagname ...>

 I18N capable formatting   http://java.sun.com/jstl/fmt     fmt     <fmt:tagname ...>

Database access (SQL)   http://java.sun.com/jstl/sql     sql      <sql:tagname ...>

Core支持JSP中的一些基本的操作；
XML processing支持XML文档的处理；
I18N capable formatting支持对JSP页面的国际化；
Database access (SQL)支持JSP对数据库的操作。

由于本人水平有限，本文仅介绍Core标签，如有兴趣，可一起探讨其它三种标签的使用与扩充。

EL语言介绍

EL语言是JSTL输出（输入）一个JAVA表达式的表示形式。
在JSTL中，EL语言只能在属性值中使用。EL语言只能通过建立表达式来进行调用。在属性值中使用表达式有三种方式。

1、 value属性包含一个表达式
<some:tag value=""/>
在这种情况下，表达式值被计算出来并根据类型转换规则赋值给value属性。比如：<c:out value="" />中的就是一个EL，它相当于JSP语句<%=request.getAttribute(“username”)%>或<% =session.getAttribute(“username”)%>

2、 value属性包含一个或多个属性，这些属性被文本分割或围绕
<some:tag value="sometext"/>
在这种情况下，表达式从左到右进行计算，并将结果转换为字符串型（根据类型转换规则），并将结果赋值给value属性

3、 value属性仅仅包含文本
<some:tag value="sometext"/>
在这种情况下，字符串型属性value将根据类型转换规则转换为标签所希望的类型。

EL语言的操作符
取得某个对象或集合中的属性值
为了获得集合中的属性，EL支持以下两种操作
1． 使用.操作符来获得有名字的属性。例如表达式表明对象user的username属性
2． 使用[]操作符来获得有名字或按数字排列的属性。
表达式和表达式含义相同
表达式 表明row集合的第一个条目。
在这里user是一个类的对象，它的属性username必须符合标准JavaBean的规范，即必须为username属性定义相应的getter、setter方法。

Empty操作符(空值检查)

使用empty操作符来决定对象、集合或字符串变量是否为空或null。例如：
true
如果request的参数列表中的username值为null，则表达式的值为true。 EL也可以直接使用比较操作符与null进行比较。如true。
比较操作符

2.准备web开发目录
   比如我的web目录为h:\webapp\myweb\(当然可以把你的web应用放在%tomcat_home%\webapps\)，称为工作目录Working folder,在工作目录h:\webapp\myweb\下建立WEB-INF\lib,WEB-INF\classes

3.拷贝.jar文件
   将jakarta-taglibs-standard-1.1.1\lib\下的两个jar文件：standard.jar和jstl.jar文件拷贝到\WEB-INF\lib\下

4.拷贝.tld文件
 将jakarta-taglibs-standard-1.1.1\tld\下的8个tld类型文件拷到"Working folder\WEB-INF\"下

5.在\WEB-INF\下建立web.xml文件：
  <?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
 
  <taglib>
    <taglib-uri>http://java.sun.com/jstl/fmt</taglib-uri>
    <taglib-location>/WEB-INF/fmt.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/fmt-rt</taglib-uri>
    <taglib-location>/WEB-INF/fmt-rt.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/core</taglib-uri>
    <taglib-location>/WEB-INF/c.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/core-rt</taglib-uri>
    <taglib-location>/WEB-INF/c-rt.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/sql</taglib-uri>
    <taglib-location>/WEB-INF/sql.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/sql-rt</taglib-uri>
    <taglib-location>/WEB-INF/sql-rt.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/x</taglib-uri>
    <taglib-location>/WEB-INF/x.tld</taglib-location>
</taglib>

<taglib>
    <taglib-uri>http://java.sun.com/jstl/x-rt</taglib-uri>
    <taglib-location>/WEB-INF/x-rt.tld</taglib-location>
</taglib>
</web-app>
6.建立一个名为test.jsp文件
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<%@ page contentType="text/html;charset=GB2312" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
<title>测试你的第一个使用到JSTL 的网页</title>
</head>
<body>
<c:out value="欢迎测试你的第一个使用到JSTL 的网页"/>
</br>你使用的浏览器是：</br>
<c:out value="${header['User-Agent']}"/>
<c:set var="a" value="David O'Davies" />
<c:out value="David O'Davies" escapeXml="true"/>
</body>
</html>

7.开启tomcat,进行调试，我的输出结果是

欢迎测试你的第一个使用到JSTL 的网页
你使用的浏览器是：
Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0) David O'Davies

注：如果你的tld文件个数为15个，在上面的web.xml中<taglib-location>中更改。

=======================================
相关文件,不但要知道它是用来干什么的(what),还要知道把它放在那里(where).相关文件放到哪里,如何进行注册与配置对与jstl,JNDI,servlet,javabeans.

WEB-INF\:包含

\lib目录
web.xml配置描述符文件
\classes目录
8个tld文件WEB-INF\lib\:所有的jar包文件,包括standard.jar和jstl.jarWEB-INF\classes\:Servlet和JavaBeans文件编译后类文件
=======================================

备注:
1: 如果没有配置web.xml的话就要使用 <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> .其中这个tld是在 standard.jar找到的..
而配置了web.xml就要把tld文件也放到WEB-INF/目录下指定了
2: 其实不升级1.1的jar包也是可以的,只要把<%@ taglib uri="http://java.sun.com/jstl/core" prefix='c'%>改成<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix='c'%> 注意core和core_rt的变动 就OK了.  大家使用前请看好版本

//success.jsp

<%@ page contentType="text/html;charset=Shift_JIS" session="true"
 isErrorPage="false" errorPage="err.jsp" %>

//a  包含方法a
<!-- jsp:include page="logincheck.jsp" flush="true"/----> 

//b 包含方法b
<%@ include file="logincheck.jsp"%>
<html>
  <head>
    <title>Success.jsp</title>
  </head>
  <body>
    This is my JSP page. Success! <br>
    Welcome 
     <%
    out.print("SCHOOL : "+request.getAttribute("school")+"<br>");
    out.print("AGE : "+session.getAttribute("age")+"<br>");
    out.print("CITY : "+application.getAttribute("city")+"<br>");
    %>
  </body>
    <A  href="logout.jsp">ログ アウト</A>
</html>

 我将文件的包含方式和文件的调转方式作了组合测试。

结果如下

--------------------------------------------------

包含方法  |   跳转方法      |   结果

-------------------------------------------------

    a           |      1                |      注1

------------------------------------------------

------------------------------------------------

   a            |      2               |      注2

------------------------------------------------

------------------------------------------------

注1

不做任何调转

注2

只有将

<jsp:include page="logincheck.jsp" flush="true"/> 

放在代码的第一行才可以。

否则

java.lang.IllegalStateException: Cannot forward after response has been committed at org.apache.catalina.core.ApplicationDispatcher.doForward

日文环境

java.lang.IllegalStateException: レスポンスをコミットした后でフォワードできません at org.apache.catalina.core.ApplicationDispatcher.doForward(ApplicationDispatcher.java:324) at

这个错误往往是在forward执行之前，response已经返回了！

不明的原因！有空上网上再找找！

4: 修改HTTP header的Location属性来重定向
　　通过设置直接修改地址栏来实现页面的重定向。
　　jsp文件代码如下：
　　＜%
　　response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
　　String newLocn = "/newpath/jsa.jsp";
　　response.setHeader("Location",newLocn);
　　%＞
　　5.JSP中实现在某页面停留若干秒后,自动重定向到另一页面
　　在html文件中，下面的代码：
　　<meta http-equiv="refresh" content="300; url=target.jsp">
　　它的含义：在5分钟之后正在浏览的页面将会自动变为target.html这一页。代码中300为刷新的延迟时间，以秒为单位。targer.html为你想转向的目标页,若为本页则为自动刷新本页。
　　由上可知，可以通过setHeader来实现某页面停留若干秒后,自动重定向到另一页面。
　　关键代码：
　　String content=stayTime+";URL="+URL;
　　response.setHeader("REFRESH",content);
　　如果总结得不够全面，请各位发表自己的意见或经验。

           jsp页面中添加如下代码：
          <%
     response.setContentType("application/x-download");//设置为下载application/x-download
     String filedownload = "/要下载的文件名";//即将下载的文件的相对路径
     String filedisplay = "最终要显示给用户的保存文件名";//下载文件时显示的文件保存名称
     filenamedisplay = URLEncoder.encode(filedisplay,"UTF-8");
     response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);
    
     try
     {
         RequestDispatcher dis = application.getRequestDispatcher(filedownload);
         if(dis!= null)
         {
             dis.forward(request,response);
         }
         response.flushBuffer();
     }
     catch(Exception e)
     {
         e.printStackTrace();
     }
     finally
     {
    
     }
%>

2、采用文件流输出的方式下载

        <%@page language="java" contentType="application/x-msdownload"   pageEncoding="gb2312"%><%
     //关于文件下载时采用文件流输出的方式处理：
     //加上response.reset()，并且所有的％>后面不要换行，包括最后一个；

     response.reset();//可以加也可以不加
     response.setContentType("application/x-download");
     String filedownload = "想办法找到要提供下载的文件的物理路径＋文件名";
     String filedisplay = "给用户提供的下载文件名";
     filedisplay = URLEncoder.encode(filedisplay,"UTF-8");
     response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);

     OutputStream outp = null;
     FileInputStream in = null;
     try
     {
         outp = response.getOutputStream();
         in = new FileInputStream(filenamedownload);

         byte[] b = new byte[1024];
         int i = 0;

         while((i = in.read(b)) > 0)
         {
             outp.write(b, 0, i);
         }
         outp.flush();
     }
     catch(Exception e)
     {
         System.out.println("Error!");
         e.printStackTrace();
     }
     finally
     {
         if(in != null)
         {
             in.close();
             in = null;
         }
         if(outp != null)
         {
             outp.close();
             outp = null;
         }
     }
%>