import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.log4j.Logger;

import com.sinosoft.platform.handup.business.submitcapture.service.CaptureServiceImpl;
import com.sinosoft.platform.handup.utils.HandupInitialiser.Handup;

import sun.net.TelnetOutputStream;
import sun.net.TelnetInputStream;
import sun.net.ftp.FtpClient;

/**
 * FTP文件服务器上传,下载,删除操作
 * @author hejianke83
 *
 */
public class FtpClientUtil{

    String localfilename;
    String remotefilename;
    FtpClient ftpClient;

    /**
     * @param ip 服务器名字
     * @param port 端口
     * @param user 用户名
     * @param password 密码
     * @param path 服务器上的路径
     */
    public void connectServer(String ip, int port, String user,
            String password, String path){

        try {
            ftpClient = new FtpClient();
            ftpClient.openServer(ip, port);
            ftpClient.login(user, password);
            System.out.println("login success!");
            if (path.length() != 0)
                ftpClient.cd(path);
            ftpClient.binary();
        } catch (IOException ex){
            System.out.println("not login");
            System.out.println(ex);
        }
    }

    public void closeConnect() {
        try {
            ftpClient.closeServer();
            System.out.println("disconnect success");
        } catch (IOException ex) {
            System.out.println("not disconnect");
            System.out.println(ex);
        }
    }

    public void upload() {

        this.localfilename = "D://1.txt";
        this.remotefilename = "test2.txt";

        try {
            TelnetOutputStream os = ftpClient.put(this.remotefilename);
            java.io.File file_in = new java.io.File(this.localfilename);
            FileInputStream is = new FileInputStream(file_in);
            byte[] bytes = new byte[1024];
            int c;
            while ((c = is.read(bytes)) != -1) {
                os.write(bytes, 0, c);
            }
            System.out.println("upload success");
            is.close();
            os.close();
        } catch (IOException ex) {
            System.out.println("not upload");
            System.out.println(ex);
        }
    }

    public void download() {

        try {
            TelnetInputStream is = ftpClient.get(this.remotefilename);
            java.io.File file_in = new java.io.File(this.localfilename);
            FileOutputStream os = new FileOutputStream(file_in);
            byte[] bytes = new byte[1024];
            int c;
            while ((c = is.read(bytes)) != -1) {
                // System.out.println((char)is.read());
                // System.out.println(file_in);
                os.write(bytes, 0, c);
            }

            System.out.println("download success");
            os.close();
            is.close();
        } catch (IOException ex) {
            System.out.println("not download");
            System.out.println(ex);
        }
    }

    public void download(String remotePath, String remoteFile, String localFile) {

        try {
            if (remotePath.length() != 0)
                ftpClient.cd(remotePath);
            TelnetInputStream is = ftpClient.get(remoteFile);
            java.io.File file_in = new java.io.File(localFile);
            FileOutputStream os = new FileOutputStream(file_in);
            byte[] bytes = new byte[1024];
            int c;
            while ((c = is.read(bytes)) != -1) {
                // System.out.println((char)is.read());
                // System.out.println(file_in);
                os.write(bytes, 0, c);
            }

            System.out.println("download success");
            os.close();
            is.close();
        } catch (IOException ex) {
            System.out.println("not download");
            System.out.println(ex);
        }
    }

    public void download(String remoteFile, String localFile) {

        try {
            TelnetInputStream is = ftpClient.get(remoteFile);
            java.io.File file_in = new java.io.File(localFile);
            FileOutputStream os = new FileOutputStream(file_in);
            byte[] bytes = new byte[1024];
            int c;
            while ((c = is.read(bytes)) != -1) {
                // System.out.println((char)is.read());
                // System.out.println(file_in);
                os.write(bytes, 0, c);
            }

            System.out.println("download success");
            os.close();
            is.close();
        } catch (IOException ex) {
            System.out.println("not download");
            System.out.println(ex);
        }
    }
    public void delete_file(FtpClientUtil fu,String url) throws Exception {
     fu.ftpClient.sendServer("DELE "+url+"\r\n");
     int status = fu.ftpClient.readServerResponse();
     System.out.print("ftp delete file status:"+status);
     if(status == 250){
      System.out.println("  成功删除FTP服务器中文件");
     }
    }
   
    public static void main(String agrs[]) {

//      String filepath[] = { "/callcenter/index.jsp"};
//      String localfilepath[] = { "C:\FTP_Test\index.jsp"};
       
        FtpClientUtil fu = new FtpClientUtil();
        String url = Handup.getPropertie(Constants.PropertyKeys.FTP_SERVER_URL);
        String username = Handup.getPropertie(Constants.PropertyKeys.FTP_USERNAME);
        String password = Handup.getPropertie(Constants.PropertyKeys.FTP_PASSWORD);
//      fu.connectServer(url, 21, username,password,"");
        fu.connectServer("192.168.1.9", 21, "root","sinosoft","");

        try{
         //System.out.print(fu.ftpClient.welcomeMsg);
         fu.ftpClient.sendServer("DELE 博硕士论文/2008/10611/20208/测试上传_20080904525964/Div+CSS布局入门教程.chm\r\n");   //删除服务器上的文件
         System.out.println(fu.ftpClient.readServerResponse());
        }
        catch(Exception e)
        {
         e.printStackTrace();
        }
        //fu.upload();
        //fu.download();
        fu.closeConnect();

    }

 public FtpClient getFtpClient() {
  return ftpClient;
 }

 public void setFtpClient(FtpClient ftpClient) {
  this.ftpClient = ftpClient;
 }
}

1、 宽容

　　一只小猪、一只绵羊和一头乳牛，被关在同一个畜栏里。有一次，牧人捉住小猪，牠大声号叫，猛烈地抗拒。绵羊和乳牛讨厌牠的号叫，便说：「他常常捉我们，我们并不大呼小叫。小猪听了回答道：「捉你们和捉我完全是两回事，他捉你们，只是要你们的毛和乳汁，但是捉住我，却是要我的命呢!

　　立场不同、所处环境不同的人，很难了解对方的感受；因此对别人的失意、挫折、伤痛，不宜幸灾乐祸，而应要有关怀、了解的心情。要有宽容的心！

2、 靠自己

　　小蜗牛问妈妈：为什么我们从生下来，就要背负这个又硬又重的壳呢？

　　妈妈：因为我们的身体没有骨骼的支撑，只能爬，又爬不快。所以要这个壳的保护！

　　小蜗牛：毛虫姊姊没有骨头，也爬不快，为什么她却不用背这个又硬又重的壳呢？

　　妈妈：因为毛虫姊姊能变成蝴蝶，天空会保护她啊。

　　小蜗牛：可是蚯蚓弟弟也没骨头爬不快，也不会变成蝴蝶他什么不背这个又硬又重的壳呢？

　　妈妈：因为蚯蚓弟弟会钻土, 大地会保护他啊。

　　小蜗牛哭了起来：我们好可怜，天空不保护，大地也不保护。

　　蜗牛妈妈安慰他：「所以我们有壳啊！」

　　我们不靠天，也不靠地，我们靠自己。

3、 鲨鱼与鱼

　　曾有人做过实验，将一只最凶猛的鲨鱼和一群热带鱼放在同一个池子，然后用强化玻璃隔开，最初，鲨鱼每天不断冲撞那块看不到的玻璃，耐何这只是徒劳，它始终不能过到对面去，而实验人员每天都有放一些鲫鱼在池子里，所以鲨鱼也没缺少猎物，只是它仍想到对面去，想尝试那美丽的滋味，每天仍是不断的冲撞那块玻璃，它试了每个角落，每次都是用尽全力，但每次也总是弄的伤痕累累，有好几次都浑身破裂出血，持续了好一些日子，每当玻璃一出现裂痕，实验人员马上加上一块更厚的玻璃。

　　后来，鲨鱼不再冲撞那块玻璃了，对那些斑斓的热带鱼也不再在意，好像他们只是墙上会动的壁画，它开始等着每天固定会出现的鲫鱼，然后用他敏捷的本能进行狩猎，好像回到海中不可一世的凶狠霸气，但这一切只不过是假像罢了，实验到了最后的阶段，实验人员将玻璃取走，但鲨鱼却没有反应，每天仍是在固定的区域游着它不但对那些热带鱼视若无睹，甚至于当那些鲫鱼逃到那边去，他就立刻放弃追逐，说什么也不愿再过去，实验结束了，实验人员讥笑它是海里最懦弱的鱼。

　　可是失恋过的人都知道为什么，它怕痛。

4、 神迹

　　法国一个偏僻的小镇，据传有一个特别灵验的水泉，常会出现神迹，可以医治各种疾病。有一天，一个拄着拐杖，少了一条腿的退伍军人，一跛一跛的走过镇上的马路，旁边的镇民带着同情的回吻说："可怜的家伙，难道他要向上帝祈求再有一条腿吗??"这一句话被退伍的军人听到了，他转过身对他们说："我不是要向上帝祈求有一条新的腿，而是要祈求祂帮助我，叫我没有一条腿后，也知道如何过日子。"

　　试想：学习为所失去的感恩，也接纳失去的事实，不管人生的得与失，总是要让自已的生命充满了亮丽与光彩，不再为过去掉泪，努力的活出自己的生命。

5、 钓竿

　　有个老人在河边钓鱼，一个小孩走过去看他钓鱼，老人技巧纯熟，所以没多久就钓上了满篓的鱼，老人见小孩很可爱，要把整篓的鱼送给他，小孩摇摇头，老人惊异的问道：「你为何不要？」小孩回答：「我想要你手中的钓竿。」老人问：「你要钓竿做什么？」小孩说：「这篓鱼没多久就吃完了，要是我有钓竿，我就可以自己钓，一辈子也吃不完。」

　　我想你一定会说：好聪明的小孩。错了，他如果只要钓竿，那他一条鱼也吃不到。因为，他不懂钓鱼的技巧，光有鱼竿是没用的，因为钓鱼重要的不在"钓竿"，而在"钓技"。

　　有太多人认为自己拥有了人生道上的钓竿，再也无惧于路上的风雨，如此，难免会跌倒于泥泞地上。就如小孩看老人，以为只要有钓竿就有吃不完的鱼，像职员看老板，以为只要坐在办公室，就有滚进的财源。

package com.sinosoft.platform.handup.utils;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import com.lowagie.text.Document;
import com.lowagie.text.DocumentException;
import com.lowagie.text.Font;
import com.lowagie.text.PageSize;
import com.lowagie.text.Paragraph;
import com.lowagie.text.Rectangle;
import com.lowagie.text.pdf.BaseFont;
import com.lowagie.text.pdf.PdfPCell;
import com.lowagie.text.pdf.PdfPTable;

import com.lowagie.text.pdf.PdfWriter;
import com.sinosoft.platform.handup.pojo.SubmitCapture;
import com.sinosoft.platform.handup.utils.HandupInitialiser.Handup;
/**
 * 自动生成PDF授权书
 * @author heguanhua
 *
 */
public class CreatePdfUtil {

 public static String createPDF(String file_url,String filename,SubmitCapture sc){
  
  //授权书存放路径
  filename = file_url+filename+"_"+Handup.getPropertie(Constants.PropertyKeys.GRANT_FILE_NAME)+".pdf";
  
  //创建一个文档对象
  Rectangle pageSize = new Rectangle(PageSize.A4);
        Document doc=new Document(pageSize);
       
        try {
        //定义输出位置并把文档对象装入输出对象中
           PdfWriter.getInstance(doc, new FileOutputStream(filename));
           BaseFont bfChinese = null;
  try {
   //设置授权书支持的中文编码
   bfChinese = BaseFont.createFont("STSong-Light", "UniGB-UCS2-H", BaseFont.NOT_EMBEDDED);
  } catch (IOException e) {
   e.printStackTrace();
  }
    //设置授权书中的中文字体
           Font FontChinese = new Font(bfChinese, 12, Font.NORMAL);

            //打开文档对象
            doc.open();
           
           
            // 加入文字
            doc.add(new Paragraph("                                                                                " +
              "       授权书",new Font(bfChinese, 12, Font.BOLD)));
            doc.add(new Paragraph(" "));
            doc.add(new Paragraph(" "));                                                                             
            doc.addAuthor(sc.getAuthor());
            doc.addTitle("授权书");
 
            //创建一个3列16行的表格
            float[] widths = {0.2f,0.4f,0.4f};
            PdfPTable table = new PdfPTable(3);
          
            //设置table每一列的宽度，widths里写的是百分比，他们加和需要是1
            table.setWidths(widths);
            //设置表格在页面上的宽度，设成100表示可以表格填满页面，但是要去掉页面margin
            table.setWidthPercentage(100);
            //设置表格上端的空白距离，类似css中的margin-top:xxpx;这样在给表格加上标题后，标题就不会跟表格重叠在一起了。
            table.setSpacingBefore(3f);
            //设置表格边框未空白
            table.getDefaultCell().setBorder(Rectangle.NO_BORDER);
           

            //每截为1行三列
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("中文题目:",FontChinese));
            table.addCell(new Paragraph(sc.getTitlecn(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("作者姓名:",FontChinese));
            table.addCell(new Paragraph(sc.getAuthor(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("导师姓名:",FontChinese));
            table.addCell(new Paragraph(sc.getTutor(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("学位级别:",FontChinese));
            table.addCell(new Paragraph(sc.getDegree(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("研究生学号:",FontChinese));
            table.addCell(sc.getUser_sno());
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("学位授予单位:",FontChinese));
            table.addCell(new Paragraph(sc.getConfercompany(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("学位授予时间:",FontChinese));
            table.addCell(sc.getConfertime());
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("学科专业:",FontChinese));
            table.addCell(new Paragraph(sc.getSubject(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("研究方向:",FontChinese));
            table.addCell(new Paragraph(sc.getReinto(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("科研成果:",FontChinese));
            table.addCell(new Paragraph(sc.getResults(),FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("时间授权:",FontChinese));
            table.addCell(new Paragraph("O 1年     O 3年     O 5年     O 7年     O 10年" +
              "   O 不开放  O 立即开放",FontChinese));
           
            table.addCell(new Paragraph(""));
            table.addCell(new Paragraph("空间授权:",FontChinese));
            table.addCell(new Paragraph("O 校内    O 互联网",FontChinese));
            

            table.addCell(new Paragraph("签名：_____________________",FontChinese));
             
            //分列
            table.addCell(new Paragraph(""));
            PdfPCell sign = new PdfPCell(); 
            sign.setColspan(2);
            sign.addElement(new Paragraph("授权书的邮寄方式： 通过邮局邮寄到国家图书馆",FontChinese));
            sign.setBorder(Rectangle.NO_BORDER);
            table.addCell(sign);

            table.addCell(new Paragraph(""));
            sign = new PdfPCell();
            sign.setColspan(2);
            sign.addElement(new Paragraph("授权书的邮寄地址： 北京市海淀区国家图书馆1号",FontChinese));
            sign.setBorder(Rectangle.NO_BORDER);
            table.addCell(sign);
           
            //doc.add(new Paragraph("我的授权书", FontFactory.getFont(FontFactory.HELVETICA, 12, Font.BOLD, new Color(0, 0, 0))));
            //由于设置了table.setSpacingBefore(3f);所以table跟标题不会重合。
 
            //把表格内容添加到PDF文件中
            doc.add(table);

         // 关闭文档对象，释放资源
            doc.close();           

       } catch (FileNotFoundException e) {

           e.printStackTrace();
       } catch (DocumentException e) {

           e.printStackTrace();
       }

        
  return filename;
 }
}

public class LobFactory {

 private static Connection con;
 String clobValue = null; //表的CLOB字段值
 
 /**
  * 创建数据库连接
  * @return
  * @throws SQLException
  * @throws ClassNotFoundException
  */
 public static Connection getConnection() throws SQLException,ClassNotFoundException {

  Class.forName("oracle.jdbc.driver.OracleDriver");

  con = DriverManager.getConnection("jdbc:oracle:thin:@192.168.1.88:1521:ORCL","handup","handup");

  return con;

 }

 /**
  * 读取CLOB字段值
  * @param serialno
  * @param table_name
  * @param Clob_value
  * @return
  * @throws SQLException
  * @throws IOException
  */
 public static List read(BigDecimal serialno,String table_name) throws SQLException,IOException {
  
  String rtn = null;
  String c_name = null;
  
  List rtnlist = new ArrayList();
  try {
   String sql = "SELECT resource_clob.serialno,resource_clob.c_name"
   +",resource_clob.c_value from resource_clob where resource_clob.serialno = "+serialno
   +"and resource_clob.table_name = '"+table_name+ "'";
   con = getConnection();
   PreparedStatement pstmt = con.prepareStatement(sql);
   ResultSet rs = pstmt.executeQuery();
   java.sql.Clob clob = null;
   while(rs.next()) {
    HashMap map = new HashMap();
    clob = rs.getClob("C_VALUE");   
    rtn=clob.getSubString((long)1,(int)clob.length());   
    c_name = rs.getString("C_NAME");
    map.put("Serialno", serialno);
    map.put("C_NAME", c_name);
    map.put("C_VALUE", rtn);
//    System.out.println("serialno :"+serialno+"  c_name:"+c_name);
//    System.out.println("c_value :"+rtn);
    rtnlist.add(map);
   }
   rs.close();
   pstmt.close();

  }catch (SQLException e){
   throw e;
  }catch (Exception ee) {
   ee.printStackTrace();
  }
//  System.out.println("----------"+rtn);
  
  con.close();
  return rtnlist;
 }
 
 
 /**
  * 更新对clob字段值的持久化
  * @param content
  * @param lob_table
  * @param serialno
  * @param Clob_value
  * @param table_name
  * @throws SQLException
  * @throws IOException
  * @throws ClassNotFoundException
  */
 public static boolean update(String content,String lob_table,BigDecimal serialno,
   String Clob_value,String table_name) throws SQLException,IOException,
   ClassNotFoundException {

  String sql = "update " + lob_table + " set c_value =empty_clob() "
   +"where serialno =" + serialno +" and c_name='"+Clob_value+"'";

  con = getConnection();
  con.setAutoCommit(false);
  PreparedStatement pstmt = con.prepareStatement(sql);
  pstmt.executeUpdate();
  sql = "select c_value from " + lob_table + " where  serialno =" + serialno +" and c_name='"+Clob_value+"'";

  Statement st = con.createStatement();

  ResultSet rs = st.executeQuery(sql);

  java.sql.Clob clob ;
  boolean isInsert = false;
  if (rs.next()) {
   isInsert = true;
   clob = ((OracleResultSet)rs).getClob("C_VALUE");
   oracle.sql.CLOB my_clob = (CLOB)clob;
   
 //  clob = ((org.apache.commons.dbcp.DelegatingResultSet)rs).getClob(fieldName);
 //  OutputStream writer = my_clob.getAsciiOutputStream();
 //  byte[] contentStr = content.getBytes();
 //  writer.write(contentStr);
 
   java.io.Writer writer = my_clob.getCharacterOutputStream();
         writer.write(content);
 
   
   writer.flush();
 
   writer.close();

  }
  
  con.commit();
  rs.close();
  st.close();
  pstmt.close();
  con.setAutoCommit(true);
  con.close();
  return isInsert;
  }

 /**
  * 实现对clob字段值的持久化
  * @param content
  * @param lob_table
  * @param serialno
  * @param Clob_value
  * @param table_name
  * @throws SQLException
  * @throws IOException
  * @throws ClassNotFoundException
  */
 public static void write(String content,String lob_table,BigDecimal serialno,
   Integer c_no,String c_name,String table_name,Integer multiply,Integer multiply_id) throws SQLException,IOException,
   ClassNotFoundException {
  
  String sql = "INSERT INTO " + lob_table + "(SERIALNO,TABLE_NAME,C_NO,C_NAME,C_VALUE,MULTIPLY,MULTIPLY_ID)"
   +" VALUES(?,?,?,?,?,?,?)";
  
  con = getConnection();
  con.setAutoCommit(false);
  PreparedStatement pstmt = con.prepareStatement(sql);
  pstmt.setBigDecimal(1, serialno);
  pstmt.setString(2, table_name);
  pstmt.setInt(3, c_no);
  pstmt.setString(4, c_name);
  pstmt.setString(5, "empty_clob()");
  pstmt.setInt(6, multiply);
  pstmt.setInt(7, multiply_id);
  pstmt.execute();
  sql = "select c_value from " + lob_table + " where  serialno =" + serialno +" and c_name='"+c_name+"'";

  Statement st = con.createStatement();
  ResultSet rs = st.executeQuery(sql);
  java.sql.Clob clob ;

  if (rs.next()) {

   clob = ((OracleResultSet)rs).getClob("C_VALUE");
   oracle.sql.CLOB my_clob = (CLOB)clob;
   
 //  clob = ((org.apache.commons.dbcp.DelegatingResultSet)rs).getClob(fieldName);
 //  OutputStream writer = my_clob.getAsciiOutputStream();
 //  byte[] contentStr = content.getBytes();
 //  writer.write(contentStr);
 
   java.io.Writer writer = my_clob.getCharacterOutputStream();
         writer.write(content);
   
   writer.flush();
   writer.close();
  }
  con.commit();
  rs.close();
  st.close();
  pstmt.close();
  con.setAutoCommit(true);
  con.close();
  }
}

代码测试过,已经能够正常使用,欢迎提意见和建议!

锁机制

当前MySQL已经支持 ISAM, MyISAM, MEMORY (HEAP) 类型表的表级锁了，BDB 表支持页级锁，InnoDB 表支持行级锁。

很多时候，可以通过经验来猜测什么样的锁对应用程序更合适，不过通常很难说一个锁比别的更好，这全都要依据应用程序来决定，不同的地方可能需要不同的锁。

想要决定是否需要采用一个支持行级锁的存储引擎，就要看看应用程序都要做什么，其中的查询、更新语句是怎么用的。例如，很多的web应用程序大量的做查询，很少删除，主要是基于索引的更新，只往特定的表中插入记录。采用基本的MySQL MyISAM 表就很合适了。

MySQL中对表级锁的存储引擎来说是释放死锁的。避免死锁可以这样做到：在任何查询之前先请求锁，并且按照请求的顺序锁表。

MySQL中用于 WRITE（写） 的表锁的实现机制如下：

如果表没有加锁，那么就加一个写锁。

否则的话，将请求放到写锁队列中。

MySQL中用于 READ（读） 的表锁的实现机制如下：

如果表没有加写锁，那么就加一个读锁。

否则的话，将请求放到读锁队列中。

当锁释放后，写锁队列中的线程可以用这个锁资源，然后才轮到读锁队列中的线程。

这就是说，如果表里有很多更新操作的话，那么 SELECT 必须等到所有的更新都完成了之后才能开始。

从 MySQL 3.23.33 开始，可以通过状态变量 Table_locks_waited 和 Table_locks_immediate 来分析系统中的锁表争夺情况：

mysql> SHOW STATUS LIKE 'Table%';

+-----------------------+---------+

| Variable_name | Value |

+-----------------------+---------+

| Table_locks_immediate | 1151552 |

| Table_locks_waited | 15324 |

+-----------------------+---------+

在 MySQL 3.23.7（在Windows上是3.23.25）以后，在 MyISAM 表中只要没有冲突的 INSERT 操作，就可以无需使用锁表自由地并行执行 INSERT 和 SELECT 语句。也就是说，可以在其它客户端正在读取 MyISAM 表记录的同时时插入新记录。如果数据文件的中间没有空余的磁盘块的话，就不会发生冲突了，因为这种情况下所有的新记录都会写在数据文件的末尾（当在表的中 间做删除或者更新操作时，就可能导致空洞）。当空洞被新数据填充后，并行插入特性就会自动重新被启用了。

如果想要在一个表上做大量的 INSERT 和 SELECT 操作，但是并行的插入却不可能时，可以将记录插入到临时表中，然后定期将临时表中的数据更新到实际的表里。可以用以下命令实现：

mysql> LOCK TABLES real_table WRITE, insert_table WRITE;

mysql> INSERT INTO real_table SELECT * FROM insert_table;

mysql> TRUNCATE TABLE insert_table;

mysql> UNLOCK TABLES;

InnoDB 使用行级锁，BDB 使用页级锁。对于 InnoDB 和 BDB 存储引擎来说，是可能产生死锁的。这是因为 InnoDB 会自动捕获行锁，BDB 会在执行 SQL 语句时捕获页锁的，而不是在事务的开始就这么做。

行级锁的优点有：

在很多线程请求不同记录时减少冲突锁。

事务回滚时减少改变数据。

使长时间对单独的一行记录加锁成为可能。

行级锁的缺点有：

比页级锁和表级锁消耗更多的内存。

当在大量表中使用时，比页级锁和表级锁更慢，因为他需要请求更多的所资源。

当需要频繁对大部分数据做 GROUP BY 操作或者需要频繁扫描整个表时，就明显的比其它锁更糟糕。

使用更高层的锁的话，就能更方便的支持各种不同的类型应用程序，因为这种锁的开销比行级锁小多了。

表级锁在下列几种情况下比页级锁和行级锁更优越：

很多操作都是读表。

在严格条件的索引上读取和更新，当更新或者删除可以用单独的索引来读取得到时：

UPDATE tbl_name SET column=value WHERE unique_key_col=key_value;

DELETE FROM tbl_name WHERE unique_key_col=key_value;

SELECT 和 INSERT 语句并发的执行，但是只有很少的 UPDATE 和 DELETE 语句。

很多的扫描表和对全表的 GROUP BY 操作，但是没有任何写表。

表级锁和行级锁或页级锁之间的不同之处还在于：

将同时有一个写和多个读的地方做版本（例如在MySQL中的并发插入）。也就是说，数据库/表支持根据开始访问数据时间点的不同支持各种不同的试图。其它名有：时间行程，写复制，或者是按需复制。

原文： Versioning (such as we use in MySQL for concurrent inserts) where you can have one writer at the same time as many readers. This means that the database/table supports different views for the data depending on when you started to access it. Other names for this are time travel, copy on write, or copy on demand.

按需复制在很多情况下比页级锁或行级锁好多了。尽管如此，最坏情况时还是比其它正常锁使用了更多的内存。

可以用应用程序级锁来代替行级锁，例如MySQL中的 GET_LOCK() 和 RELEASE_LOCK()。但它们是劝告锁（原文：These are advisory locks），因此只能用于安全可信的应用程序中。

7.3.2 锁表

为了能有快速的锁，MySQL除了 InnoDB 和 BDB 这两种存储引擎外，所有的都是用表级锁（而非页、行、列级锁）。

对于 InnoDB 和 BDB 表，MySQL只有在指定用 LOCK TABLES 锁表时才使用表级锁。在这两种表中，建议最好不要使用 LOCK TABLES，因为 InnoDB 自动采用行级锁，BDB 用页级锁来保证事务的隔离。

如果数据表很大，那么在大多数应用中表级锁会比行级锁好多了，不过这有一些陷阱。

表级锁让很多线程可以同时从数据表中读取数据，但是如果另一个线程想要写数据的话，就必须要先取得排他访问。正在更新数据时，必须要等到更新完成了，其他线程才能访问这个表。

更新操作通常认为比读取更重要，因此它的优先级更高。不过最好要先确认，数据表是否有很高的 SELECT 操作，而更新操作并非很‘急需’。

表锁锁在一个线程在等待，因为磁盘空间满了，但是却需要有空余的磁盘空间，这个线程才能继续处理时就有问题了。这种情况下，所有要访问这个出问题的表的线程都会被置为等待状态，直到有剩余磁盘空间了。

表锁在以下设想情况中就不利了：

一个客户端提交了一个需要长时间运行的 SELECT 操作。

其他客户端对同一个表提交了 UPDATE 操作，这个客户端就要等到 SELECT 完成了才能开始执行。

其他客户端也对同一个表提交了 SELECT 请求。由于 UPDATE 的优先级高于 SELECT，所以 SELECT 就会先等到 UPDATE 完成了之后才开始执行，它也在等待第一个 SELECT 操作。

下列所述可以减少表锁带来的资源争夺：

让 SELECT 速度尽量快，这可能需要创建一些摘要表。

启动 mysqld 时使用参数 --low-priority-updates。这就会让更新操作的优先级低于 SELECT。这种情况下，在上面的假设中，第二个 SELECT 就会在 INSERT 之前执行了，而且也无需等待第一个SELECT 了。

可以执行 SET LOW_PRIORITY_UPDATES=1 命令，指定所有的更新操作都放到一个指定的链接中去完成。详情请看“14.5.3.1 SET Syntax”。

用 LOW_PRIORITY 属性来降低 INSERT，UPDATE，DELETE 的优先级。

用 HIGH_PRIORITY 来提高 SELECT 语句的优先级。详情请看“14.1.7 SELECT Syntax”。

从MySQL 3.23.7 开始，可以在启动 mysqld 时指定系统变量 max_write_lock_count 为一个比较低的值，它能强制临时地提高表的插入数达到一个特定值后的所有 SELECT 操作的优先级。它允许在 WRITE 锁达到一定数量后有 READ 锁。

当 INSERT 和 SELECT 一起使用出现问题时，可以转而采用 MyISAM 表，它支持并发的SELECT 和 INSERT 操作。

当在同一个表上同时有插入和删除操作时，INSERT DELAYED 可能会很有用。详情请看“14.1.4.2 INSERT DELAYED Syntax”。

当 SELECT 和 DELETE 一起使用出现问题时，DELETE 的 LIMIT 参数可能会很有用。详情请看“14.1.1 DELETE Syntax”

执行 SELECT 时使用 SQL_BUFFER_RESULT 有助于减短锁表的持续时间.详情请看“14.1.7 SELECT Syntax”。

可以修改源代码 `mysys/thr_lock.c'，只用一个所队列。这种情况下，写锁和读锁的优先级就一样了，这对一些应用可能有帮助。

以下是MySQL锁的一些建议：

只要对同一个表没有大量的更新和查询操作混在一起，目前的用户并不是问题。

执行 LOCK TABLES 来提高速度（很多更新操作放在一个锁之中比没有锁的很多更新快多了）。将数据拆分开到多个表中可能也有帮助。

当MySQL碰到由于锁表引起的速度问题时，将表类型转换成 InnoDB 或 BDB 可能有助于提高性能。详情请看“16 The InnoDB Storage Engine”和“15.4 The BDB (BerkeleyDB) Storage Engine”。

修改表结构：

ALTER TABLE history add norenewdays int default 0;

alter TABLE history modify norenewdays int default 0;

alter table infos add ex tinyint not null default '0';

近日在做web呼叫的时候碰到JS跨域问题，需与华为的服务器交互，用户提交客户号和验证码后，到华为的服务器上去验证用户信息，然后返回用户信息给我们的网页，直接用ajax访问在IE上有安全提示问题，用户信息可返回，调低安全级别可实现，但作为门户网站，让客户去适应我们的要求，这种方法是不可行的，参考了网上一篇“服务器端可控情形JS跨域访问解决方法”，这位老大写了个大概，对我这种低手来说仍然是有点不清不楚的，经过一天痛苦的摸索之后，用动态脚本的方式实现了跨域的解决，现把代码记录下来，以便今后查看。

我启了两个服务，分别是tomcat和weblogic。用tomcat的工程模拟本地，weblogic的工程模拟远程。

先在本地的页面中这样做

java 代码

1. function transTest(){   
2.     var username = document.form1.username.value;   
3.     var email = escape(document.form1.email.value);   
4.     var url = "http://10.13.78.95:7001/finprog/registerCheckUserByAjax.do?username="+username+"&email="+email;   
5.     url = encodeURI(url);    
6.        
7.     var js_obj = document.createElement( "script" );    
8.     js_obj.type = "text/javascript";    
9. js_obj.setAttribute( "src" , url);    
10. document.body.appendChild(js_obj);   
11. }   
12.   
13. function onServerResponse(responseText){   
14.     alert(responseText);   
15.     var message = document.getElementById("message");   
16.     if(message.hasChildNodes()){   
17.             message.removeChild(message.childNodes[0]);   
18.     }   
19.     var messagenode=document.createTextNode(responseText);//??????   
20.     message.appendChild(messagenode);   
21.        
22. }  

上面jsp页面中，执行transTest()方法后，document.createElement( "script" ); 会动态的在页面中生成一段script脚本，然后在脚本中，绕过IE的安全验证，js_obj.setArrribute() 将信息作为 src 的 url 参数提交给了远程servlet，(用的.do请求，名字是finprog工程里的一个servlet，我懒，不想新写)。

在registerCheckUserByAjax.do中的最末，我返回给建立通信的jsp页面以信息，代码如下：

java 代码

1. UserInfoDTO userinfoDTO = (UserInfoDTO) serviceModel.get("userinfoDTO");   
2.         String responseText;   
3.         if(userinfoDTO==null){   
4.             responseText="成功";   
5.         }else if (userinfoDTO.getUserName().equals(username) && userinfoDTO.getEmail().equals(email)) {   
6.             responseText="失败";   
7.         } else {   
8.             responseText="成功";   
9.         }   
10.         responseText = new String(responseText.getBytes(), "ISO-8859-1");   
11.         response.getWriter().println("var a='" + responseText + "';");    
12.         response.getWriter().println("onServerResponse(a); ");   

这里去调JSP页面中的onServerResponse()方法，回显信息给本地。 这样本地网页就会响应服务器结果，通过message节点把服务器端信息给回显出来，如果是中文要先编好码。

上面的方法我在IE和FireFox中都测过，大功告成。

另外参考网上的解决方法，还可以用本地代理页面，涉及到配置Apache的问题，看得我头昏，我想到了一些解决方法，用一个本地的servlet，在JS提交的时候，提交到本地servlet，然后本地servlet去请求远程servlet，至于怎么建立通信传值，可以这样，在远程servlet中再请求本地的servlet，这时本地servlet对于远程来说，也变成服务器端了，本地再response回给JSP,这是个笨办法。不过没试过。另外，可以用socket方案，不过对于我们公司的层层防火墙是个考验，还有可以在本地存放一个临时页面，用HttpURLConnection con = (HttpURLConnection)url.openConnection();   

与远程建立连接，不过也没试过。暂时没有精力去搞了。

引用来自：http://jeromefeng.javaeye.com/blog/41691

基于Java的全文索引/检索引擎——Lucene

Lucene不是一个完整的全文索引应用，而是是一个用Java写的全文索引引擎工具包，它可以方便的嵌入到各种应用中实现针对应用的全文索引/检索功能。

Lucene的作者：Lucene的贡献者Doug Cutting是一位资深全文索引/检索专家，曾经是V-Twin搜索引擎(Apple的Copland操作系统的成就之一)的主要开发者，后在Excite担任高级系统架构设计师，目前从事于一些INTERNET底层架构的研究。他贡献出的Lucene的目标是为各种中小型应用程序加入全文检索功能。

Lucene的发展历程：早先发布在作者自己的www.lucene.com，后来发布在SourceForge，2001年年底成为APACHE基金会jakarta的一个子项目：http://jakarta.apache.org/lucene/

已经有很多Java项目都使用了Lucene作为其后台的全文索引引擎，比较著名的有：

• Jive：WEB论坛系统；
• Eyebrows：邮件列表HTML归档/浏览/查询系统，本文的主要参考文档“TheLucene search engine: Powerful, flexible, and free”作者就是EyeBrows系统的主要开发者之一，而EyeBrows已经成为目前APACHE项目的主要邮件列表归档系统。
• Cocoon:基于XML的web发布框架，全文检索部分使用了Lucene

• Eclipse:基于Java的开放开发平台，帮助部分的全文索引使用了Lucene

对于中文用户来说，最关心的问题是其是否支持中文的全文检索。但通过后面对于Lucene的结构的介绍，你会了解到由于Lucene良好架构设计，对中文的支持只需对其语言词法分析接口进行扩展就能实现对中文检索的支持。

全文检索的实现机制

Lucene的API接口设计的比较通用，输入输出结构都很像数据库的表==>记录==>字段，所以很多传统的应用的文件、数据库等都可以比较方便的映射到Lucene的存储结构/接口中。总体上看：可以先把Lucene当成一个支持全文索引的数据库系统。

比较一下Lucene和数据库：

索引数据源：doc(field1,field2...) doc(field1,field2...)
                  \  indexer /
                 _____________
                | Lucene Index|
                --------------
                 / searcher \
 结果输出：Hits(doc(field1,field2) doc(field1...))

 索引数据源：record(field1,field2...) record(field1..)
              \  SQL: insert/
               _____________
              | DB  Index   |
               -------------
              / SQL: select \
结果输出：results(record(field1,field2..) record(field1...))

全文检索 ≠ like "%keyword%"

通常比较厚的书籍后面常常附关键词索引表（比如：北京：12, 34页，上海：3,77页……），它能够帮助读者比较快地找到相关内容的页码。而数据库索引能够大大提高查询的速度原理也是一样，想像一下通过书后面的索引查找的速度要比一页一页地翻内容高多少倍……而索引之所以效率高，另外一个原因是它是排好序的。对于检索系统来说核心是一个排序问题。

由于数据库索引不是为全文索引设计的，因此，使用like "%keyword%"时，数据库索引是不起作用的，在使用like查询时，搜索过程又变成类似于一页页翻书的遍历过程了，所以对于含有模糊查询的数据库服务来说，LIKE对性能的危害是极大的。如果是需要对多个关键词进行模糊匹配：like"%keyword1%" and like "%keyword2%" ...其效率也就可想而知了。

所以建立一个高效检索系统的关键是建立一个类似于科技索引一样的反向索引机制，将数据源（比如多篇文章）排序顺序存储的同时，有另外一个排好序的关键词列表，用于存储关键词==>文章映射关系，利用这样的映射关系索引：[关键词==>出现关键词的文章编号，出现次数（甚至包括位置：起始偏移量，结束偏移量），出现频率]，检索过程就是把模糊查询变成多个可以利用索引的精确查询的逻辑组合的过程。从而大大提高了多关键词查询的效率，所以，全文检索问题归结到最后是一个排序问题。

由此可以看出模糊查询相对数据库的精确查询是一个非常不确定的问题，这也是大部分数据库对全文检索支持有限的原因。Lucene最核心的特征是通过特殊的索引结构实现了传统数据库不擅长的全文索引机制，并提供了扩展接口，以方便针对不同应用的定制。

可以通过一下表格对比一下数据库的模糊查询：

全文检索和数据库应用最大的不同在于：让最相关的头100条结果满足98%以上用户的需求

Lucene的创新之处：

大部分的搜索（数据库）引擎都是用B树结构来维护索引，索引的更新会导致大量的IO操作，Lucene在实现中，对此稍微有所改进：不是维护一个索引文件，而是在扩展索引的时候不断创建新的索引文件，然后定期的把这些新的小索引文件合并到原先的大索引中（针对不同的更新策略，批次的大小可以调整），这样在不影响检索的效率的前提下，提高了索引的效率。

Lucene和其他一些全文检索系统/应用的比较：

关于亚洲语言的的切分词问题(Word Segment)

对于中文来说，全文索引首先还要解决一个语言分析的问题，对于英文来说，语句中单词之间是天然通过空格分开的，但亚洲语言的中日韩文语句中的字是一个字挨一个，所有，首先要把语句中按“词”进行索引的话，这个词如何切分出来就是一个很大的问题。

首先，肯定不能用单个字符作(si-gram)为索引单元，否则查“上海”时，不能让含有“海上”也匹配。

但一句话：“北京天安门”，计算机如何按照中文的语言习惯进行切分呢？
“北京 天安门” 还是“北 京 天安门”？让计算机能够按照语言习惯进行切分，往往需要机器有一个比较丰富的词库才能够比较准确的识别出语句中的单词。

另外一个解决的办法是采用自动切分算法：将单词按照2元语法(bigram)方式切分出来，比如：
"北京天安门" ==> "北京 京天 天安 安门"。

这样，在查询的时候，无论是查询"北京" 还是查询"天安门"，将查询词组按同样的规则进行切分："北京"，"天安安门"，多个关键词之间按与"and"的关系组合，同样能够正确地映射到相应的索引中。这种方式对于其他亚洲语言：韩文，日文都是通用的。

基于自动切分的最大优点是没有词表维护成本，实现简单，缺点是索引效率低，但对于中小型应用来说，基于2元语法的切分还是够用的。基于2元切分后的索引一般大小和源文件差不多，而对于英文，索引文件一般只有原文件的30%-40%不同，

目前比较大的搜索引擎的语言分析算法一般是基于以上2个机制的结合。关于中文的语言分析算法，大家可以在Google查关键词"wordsegment search"能找到更多相关的资料。

安装和使用

下载：http://jakarta.apache.org/lucene/

注意：Lucene中的一些比较复杂的词法分析是用JavaCC生成的（JavaCC：JavaCompilerCompiler，纯Java的词法分析生成器），所以如果从源代码编译或需要修改其中的QueryParser、定制自己的词法分析器，还需要从https://javacc.dev.java.net/下载javacc。

lucene的组成结构：对于外部应用来说索引模块(index)和检索模块(search)是主要的外部应用入口

简单的例子演示一下Lucene的使用方法：

public class IndexFiles { 
  //使用方法：: IndexFiles [索引输出目录] [索引的文件列表] ... 
  public static void main(String[] args) throws Exception {
    String indexPath = args[0];
    IndexWriter writer;
    //用指定的语言分析器构造一个新的写索引器（第3个参数表示是否为追加索引）
    writer = new IndexWriter(indexPath, new SimpleAnalyzer(), false);

    for (int i=1; i<args.length; i++) {
      System.out.println("Indexing file " + args[i]);
      InputStream is = new FileInputStream(args[i]);

      //构造包含2个字段Field的Document对象
      //一个是路径path字段，不索引，只存储
      //一个是内容body字段，进行全文索引，并存储
      Document doc = new Document();
      doc.add(Field.UnIndexed("path", args[i]));
      doc.add(Field.Text("body", (Reader) new InputStreamReader(is)));
      //将文档写入索引
      writer.addDocument(doc);
      is.close();
    };
    //关闭写索引器
    writer.close();
  }
}
　

索引过程中可以看到：

• 语言分析器提供了抽象的接口，因此语言分析(Analyser)是可以定制的，虽然lucene缺省提供了2个比较通用的分析器SimpleAnalyser和StandardAnalyser，这2个分析器缺省都不支持中文，所以要加入对中文语言的切分规则，需要修改这2个分析器。
• Lucene并没有规定数据源的格式，而只提供了一个通用的结构（Document对象）来接受索引的输入，因此输入的数据源可以是：数据库，WORD文档，PDF文档，HTML文档……只要能够设计相应的解析转换器将数据源构造成成Docuement对象即可进行索引。
• 对于大批量的数据索引，还可以通过调整IndexerWrite的文件合并频率属性（mergeFactor）来提高批量索引的效率。

检索过程和结果显示：

搜索结果返回的是Hits对象，可以通过它再访问Document==>Field中的内容。

假设根据body字段进行全文检索，可以将查询结果的path字段和相应查询的匹配度(score)打印出来，

public class Search { 
  public static void main(String[] args) throws Exception {
    String indexPath = args[0], queryString = args[1];
    //指向索引目录的搜索器
    Searcher searcher = new IndexSearcher(indexPath);
    //查询解析器：使用和索引同样的语言分析器
    Query query = QueryParser.parse(queryString, "body", 
                              new SimpleAnalyzer());
    //搜索结果使用Hits存储
    Hits hits = searcher.search(query);
    //通过hits可以访问到相应字段的数据和查询的匹配度
    for (int i=0; i<hits.length(); i++) {
      System.out.println(hits.doc(i).get("path") + "; Score: " + 
                         hits.score(i));
    };
  }
}

Hacking Lucene

简化的查询分析器

个人感觉lucene成为JAKARTA项目后，画在了太多的时间用于调试日趋复杂QueryParser，而其中大部分是大多数用户并不很熟悉的，目前LUCENE支持的语法：

Query ::= ( Clause )*
Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")")

中间的逻辑包括：and or + - &&||等符号，而且还有"短语查询"和针对西文的前缀/模糊查询等，个人感觉对于一般应用来说，这些功能有一些华而不实，其实能够实现目前类似于Google的查询语句分析功能其实对于大多数用户来说已经够了。所以，Lucene早期版本的QueryParser仍是比较好的选择。

添加修改删除指定记录（Document）

Lucene提供了索引的扩展机制，因此索引的动态扩展应该是没有问题的，而指定记录的修改也似乎只能通过记录的删除，然后重新加入实现。如何删除指定的记录呢？删除的方法也很简单，只是需要在索引时根据数据源中的记录ID专门另建索引，然后利用IndexReader.delete(Termterm)方法通过这个记录ID删除相应的Document。

根据某个字段值的排序功能

lucene缺省是按照自己的相关度算法（score）进行结果排序的，但能够根据其他字段进行结果排序是一个在LUCENE的开发邮件列表中经常提到的问题，很多原先基于数据库应用都需要除了基于匹配度（score）以外的排序功能。而从全文检索的原理我们可以了解到，任何不基于索引的搜索过程效率都会导致效率非常的低，如果基于其他字段的排序需要在搜索过程中访问存储字段，速度回大大降低，因此非常是不可取的。

但这里也有一个折中的解决方法：在搜索过程中能够影响排序结果的只有索引中已经存储的docID和score这2个参数，所以，基于score以外的排序，其实可以通过将数据源预先排好序，然后根据docID进行排序来实现。这样就避免了在LUCENE搜索结果外对结果再次进行排序和在搜索过程中访问不在索引中的某个字段值。

这里需要修改的是IndexSearcher中的HitCollector过程：

...
　scorer.score(new HitCollector() {
 private float minScore = 0.0f;
 public final void collect(int doc, float score) {
   if (score > 0.0f &&     // ignore zeroed buckets
       (bits==null || bits.get(doc))) {   // skip docs not in bits
     totalHits[0]++;
     if (score >= minScore) {
              /* 原先：Lucene将docID和相应的匹配度score例入结果命中列表中：
        * hq.put(new ScoreDoc(doc, score));   // update hit queue
               * 如果用doc 或 1/doc 代替 score，就实现了根据docID顺排或逆排
               * 假设数据源索引时已经按照某个字段排好了序，而结果根据docID排序也就实现了
               * 针对某个字段的排序，甚至可以实现更复杂的score和docID的拟合。
               */
              hq.put(new ScoreDoc(doc, (float) 1/doc )); 
       if (hq.size() > nDocs) {    // if hit queue overfull
  hq.pop();     // remove lowest in hit queue
  minScore = ((ScoreDoc)hq.top()).score; // reset minScore
       }
     }
   }
 }
      }, reader.maxDoc());

更通用的输入输出接口

虽然lucene没有定义一个确定的输入文档格式，但越来越多的人想到使用一个标准的中间格式作为Lucene的数据导入接口，然后其他数据，比如PDF只需要通过解析器转换成标准的中间格式就可以进行数据索引了。这个中间格式主要以XML为主，类似实现已经不下4，5个：

数据源: WORD       PDF     HTML    DB       other
         \          |       |      |         /
                       XML中间格式
                            |
                     Lucene INDEX

目前还没有针对MSWord文档的解析器，因为Word文档和基于ASCII的RTF文档不同，需要使用COM对象机制解析。这个是我在Google上查的相关资料：http://www.intrinsyc.com/products/enterprise_applications.asp
另外一个办法就是把Word文档转换成text：http://www.winfield.demon.nl/index.html

索引过程优化

索引一般分2种情况，一种是小批量的索引扩展，一种是大批量的索引重建。在索引过程中，并不是每次新的DOC加入进去索引都重新进行一次索引文件的写入操作（文件I/O是一件非常消耗资源的事情）。

Lucene先在内存中进行索引操作，并根据一定的批量进行文件的写入。这个批次的间隔越大，文件的写入次数越少，但占用内存会很多。反之占用内存少，但文件IO操作频繁，索引速度会很慢。在IndexWriter中有一个MERGE_FACTOR参数可以帮助你在构造索引器后根据应用环境的情况充分利用内存减少文件的操作。根据我的使用经验：缺省Indexer是每20条记录索引后写入一次，每将MERGE_FACTOR增加50倍，索引速度可以提高1倍左右。

搜索过程优化

lucene支持内存索引：这样的搜索比基于文件的I/O有数量级的速度提升。
http://www.onjava.com/lpt/a/3273
而尽可能减少IndexSearcher的创建和对搜索结果的前台的缓存也是必要的。

Lucene面向全文检索的优化在于首次索引检索后，并不把所有的记录（Document）具体内容读取出来，而起只将所有结果中匹配度最高的头100条结果（TopDocs）的ID放到结果集缓存中并返回，这里可以比较一下数据库检索：如果是一个10,000条的数据库检索结果集，数据库是一定要把所有记录内容都取得以后再开始返回给应用结果集的。所以即使检索匹配总数很多，Lucene的结果集占用的内存空间也不会很多。对于一般的模糊检索应用是用不到这么多的结果的，头100条已经可以满足90%以上的检索需求。

如果首批缓存结果数用完后还要读取更后面的结果时Searcher会再次检索并生成一个上次的搜索缓存数大1倍的缓存，并再重新向后抓取。所以如果构造一个Searcher去查1－120条结果，Searcher其实是进行了2次搜索过程：头100条取完后，缓存结果用完，Searcher重新检索再构造一个200条的结果缓存，依此类推，400条缓存，800条缓存。由于每次Searcher对象消失后，这些缓存也访问那不到了，你有可能想将结果记录缓存下来，缓存数尽量保证在100以下以充分利用首次的结果缓存，不让Lucene浪费多次检索，而且可以分级进行结果缓存。

Lucene的另外一个特点是在收集结果的过程中将匹配度低的结果自动过滤掉了。这也是和数据库应用需要将搜索的结果全部返回不同之处。

我的一些尝试：

• 支持中文的Tokenizer：这里有2个版本，一个是通过JavaCC生成的，对CJK部分按一个字符一个TOKEN索引，另外一个是从SimpleTokenizer改写的，对英文支持数字和字母TOKEN，对中文按迭代索引。
• 基于XML数据源的索引器：XMLIndexer，因此所有数据源只要能够按照DTD转换成指定的XML，就可以用XMLIndxer进行索引了。
• 根据某个字段排序：按记录索引顺序排序结果的搜索器：IndexOrderSearcher，因此如果需要让搜索结果根据某个字段排序，可以让数据源先按某个字段排好序（比如：PriceField），这样索引后，然后在利用这个按记录的ID顺序检索的搜索器，结果就是相当于是那个字段排序的结果了。

从Lucene学到更多

Luene的确是一个面对对象设计的典范

• 所有的问题都通过一个额外抽象层来方便以后的扩展和重用：你可以通过重新实现来达到自己的目的，而对其他模块而不需要；
• 简单的应用入口Searcher, Indexer，并调用底层一系列组件协同的完成搜索任务；
• 所有的对象的任务都非常专一：比如搜索过程：QueryParser分析将查询语句转换成一系列的精确查询的组合(Query),通过底层的索引读取结构IndexReader进行索引的读取，并用相应的打分器给搜索结果进行打分/排序等。所有的功能模块原子化程度非常高，因此可以通过重新实现而不需要修改其他模块。 
• 除了灵活的应用接口设计，Lucene还提供了一些适合大多数应用的语言分析器实现（SimpleAnalyser,StandardAnalyser），这也是新用户能够很快上手的重要原因之一。

这些优点都是非常值得在以后的开发中学习借鉴的。作为一个通用工具包，Lunece的确给予了需要将全文检索功能嵌入到应用中的开发者很多的便利。

此外，通过对Lucene的学习和使用，我也更深刻地理解了为什么很多数据库优化设计中要求，比如：

• 尽可能对字段进行索引来提高查询速度，但过多的索引会对数据库表的更新操作变慢，而对结果过多的排序条件，实际上往往也是性能的杀手之一。
• 很多商业数据库对大批量的数据插入操作会提供一些优化参数，这个作用和索引器的merge_factor的作用是类似的，
• 20%/80%原则：查的结果多并不等于质量好，尤其对于返回结果集很大，如何优化这头几十条结果的质量往往才是最重要的。
• 尽可能让应用从数据库中获得比较小的结果集，因为即使对于大型数据库，对结果集的随机访问也是一个非常消耗资源的操作。
  

      [wait(),notify()/notityAll()方法]

　　关于这两个方法,有很多的内容需要说明.在下面的说明中可能会有很多地方不能一下子明白,但在看完本节后,即使不能完全明白,你也一定要回过头来记住下面的两句话:

　　[wait(),notify()/notityAll()方法是普通对象的方法(Object超类中实现),而不是对象的方法]

　　[wait(),notify()/notityAll()方法只能在同步方法中调用]

　　[线程的互斥控制]

　　多个线程同时操作某一对象时,一个线程对该对象的操作可能会改变其状态,而该状态会影响另一线程对该对象的真正结果.

　　这个例子我们在太多的文档中可以看到,就象两个操售票员同时售出同一张票一样.

1.线程A在中查询存票,发现票C可以卖出   class="left"

2.线程A接受用户订票请求,准备出票.    

3.这时切换到了线程B执行  

4.线程B在数据库中查询存票,发现票C可以卖出  

5.线程B将票卖了出去

6.切换到线程A执行,线程A卖了一张已经卖出的票  

　　所以需要一种机制来管理这类问题的发生,当某个线程正在执行一个不可分割的部分时,其它线程不能不能同时执行这一部分.

　　象这种控制某一时刻只能有一个线程执行某个执行单元的机制就叫互斥控制或共享互斥(mutual exclusion)

　　在中,用synchornized关键字来实现互斥控制(暂时这样认为,1.5已经发展了新的机制)

　　[synchornized关键字]

　　把一个单元声明为synchornized,就可以让在同一时间只有一个线程操作该方法.

　　有人说synchornized就是一把锁,事实上它确实存在锁,但是是谁的锁,锁谁,这是一个非常复杂的问题.

　　每个对象只有一把监视锁(monitor lock),一次只能被一个线程获取.当一个线程获取了这一个锁后,其它线程就只能等待这个线程释放锁才能再获取.

　　那么synchornized关键字到底锁什么?得到了谁的锁?

　　对于同步块,synchornized获取的是参数中的对象锁:

synchornized(obj){ //............... }

　　线程执行到这里时,首先要获取obj这个实例的锁,如果没有获取到线程只能等待.如果多个线程执行到这里,只能有一个线程获取obj的锁,然后执行{}中的语句,所以,obj对象的作用范围不同,控制程序不同.

　　假如:

public void test(){ Object o = new Object(); synchornized(obj){ //............... } }

　　这段程序控制不了任何,多个线程之间执行到Object o = new Object();时会各自产生一个对象然后获取这个对象有监视锁,各自皆大欢喜地执行.

　　而如果是类的属性:

class Test{ Object o = new Object(); public void test(){ synchornized(o){ //............... } } }

　　所有执行到Test实例的synchornized(o)的线程,只有一个线程可以获取到监视锁.

　　有时我们会这样:

public void test(){ synchornized(this){ //............... } }

　　那么所有执行Test实例的线程只能有一个线程执行.而synchornized(o)和synchornized(this)的范围是不同的,因为执行到Test实例的synchornized(o)的线程等待时,其它线程可以执行Test实例的synchornized(o1)部分,但多个线程同时只有一个可以执行Test实例的synchornized(this).]

　　而对于

synchornized(Test.class){ //............... }

　　这样的同步块而言,所有调用Test多个实例的线程赐教只能有一个线程可以执行.

[synchornized方法]

　　如果一个方法声明为synchornized的,则等同于把在为个方法上调用synchornized(this).

　　如果一个静态方法被声明为synchornized,则等同于把在为个方法上调用synchornized(类.class).

　　现在进入wait方法和notify/notifyAll方法.这两个(或叫三个)方法都是Object对象的方法,而不是线程对象的方法.如同锁一样,它们是在线程中调用某一对象上执行的.

class Test{ public synchornized void test(){ //获取条件,int x 要求大于100; if(x < 100) wait(); } }

　　这里为了说明方法没有加在try{}catch(){}中,如果没有明确在哪个对象上调用wait()方法,则为this.wait();

　　假如:

　　Test t = new Test();

　　现在有两个线程都执行到t.test();方法.其中线程A获取了t的对象锁,进入test()方法内.

　　这时x小于100,所以线程A进入等待.

　　当一个线程调用了wait方法后,这个线程就进入了这个对象的休息室(waitset),这是一个虚拟的对象,但JVM中一定存在这样的一个数据结构用来记录当前对象中有哪些程线程在等待.

　　当一个线程进入等待时,它就会释放锁,让其它线程来获取这个锁.

　　所以线程B有机会获得了线程A释放的锁,进入test()方法,如果这时x还是小于100,线程B也进入了t的休息室.

　　这两个线程只能等待其它线程调用notity[All]来唤醒.

　　但是如果调用的是有参数的wait(time)方法,则线程A,B都会在休息室中等待这个时间后自动唤醒.

[为什么真正的应用都是用while(条件)而不用if(条件)]

　　在实际的编程中我们看到大量的例子都是用?

　　while(x < 100)

　　wait();go();而不是用if,为什么呢?

　　在多个线程同时执行时,if(x <100)是不安全的.因为如果线程A和线程B都在t的休息室中等待,这时另一个线程使x==100了,并调用notifyAll方法,线程A继续执行下面的go().而它执行完成后,x有可能又小于100,比如下面的程序中调用了--x,这时切换到线程B,线程B没有继续判断,直接执行go();就产生一个错误的条件,只有while才能保证线程B又继续检查一次。

　　[notify/notifyAll方法]

　　这两个方法都是把某个对象上休息区内的线程唤醒,notify只能唤醒一个,但究竟是哪一个不能确定,而notifyAll则唤醒这个对象上的休息室中所有的线程.

　　一般有为了安全性,我们在绝对多数时候应该使用notifiAll(),除非你明确知道只唤醒其中的一个线程.

　　那么是否是只要调用一个对象的wait()方法,当前线程就进入了这个对象的休息室呢?事实中,要调用一个对象的wait()方法,只有当前线程获取了这个对象的锁,换句话说一定要在这个对象的同步方法或以这个对象为参数的同步块中.

class MyThread extends Thread{ Test t = new Test(); public void run(){ t.test(); System.out.println("Thread say:Hello,World!"); } } public class Test { int x = 0; public void test(){ if(x==0) try{ wait(); }catch(Exception e){} } public static void main(String[] args) throws Exception{ new MyThread().start(); } }

　　这个线程就不会进入t的wait方法而直接打印出Thread say:Hello,World!.

　　而如果改成:

public class Test { int x = 0; public synchornized void test(){ if(x==0) try{ wait(); }catch(Exception e){} } public static void main(String[] args) throws Exception{ new MyThread().start(); } }　　我们就可以看到线程一直等待,注意这个线程进入等待后没有其它线程唤醒,除非强行退出JVM环境,否则它一直等待.

　　所以请记住:

　　[线程要想调用一个对象的wait()方法就要先获得该对象的监视锁,而一旦调用wait()后又立即释放该锁]

做网络必须掌握的83句话，网络成功可以复制
1，网络的成功，是可以复制的。
2，自己做不了的事情，找别人来完成。
3，交际是网络创业成功的捷径。
4，做网络的真正的高手，都是年龄大于35岁的。
5，技术是最次要的一个环节。
6，一个人从开始做网络到正规站阶段，至少需要5年的时间。
7，一个垃圾团队的能力远超出一个天才的全部。
8，在投资上节约的人，就是最会浪费的人。
9，用最简单的程序来完成最复杂的要求，就是最完美的网站。
10，广告的最高境界，就是不像广告。
11，绝不放过任何一个比我们收入高的人。
12，创意站，将是未来10年内网络发展的主角。
13，网络从来不相信什么元老。
14，身边一定要有大于自己20岁以上的朋友。
15，全民皆赚，全民皆转，唯我独赚。
16，真正的网络高手，都看起来像新手，真正的新手，在群上往往表现的像高手。
17，一个团队的年龄段可以拉大，但是层次一定不要拉的太大。
18，别人把自己的商业机密告诉你，只有两个原因，一是你是他的朋友，二是你是他的潜在投资者。
19，一个群，要想有团结力，要想由一个群变成一个团队，必须要做到的就是高门槛。
20，当别人都在做网站的时候，我们就要出售网站创意，当别人都在出售网站创意的时候，我们就要出售网站，当别人又在出售网站的时候，我们就去出售字画。
21，我在群上对你好，说明我害怕你，因为我怕你捣乱，所以我对你好，我越对你好，说明我越讨厌你，生怕你给我惹事。
22，被朋友利用，那说明你没有做事的原则，朋友之间绝对不能有经济来往，朋友不会成为你的客户，但是客户有可能成为你的朋友。
23，一个领导者，一个管理者，最应该避讳的就是与自己团队里的女性朋友的亲密接触，哪怕是狼，在团队面前，也要披上羊皮，否则很快就将失去自己的色彩。
24，一个人，到了30岁，在实业上还没有起色，想通过网络来获得高收入，那么我可以答复你，可能性为0，因为收入决定于一个人的情商，无论实业，还是网络行业，都是通用的。是金子，在哪里都发光，换句话说，是垃圾，到哪里都成不了金子。
25，在网络上，小钱靠技术，中钱靠技巧，大钱靠运营。
26，让关键词排名第一，不一定就是要靠SEO，还可以创造搜索源。
27，三等软文带网址，二等软文带QQ，一等软文被置顶。
28，你应该最大化的利用懂懂，无论懂懂脾气多么不好，性格多么古怪，在这一块网络地皮上，还是他的土地拥有权，他曾经利用这块地皮炒出过十多个月收入10万元以上的人，你能不能走红，能不能发展起来，关键是看你有没有靠近他，有没有让他主动的为你宣传。
29，每10个跟着懂懂的人，就有5个人能够达到500元/天以上的收入，就有1个能够达到1000元/天的收入，就有1/1000个人能够做到一年几百万的利润，但是有50%的人是发展不起来的，你有50%的可能是发展不起来的，你只有千分之一的可能会成为网络奇才。
30，无论是谁，只要产生了群内交易，那么出售方都会被这个群体所淘汰，因为群内交易，肯定会出问题的，到现在为止，有几十个人都因为这个出局了，没有一个人跳出这个怪圈。
31，对你真正发自内心好的人，不是口口声声赞美你的人，也不是口口声声喊你哥哥或者弟弟的人，而是那些在背后默默的支持着的人，君子之交淡如水，同样比油还浓的交情，肯定不是君子。
32，如果你和我说，你的QQ有个牛人，他说一天能挣几万块，那么我可以告诉你，你找错人了，因为如果他连你的QQ的信息都回复的话，那么说明他要回复更 多的和你一样傻的人的信息，那么他一天除了聊QQ外基本上不做事，这不是做事人的做事态度，所以判断一个人是不是高手，一个粗略的判断方法，那就是你加他 QQ，他和不和你聊天。
33，如果一个人，主动的要推销，要带你做网络，那么你可以放弃选择他为老师，因为真正的高手，都是没有时间带学生的，真正带学生的，没有高手。
34，如果你小于20岁，你在网络上骂街，那么我佩服你的年轻，如果你是20-30岁之间在骂街，那么我怀疑你的无聊，如果你大于30岁，那么我怀疑的不是你的无聊，而是怀疑你的智商和神经。
35，智者不骂，骂者不智，要想去惩罚一个人，最好的办法就是鼓励他，而不是去遏止他。
36，第三页+正规广告页=广告中的罗那尔多。
37，如果你想赚钱，那么请你拿出半年的时间来学习，如果你不想赚钱，那么你可能会在学习上浪费1年以上的时间，最后还是选择了放弃网络。
38，如果你准备做网络培训来装B，那么我建议你什么都要学，如果你准备挣钱，那么我建议你抓住一个小小的知识点，然后做起来。
39，做网络的，收入越高，长相越丑，刚才我照了一下镜子，突然发现自己帅了很多。呕咽！
40，群管理的法宝，就是让群上的每一个人都把这里当家，让他们把这里当家的法宝就是把他们每天都介绍一遍。
41，如果你的网站被黑了，首先怀疑的就是和你关系最好的，而不是平时你最讨厌的那个。
42，在商界，没有永远的客户，只有永恒的利益，一旦你的团队没有了新的知识，新的动力，那么也就是你的团队宣布结束的时刻。
43，说自己一分钱没挣到的，这种是真没收入，说自己挣到了1000元/天的，这种收入在100元/天以内，说自己收入很了了的，这种收入在1000元/天以上。
44，这几年，跟着我的人中，有收入过万/天的，他们有的希望我倒下，因为他们不希望他们的背后曾经挂着我的学生的名头，有收入低于10元/天的，他们希 望我倒下，因为他们除了呐喊两声，实在是找不到发泄的地方了，有同行希望我倒下，因为我来的太突然了，忘了给他们送礼，影响了他们的地位。
46，当有人决定让你和被批斗的地主一样，游行街头的时候，你最佳的回击方式是选择沉默，因为你对他最大的打击，就是根本就没把他当回事。
47，网络和现实一样， 不是暴利，99%的网站的日收入不会超过50元人民币，注意是99% 。
50，你应该提防每一个奉承你的人，因为他是一个善于评头论足的人，今天评你的头，后天就论你的足。
51，做网络，一定要表现出来自己的一点爱好，哪怕自己根本就不懂这行，你也要表现出来，因为它可以给你带来巨额收入，例如懂懂，连个字都不认识几个，还装比去收藏字画， 不过是敛财的手段而已。。
52，你要真准备做网络，首先应该放弃使用QQ。
53，一个人在网络上的素质，绝对正比于他的学历和年龄。
54，做网络的最高境界，就是实事求是。
55，如果你准备与一个人谈生意，千万不要男扮女装，因为一旦成交后，你在他心中永远对是一个另类，因为他觉得你这个人太不实在了，记住，不要去装女的。
56，给对方打电话前，要先短信预约。
57，我今年25岁，看一个10岁天才的孩子的话，觉得他很幼稚，同样一个45岁的人，看我的行为，一样能够看出我的幼稚，我玩一个10岁的孩子，玩的他不知道东南西北，同样，45岁的朋友玩我，也会玩的我不知道东南西北，所以人与人之间最大的差距，就在年龄和经验上。
58，走到一个团队，首先想到的就是要做这个团队的老大，要把这个团队上能够对自己有利的人全部拉为自己的人，当自己离开这个团队的时候，也就是这个团队宣布属于自己的时候。
59，你问我中创值不值做，那么我给你的答案就是，只要符合两个条件的事业，就值得你去做，一是合法，二是暴利。
60，如果你比别人晚1年半入群，而想马上跟上节奏，那么你就问一下自己，你在上学的时候，是不是从小学直接上的高一？所以你最应该做的不是去挣钱，而是花更多的时间去补习过去的功课。
61，买空间哪里的好啊？买就买最贵的，你问我是不是SB？那么我可以告诉你，2个月后，你就知道自己是多么SB了。
62，如果你收100元入你的群，那么来的都是25岁以下的，如果你收1000元，那么进你的群的都是创业失败的中年人，如果你收5000元入群，那么来的都是在实业上做的不错的，如果你收1万元入群，那么他们可能都不是来听你讲课的。。
63，你犯了错误，我不说你，我还会去为你辩护，一方面说明我是对这个群负责的，无论你对也好，错也好，我都是支持你的，但是同时我有更深层的意思，那就是纵容你继续犯错误，然后被群上的兄弟们把你主动的赶走。。
66，一个方法，如果我1万元卖给你，你能收入5万元，如果我1000元卖给你，你有可能做起来，如果我免费告诉你的，那么你肯定做不起来。所以为了让你 挣到钱，我有这个责任来收你的钱。。
67，看不惯别人，是自己的修养不够，所以为了锻炼自己的修养，我找了一个脾气最多的老婆。。
68，一个人，生活的质量如何，不看他的收入，而是看他是否活的快乐，活的开心，我说钟情姐是群上最笨的一个，但是我觉得她反过来是活的最开心的一个，因为老朋友们都喜欢她，她的流量网站等都是老朋友们帮他做的。
69，如果一个软件，描述的非常好，你准备去买，那么我可以告诉你，你没有必要投资了，真正可以产生暴利的软件，都是在这个软件没有开发以前，当一个软件，连你都知道是暴利的时候，你就没有必要投资了， 因为在你知道之前，肯定有更多的人知道。
71，网站流量高，不一定网站就有人气，有人气，一定就会慢慢的有流量的。
72，不要指望别人对你忠诚一辈子，因为你仅仅代表了一个层次，当对方发展的高于你这个层次或者低于这个层次的时候，他就脱离了你这个团队。
73，在一个团队里也好，在一个公司里也好，在一个企业里也好，在一个小组里也好，与领头羊搞好关系，是你能够在这里工作的很愉快的前提，当然也是你事业有所突破的前提。
74，如果有谣言传出，这个最值得怀疑的人，就是天天向你打听进展，关心你的人。。
75，当你的团队中或者你的圈子中有人出了问题，或者是经济纠纷或者是其他问题， 别人来攻击你的时候，你应该保持沉默，而且不要去掺合，去解释，因为一杯水，你要想让他澄清，最好的办法就是让它静止下来，而不是去摇晃它。
76，如果一个群，你花了100元就可以进去，那么说明这个群的价值，低于100元，因为群主对你的重视程度，就是100块钱的。
77，南方人智商高，一方面可能是网络精英，一方面可能是网络大盗，北方人豪爽，一方面是怒气冲天，一方面是两肋插刀，山东人喜欢礼尚往来，但是在生意场上，礼尚往来是破坏规矩的最大的隐患。
78，如果你组建了团队，而你又不敢去淘汰的糟粕的话， 说明你本身就是一个胆怯的人。
79，正常情况下，一个人从0日收入到500元/天的收入，至少也要经历1年的学习时间。
80，如果有人推出了网络项目，他承诺一天收入500元，而且这个人在网络上有网站，也有一个固定的圈子，首先我可以肯定这个项目是真实可以达到500元/天的收入的，但是网络项目都是具有时效性的，一般暴利期不会超过1个月。
82，读万卷书，不如阅百人，所以通过一个站，能够结交各类朋友，能够快速的提升自己的生活阅历。
83，生活中，无意中遇到比我们强的人，一定要想法把他运营成自己的朋友，无论吃饭还是游玩，都要自己主动的去买单，因为我们可以得到更高的回报，他之所 以比我们强，因为他们更懂的投资回报比，他们心里的称更准，没有一个高人愿意接受一个比自己差的人的恩赐的，所以他随意一个小动作，就让你成名或者有银子 了。

用java程序查询1百万的数据库,如何加快分页跳转的速度?

一般有常用几种基本的方法可以借鉴：

第一：

hibernate中的oracle分页查询原代码：
StringBuffer pagingSelect = new StringBuffer(100);
pagingSelect.append("select * from ( select row_.*, rownum rownum_ from ( ");
pagingSelect.append(sql);
pagingSelect.append(" ) row_ where rownum <= ?) where rownum_ > ?");

其实就是
select * from ( select row_.*, rownum rownum_ from ( 你的查询语句 )
row_ where rownum <= 结束行) where rownum_ > 开始行

第二：

这个要看用哪个字段排序了，如果按照ID之类的，即是主键聚集索引，下面这个思想的分页很快，百万级别，分到后面100W条左右600毫秒，解决千万级别估计没啥问题。

先取出第N条的ID，例如 select top 1000000 @ID = ID;
上句将占99%的查询成本。
然后select top 10 * where ID >前面取出的ID即可

第三：

1. 总共只需要一个查询总页数: select count(proid) from sys.tblproduct，而不是每翻页就去查询一次

2. SQL语句中只需要一次排序就可以了，不需要多次排序
select productname,proid,addtime,prodetail from
(select productname,proid,addtime,prodetail, rownum as rid
from (select productname,proid,addtime,prodetail from sys.tblproduct order by proid)
where rownum <= &intPage * &intPageSize
) where rid >= (&intPage-1) * &intPageSize+1

第四：

采用orcale的数据分区功能，分区后速度提升很明显。
另外一个关键是要合理的索引设置
硬件的配置也要跟上

第五：

用分析函数row_number(order by XX)会比较快，比rownum的性能好一些
hibernate不用的主要原因，我猜测是解析起来有点麻烦，必须在查询语句中间插一句，容易错。

问题的另一个关键是，有必要在任何条件下给客户看全部数据么？客户关心么？
和客户交流，看他们能接受什么样的默认的查询条件限制，这来得实际多了。