servlet-mapping元素及其子元素

<servlet-mapping> <servlet-name>helloworld</servlet-name> <url-pattern>/hello</url-pattern> </servlet-mapping>

        Servlet 2.5规范允许<servlet-mapping>的<url-pattern>子元素出现多次，之前的规范只允许一个<servlet-mapping>元素包含一个<url-pattern>子元素。我们看下面的例子：

<servlet-mapping> <servlet-name>welcome</servlet-name> <url-pattern>/en/welcome</url-pattern> <url-pattern>/zh/welcome</url-pattern> </servlet-mapping>

       在配置了Servlet与URL样式之间的映射后，当Servlet容器接收到一个请求，它首先确定该请求应该由哪一个Web应用程序来响应。这是通过比较请求URI的开始部分与Web应用程序的上下文路径来确定的。映射到Servlet的路径是请求URI减去上下文的路径，Web应用程序的Context对象在去掉请求URI的上下文路径后，将按照下面的路径映射规则的顺序对剩余部分的路径进行处理，并且在找到第一个成功的匹配后，不再进行下一个匹配。

      容器试着对请求的路径和Servlet映射的路径进行精确匹配，如果匹配成功，则调用这个Servlet来处理请求。

      容器试着匹配最长的路径前缀，以斜杠（/）为路径分隔符，按照路径树逐级递减匹配，选择最长匹配的Servlet来处理请求。

      如果请求的URL路径最后有扩展名，如.jsp，Servlet容器会试着匹配处理这个扩展名的Servlet。

       如果按照前面3条规则没有找到匹配的Servlet，容器会调用Web应用程序默认的Servlet来对请求进行处理，如果没有定义默认的Servlet，容器将向客户端发送HTTP 404错误信息（请求资源不存在）。

posted @ 2012-05-22 20:32 youngturk 阅读(18496) | 评论 (1) | 编辑 收藏

web.xml中servlet控制参数方法

web.xml中servlet：

    <servlet>   <!--接着顺序加载servlet被初始化-->
           <!-- servlet获得控制文件Class的名字，类名 -->
        <servlet-name>smvcCoreDispatcher</servlet-name>
        <servlet-class>org.bluechant.mvc.core.CoreDispatcherController</servlet-class>
        <init-param>
            <param-name>templateLoaderPath</param-name>
            <param-value>/WEB-INF/view</param-value>
        </init-param>
        <init-param>
            <param-name>defaultEncoding</param-name>
            <param-value>GBK</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/smvc_config/smvc-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup><!-- 加载路径 -->
    
     </servlet>
    <servlet-mapping>
        <servlet-name>smvcCoreDispatcher</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    
    <welcome-file-list>
        <welcome-file>login.html</welcome-file>
    </welcome-file-list>

web.xml对应的servlet控制java改写：

package org.bluechant.mvc.core;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.bluechant.mvc.controller.ModelAndView;
import org.bluechant.mvc.core.util.ServletUtils;

import freemarker.template.Configuration;
import freemarker.template.ObjectWrapper;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import freemarker.template.TemplateExceptionHandler;

public class CoreDispatcherController extends HttpServlet {
    
    private Logger logger = Logger.getLogger(CoreDispatcherController.class);
    
    private CacheManager cache ;
    
    private String baseControllerClass = "org.bluechant.mvc.controller.Controller";

    private static final long serialVersionUID = 1L;
    
    private Configuration cfg ;
    
    private String templateLoaderPath ;
    
    private String defaultEncoding ;    
    
    private String contentType ;

    private String contextConfigLocation ;
    
    private ActionConfig actionCoinfig ;    
    
    public void init(ServletConfig config) throws ServletException {
        
        super.init(config);
        //super.init(config);

        String absPath = config.getServletContext().getRealPath("/");//获得系统绝对路径
        System.out.println("absPath:"+absPath);
        //getRealPath("/virtual_dir/file2.txt")应该返回"C:\site\a_virtual\file2.txt" 　　getRealPath("/file3.txt")应该返回null，因为这个文件不存在。 
        ///返回路径D:\Java\workspaces\helios\newshpt\获得文件路径
        defaultEncoding = getInitParameter("defaultEncoding");
        
        templateLoaderPath = getInitParameter("templateLoaderPath");
        //");//从web.xml中获得templateLoaderPath信息，web.xml中对应的路径”/WEB-INF/view“
        
        contextConfigLocation = getInitParameter("contextConfigLocation");
        System.out.println("contextConfigLocation:"+contextConfigLocation);
        ///获得web.xml文件中路径WEB-INF/smvc_config/smvc-config.xml
        actionCoinfig = new ActionConfig();
        actionCoinfig.load(absPath+contextConfigLocation);//文档进行解析与读取,
        ///D:\Java\workspaces\helios\newshpt\WEB-INF/smvc_config/smvc-config.xml
        contentType = "text/html;charset="+defaultEncoding ;
        
        //创建Configuration实例，Configuration是入口，通过它来获得配置文件
        cfg = new Configuration();
        //设置模板路径， getServletContext(),所有是所有路径都能拿到的..
        cfg.setServletContextForTemplateLoading(getServletContext(), templateLoaderPath);
        //cfg.setServletContextForTemplateLoading(arg0, arg1)
        //设置编码格式
        cfg.setEncoding(Locale.getDefault(), defaultEncoding);
        
        //init cache manager
        cache = CacheManager.getInstance();
    }
    
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        processRequest(request,response);
    }
    
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {    
        processRequest(request,response);
        
    }
    
    private void showRequestParams(HttpServletRequest request){
        Enumeration en = request.getParameterNames();
        while (en.hasMoreElements()) {
            String paramName = (String) en.nextElement();
            String[] paramValues = request.getParameterValues(paramName);
            if (paramValues.length == 1) {
                String paramValue = paramValues[0];
                if (paramValue.length() != 0) {
                    //map.put(paramName, paramValue);
                    //System.out.println(paramName+"\t"+paramValue);
                }
            }else if(paramValues.length >1 ){//checkbox
                //map.put(paramName, paramValues);
                //System.out.println(paramName+"\t"+paramValues);
            }
        }
    }
    
    public void processRequest(HttpServletRequest request, HttpServletResponse response){
        
        try {
            request.setCharacterEncoding(defaultEncoding);
            showRequestParams(request);//waiting back to resolve
        } catch (UnsupportedEncodingException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } // set request encoding
        
        ModelAndView mv = analyzeRequest(request);        
        try {
            invokeActionHandler(mv,request);
            if(mv.getViewPath().endsWith(".ftl")){
                invokeViewResolverHandler(mv , response , request);
            }else{
                response.sendRedirect(mv.getWebroot()+mv.getViewPath());
            }    
        } catch (Exception e) {
            e.printStackTrace();
        }    
    }
    
    public ModelAndView analyzeRequest(HttpServletRequest request){        
        ModelAndView modelAndView = new ModelAndView();            
        logger.debug("request url path is : "+request.getRequestURI());
        String requestPath = request.getRequestURI(); // /newshpt/account!login.do
        String webroot = request.getContextPath() ; // /newshpt
        System.out.println("request url path is : "+requestPath);
        System.out.println("request webroot path is : "+webroot);
        modelAndView.setWebroot(webroot);
        String actionFullName = requestPath.substring(webroot.length()); // /account!login.do
        System.out.println("actionFullName : "+actionFullName);
        String[] temp = actionFullName.split("!");
        String method = "execute";
        if(temp.length==2){
             method = temp[1].split("\\.")[0];
        }
        System.out.println("method : "+method);
        String actionName = temp[0]; // /demo
        System.out.println("actionName : "+actionName);
        String className = actionCoinfig.getClassName(actionName);
        System.out.println("className :"+className);
        modelAndView.setClassName(className);
        modelAndView.setMethodName(method);
        modelAndView.setAction(actionName);
        
        return modelAndView ;
    }
    
    /**
     * invoke the request controller's target method 
     * param ModelAndView will be mofified during the process
     * @param mv
     * @param request
     * @throws Exception 
     */
    public void invokeActionHandler(ModelAndView mv , HttpServletRequest request) throws Exception{
        String className = mv.getClassName();
        String methodName = mv.getMethodName();
        //load class
        Class controllerClass = cache.loadClass(className);
        Class parentControllerClass = cache.loadClass(baseControllerClass);
        //load method
        Method setRequest = cache.loadMethod(parentControllerClass, "setRequest", new Class[] { HttpServletRequest.class });    
        Method setModelAndView = cache.loadMethod(parentControllerClass, "setModelAndView", new Class[] { ModelAndView.class });//org.bluechant.mvc.controller.Controller-setModelAndView@6024418  public void org.bluechant.mvc.controller.Controller.setModelAndView(org.bluechant.mvc.controller.ModelAndView)
        Method targetMethod = cache.loadMethod(controllerClass, methodName, new Class[]{});
        //buiid controller instance and invoke target method
        Object instance = controllerClass.newInstance();
        setRequest.invoke(instance, new Object[] { request });//对带有指定参数的指定对象调用由此 Method 对象表示的基础方法    
        setModelAndView.invoke(instance, new Object[] { mv });
        targetMethod.invoke(instance, new Object[]{});        
    }
    
    /**
     * send data to view model , and generate the view page by FreeMarker
     */
    public void invokeViewResolverHandler(ModelAndView modelAndView , HttpServletResponse response ,HttpServletRequest request){    
        //convert session attributes to sessionModel , and push to modelAndView
        Map sessionModel = ServletUtils.sessionAttributesToMap(request.getSession());// userSources=[/admin, /button/custom, /custom, /delivery, /loadShip, /unloadPickUp, /unloadShip]
        modelAndView.put("Session", sessionModel);
        response.setContentType(contentType); 
        try {//初始化FreeMarker
            PrintWriter out = response.getWriter();
            Template template = cfg.getTemplate(modelAndView.getViewPath());//取得生成模版文件
            template.setTemplateExceptionHandler(TemplateExceptionHandler.DEBUG_HANDLER);//setTemplateExceptionHandler
            //set the object wrapper , beanwrapper is the perfect useful objectWrapper instance
            template.setObjectWrapper(ObjectWrapper.BEANS_WRAPPER);// 设置对象包装器
            template.process(modelAndView, out);//模版环境开始载入..
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TemplateException e) {
            e.printStackTrace();
        }
    }
    
}

smvc-config.xml文件:

<?xml version="1.0" encoding="UTF-8"?>
<smvc-config>    
    <action name="/account" class="com.cenin.tjport.shpt.mvc.controller.AccountController"/>
    <action name="/yard" class="com.cenin.tjport.shpt.mvc.controller.DuiCunController"/>
</smvc-config>

posted @ 2012-05-22 15:08 youngturk 阅读(987) | 评论 (0) | 编辑 收藏

Method类

posted @ 2012-05-22 14:01 youngturk 阅读(116) | 评论 (0) | 编辑 收藏

class类使用说明

posted @ 2012-05-22 13:42 youngturk 阅读(136) | 评论 (0) | 编辑 收藏

getServletContext(),获得servlet上下文

posted @ 2012-05-22 11:21 youngturk 阅读(3165) | 评论 (0) | 编辑 收藏

dom4j学习转

1.加载XML文档
SAXReader reader = new SAXReader();
Document doc = reader.read("src/book.xml");

2.获得根元素
Node root = doc.getRootElement();
     或 Element r = doc.getRootElement();

3.取得某节点的单个子节点
Element root = root.getRootElement();
Element memberElm=root.element("member");// "member"是节点名

4.取得节点的文字
String text=memberElm.getText();

5.取得某节点下名为"book"的所有字节点并进行遍历
Element r = doc.getRootElement();
List titles = r.elements("book");
for(int i=0;i<titles.size();i++){
     System.out.println(((Element)titles.get(i)).asXML());
}
6.在某节点下添加子节点.
Element ageElm = newMemberElm.addElement("age");

7.设置节点文字.
ageElm.setText("29");

8.删除某节点.
parentElm.remove(childElm);// childElm是待删除的节点,parentElm是其父节点

三.属性相关.
1.取得某节点下的某属性
            Element root=document.getRootElement();   
            Attribute attribute=root.attribute("size");// 属性名name
2.取得属性的文字
            String text=attribute.getText();
也可以用:
String text2=root.element("name").attributeValue("firstname");这个是取得根节点下name字节点的属性firstname的值.

3.遍历某节点的所有属性
            Element root=document.getRootElement();   
            for(Iterator it=root.attributeIterator();it.hasNext();){
                Attribute attribute = (Attribute) it.next();
                String text=attribute.getText();
                System.out.println(text);
            }
4.设置某节点的属性和文字.
newMemberElm.addAttribute("name", "sitinspring");
5.设置属性的文字
            Attribute attribute=root.attribute("name");
            attribute.setText("sitinspring");
6.删除某属性
            Attribute attribute=root.attribute("size");// 属性名name
            root.remove(attribute);
四.将文档写入XML文件.
1.文档中全为英文,不设置编码,直接写入的形式.
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();
2.文档中含有中文,设置编码格式写入的形式.
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GBK");    // 指定XML编码       
            XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);
           
            writer.write(document);
            writer.close();
五.字符串与XML的转换
1.将字符串转化为XML
String text = "<members> <member>sitinspring</member> </members>";
Document document = DocumentHelper.parseText(text);
2.将文档或节点的XML转化为字符串.
            SAXReader reader = new SAXReader();
            Document document = reader.read(new File("input.xml"));           
            Element root=document.getRootElement();               
            String docXmlText=document.asXML();
            String rootXmlText=root.asXML();
            Element memberElm=root.element("member");
            String memberXmlText=memberElm.asXML();
六.使用XPath快速找到节点.
读取的XML文档示例
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>MemberManagement</name>
<comment></comment>
<projects>
    <project>PRJ1</project>
    <project>PRJ2</project>
    <project>PRJ3</project>
    <project>PRJ4</project>
</projects>
<buildSpec>
    <buildCommand>
      <name>org.eclipse.jdt.core.javabuilder</name>
      <arguments>
      </arguments>
    </buildCommand>
</buildSpec>
<natures>
    <nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>

使用XPath快速找到节点project.
public static void main(String[] args){
    SAXReader reader = new SAXReader();
   
    try{
      Document doc = reader.read(new File("sample.xml"));
     
      List projects=doc.selectNodes("/projectDescription/projects/project");
     
      Iterator it=projects.iterator();
     
      while(it.hasNext()){
        Element elm=(Element)it.next();      
        System.out.println(elm.getText());
      }
     
    }
    catch(Exception ex){
       ex.printStackTrace();
    }
}

posted @ 2012-05-22 10:52 youngturk 阅读(161) | 评论 (0) | 编辑 收藏

json格式学习笔记

1. 什么是 JSON

      JSON概念很简单，JSON 是一种轻量级的数据格式，他基于 javascript 语法的子集，即数组和对象表示。由于使用的是 javascript 语法，因此JSON 定义可以包含在javascript 文件中，对其的访问无需通过基于 XML 的语言来额外解析。不过在使用 JSON 之前，很重要的一点是理解 javascript 中数组及对象字面量的特殊语法。

1.1 数组字面量

         数组字面量，是用一对方括号括起一组用逗号隔开的 javascript 值，例如：

        var aNames=["hello", 12, true , null];

1.2 对象字面量

        对象字面量，是通过两个花括号来定义的。在花括号内可以放置任意数量的“名称-值”对，定义格 式字符串值”。除了最后一行外，每个“名称-值”对后必须有一个逗号（这与Perl 中的联合数组的定义有些类似）。例如：

        var oCar = {

               "color": "red",       

              "doors" : 4,

               "paidFor" : true

        };

1.3 混合字面量

      我们可以混用对象和数组字面量，来创建一个对象数组，或一个包含数组的对象。例如：

{comments:[
{
id:1,
author:"someone1",
url:"http://someone1.x2design.net",
content:"hello"
},
{
id:2,
author:"someone2",
url:"http://someone2.x2design.net",
content:"hello"
},
{
id:3,
author:"someone3",
url:"http://someone3.x2design.net",
content:"hello"
}
]};

1.4 JSON 语法

      在Ajax应用中，就是服务器直接生成javascript语句，客户端获取后直接用eval方法来获得这个对象，这样就可以省去解析XML的性能损失。 同时，在javascript 通信中使用JSON作为数据格式的好处很明星，可以立即获得数据的值，因此可以更快的访问其中包含的数据。

      var oCarInfo = eval("(" + sJSON + ")");

请记住：在javascript中花括号也是一个语句。要让解析器知道这个花括号表示的是一个对象而非一个语句的唯一方法是能否找到封装它的圆括号（它是用来说明代码是一个表达式而非一个语句）。

1.5 JSON 编码和解码

       作为 JSON 资源的一部分，Corockford 开发了一个能够实现 JSON 和Javascript 对象直接解码和编码的工具。这个工具的源程序可以在 www.crockford.com/JSON/json.js 中下载。

       在上面提出用到eval() 存在些固有的不足：它是用来对传入的任何 Javascript 代码求值的，而不仅仅针对JSON。因此，当涉及企业级 web 应用程序开发时，它存在很大的安全隐患。为了解决这个问题，可以使用只用来将 JSON 代码转换为 Javascript 的解析器 JSON.parse() 方法来实现。例如：

       var oObject = JSON.parse (sJSON);

       同时，它也提供了一种将 Javascript 对象转换为 JSON 字符串（数据传输时使用的）的工具（在Javascript 中没有内建这种功能支持）。你要做的只是将对象传入到 JSON.Stringify() 方法。请看下面的例子：

       var oCar = new Object();

       oCar.doors = 4;

        oCar.color = "blue";

       oCar.year = 1995;

       oCar.drivers = new Array("Penny", "Dan" , "Kris");

       document.write(JSON.stringify(oCar));

这段代码将输出如下所示的JSON 字符串：

{"doors" : 4, "color" : "blue", "year" :1995, "drivers" : ["Penny", "Dan" , "Kris"]}

2. JSON 与 XML

       正如上面所说，JSON 与 XML 相比的一大优点就是它更加简单。

请看 XML 数据表示实例：

使用XML表示：

<comments>
<comment>
<id>1</id>
<author>someone1</author>
<url>http://someone1.x2design.net</url>
<content>hello</content>
</comment>
<comment>
<id>2</id>
<author>someone2</author>
<url>http://someone2.x2design.net</url>
<content>someone1</content>
</comment>
<comment>
<id>3</id>
<author>someone3</author>
<url>http://someone3.x2design.net</url>
<content>hello</content>
</comment>
</comments>

使用JSON表示：

{comments:[
{
id:1,
author:"someone1",
url:"http://someone1.x2design.net",
content:"hello"
},
{
id:2,
author:"someone2",
url:"http://someone2.x2design.net",
content:"hello"
},
{
id:3,
author:"someone3",
url:"http://someone3.x2design.net",
content:"hello"
}
]};

       很容易发现，许多冗余的信息不见了。由于不需要有与开始标签（opening tag）匹配的结束标签（closing tag），因此传送相同的信息所需的字节数大大降低了。创始人 Corockford 将其称之为“XML 的减肥方案”）。

        JSON 格式的数据与 XML 相比，缺点是对于外行人可读性更差。当然，有一种观点是，数据交换格式不是用肉眼观察的。如果是通过工具对来回传送的数据进行创建和解析，那么的确没有理 由要求数据必须使人们易于阅读。问题的实质在于：存在可用的 JSON 工具。

3. 服务器端 JSON 工具

java ：java JSON 工具，由Douglas Crock ford 开发，可在 www.crockford.com/JSON/java/

           中下载，它可以在 JSP 中使用。

4. JSON 优势与缺点

       JSON不仅减少了解析XML解析带来的性能问题和兼容性问题，而且对于javascript来说非常容易使用，可以方便的通过遍历数组以及访问对象属性 来获取数据，其可读性也不错，基本具备了结构化数据的性质。不得不说是一个很好的办法，而且事实上google maps就没有采用XML传递数据，而是采用了JSON方案。

       JSON 另外一个优势是跨域可行性，例如你在www.xxx.com的网页里使用是完全可行的，这就意味着你可以跨域传递信息。而使用XMLHttpRequest却获取不了跨域的信息，这是javascript内部的安全性质所限制的。

       JSON看上去很美，是不是就能完全取代XML呢？事实并非如此，而原因就在于XML的优势：通用性。要使服务器端产生语法合格的javascript代 码并不是很容易做到的，这主要发生在比较庞大的系统，服务器端和客户端有不同的开发人员。它们必须协商对象的格式，这很容易造成错误。

posted @ 2012-05-19 09:27 youngturk 阅读(558) | 评论 (0) | 编辑 收藏

Java 读写json格式的文件方法详解

posted @ 2012-05-19 09:09 youngturk 阅读(1435) | 评论 (0) | 编辑 收藏

json 解析ajax

posted @ 2012-05-19 00:36 youngturk 阅读(394) | 评论 (0) | 编辑 收藏

Ajax 实现函数 autocomplete

<html xmlns="http://www.w3.org/1999/xhtml">
 <head id="Head1" runat="server">
     <title>AutoComplate</title>
     <script type="text/javascript" src="js/jquery.min.js"></script>
     <script type="text/javascript" src="js/jquery.autocomplete.min.js"></script>
   
    <link rel="Stylesheet" href="js/css/jquery.autocomplete.css" /> 
   
     <script type="text/javascript">
         $(function() {

           var emails = [

                { name: "Peter Pan", to: "peter@pan.de" },

                { name: "Molly", to: "molly@yahoo.com" },

                { name: "Forneria Marconi", to: "live@japan.jp" },

                { name: "Master <em>Sync</em>", to: "205bw@samsung.com" },

                { name: "Dr. <strong>Tech</strong> de Log", to: "g15@logitech.com" },

                { name: "Don Corleone", to: "don@vegas.com" },

                { name: "Mc Chick", to: "info@donalds.org" },

                { name: "Donnie Darko", to: "dd@timeshift.info" },

                { name: "Quake The Net", to: "webmaster@quakenet.org" },

                { name: "Dr. Write", to: "write@writable.com" }

                ];
                        
             $('#content').autocomplete(emails,
             {
                width :400,
                formatItem: function (row, i, max) {  
                 //   var row=eval("("+row+")");//将JSON转换成对象   
                    return "<table><tr><td align='left'>" + row.name + "</td><td align='right'>约" + row.to + "个宝贝</td></tr></table>";

                 },
                formatMatch: function(row, i, max){
                   // var obj=eval("("+row+")");//将JSON转换成对象   
                     return row.name + " " + row.to;

                } ,

                formatResult: function(row, i, max) {
                  
                      return row.to;

                  }                
             });
        

         
           //此处为动态查询数据例子  （返回Json）
             $("#keyword").autocomplete("default6.aspx", {
                        minChars: 0, 
                        max:10, 
                        width: 400,
                        matchCase:false,//不区分大小写
                      //  matchContains :true,
                       // autoFill: false,
                        scroll: false,
                        dataType: 'json',    
                        scrollHeight: 500,
                       //此处为传递参数
                        extraParams:{v:function() { return $('#keyword').val();}},
                      //需要把data转换成json数据格式                      

                        parse: function(data) {
                           return $.map(eval(data), function(row) {
                               return {
                                data: row,
                                value: row.Guage,    //此处无需把全部列列出来，只是两个关键列
                                result: row.Matcode 
                              }
                        });
                 },
                formatItem: function(data, i, total) {  
                   return "<table><tr><td align='left'>" + data.Guage + "</td><td align='right'> " + data.Unit + " </td></tr></table>"; 
                    
                 },
                formatMatch: function(data, i, total) {
                            return data.Guage;
                 },
                formatResult: function(data, value) { 
                            return data.Guage;   

                 }
                }).result(function(event, data, formatted) { //回调
                         $('#keyword').val(data.Matcode);   //不知为何自动返回值后总是加了个“,”,所以改成后赋值
                         $("#content").val(data.Guage+data.Unit);
            });
  });  
     </script>
 </head>
 <body>
     <form id="form1" runat="server">
     <div>
         <input id="keyword" />
         <input id="content" />
     </div>
     </form>
 </body>
 </html>

引用：

三、参数说明：

* minChars (Number):

在触发autoComplete前用户至少需要输入的字符数.Default: 1，如果设为0，在输入框内双击或者删除输入框内内容时显示列表

* width (Number):

指定下拉框的宽度. Default: input元素的宽度

* max (Number):

autoComplete下拉显示项目的个数.Default: 10

* delay (Number):

击键后激活autoComplete的延迟时间(单位毫秒).Default: 远程为400 本地10

* autoFill (Boolean):

要不要在用户选择时自动将用户当前鼠标所在的值填入到input框. Default: false

* mustMatch (Booolean):

如果设置为true,autoComplete只会允许匹配的结果出现在输入框,所有当用户输入的是非法字符时将会得不到下拉框.Default: false

* matchContains (Boolean):

决定比较时是否要在字符串内部查看匹配,如ba是否与foo bar中的ba匹配.使用缓存时比较重要.不要和autofill混用.Default: false

* selectFirst (Boolean):

如果设置成true,在用户键入tab或return键时autoComplete下拉列表的第一个值将被自动选择,尽管它没被手工选中(用键盘或鼠标).当然如果用户选中某个项目,那么就用用户选中的值. Default: true

* cacheLength (Number):

缓存的长度.即对从数据库中取到的结果集要缓存多少条记录.设成1为不缓存.Default: 10

* matchSubset (Boolean):

autoComplete可不可以使用对服务器查询的缓存,如果缓存对foo的查询结果,那么如果用户输入foo就不需要再进行检索了,直接使用缓存.通常是打开这个选项以减轻服务器的负担以提高性能.只会在缓存长度大于1时有效.Default: true

* matchCase (Boolean):

比较是否开启大小写敏感开关.使用缓存时比较重要.如果你理解上一个选项,这个也就不难理解,就好比foot要不要到FOO的缓存中去找.Default: false

* multiple (Boolean):

是否允许输入多个值即多次使用autoComplete以输入多个值. Default: false

* multipleSeparator (String):

如果是多选时,用来分开各个选择的字符. Default: ","

* scroll (Boolean):

当结果集大于默认高度时是否使用卷轴显示 Default: true

* scrollHeight (Number):

自动完成提示的卷轴高度用像素大小表示 Default: 180 

* formatItem (Function):

为每个要显示的项目使用高级标签.即对结果中的每一行都会调用这个函数,返回值将用LI元素包含显示在下拉列表中. Autocompleter会提供三个参数(row, i, max): 返回的结果数组, 当前处理的行数(即第几个项目,是从1开始的自然数), 当前结果数组元素的个数即项目的个数. Default: none, 表示不指定自定义的处理函数,这样下拉列表中的每一行只包含一个值.

* formatResult (Function):

和formatItem类似,但可以将将要输入到input文本框内的值进行格式化.同样有三个参数,和formatItem一样.Default: none,表示要么是只有数据,要么是使用formatItem提供的值.

* formatMatch (Function):

对每一行数据使用此函数格式化需要查询的数据格式. 返回值是给内部搜索算法使用的. 参数值row

* extraParams (Object):

为后台(一般是服务端的脚本)提供更多的参数.和通常的作法一样是使用一个键值对对象.如果传过去的值是{ bar:4 },将会被autocompleter解析成my_autocomplete_backend.aspx?q=foo&bar=4 (假设当前用户输入了foo). Default: {}

* result (handler) Returns: jQuery

此事件会在用户选中某一项后触发，参数为：

event: 事件对象. event.type为result.

formatted:formatResult函数返回的值

$("#singleBirdRemote").result(function(event, data, formatted) {

//如选择后给其他控件赋值，触发别的事件等等

});

四、注意问题：

1.网上有人说对中文的检索时处理有问题，经过测试此版本没有问题 2.在使用远程地址时，它默认传入的参数是：q（输入值），limit（返回结果的最大值），可以使用extraParams传入其他的参数

exmple:
http://www.2cto.com/kf/201202/118735.html

posted @ 2012-05-19 00:14 youngturk 阅读(585) | 评论 (0) | 编辑 收藏