久久www人成免费看片中文,久久国产精品久久久久久电车,91极品女神在线

2014年5月22日

摘要: 需求描述：公司通過APP產(chǎn)品分享出去的需求和簡歷是做了一個H5頁面作為分享的鏈接，通過APP分享出去自然是沒問題，也是第一次分享，之后通過微信打開H5頁面后想再次分享出去時候就變成了一個鏈接了，而不是自己定制的卡片模式，初次分享后如下：但是打開以后的H5頁面再分享出去就變成這個樣子了：也就是說需要在H5頁面做微信分享的相關(guān)工作，JS-SDK上場了，首先看看JS-SDK的官方說明文檔：https:/... 閱讀全文

posted @ 2016-12-16 17:05 小人物_Amor 閱讀(3559) | 評論 (0) | 編輯收藏

Apache Zeppelin設(shè)置訪問登錄

Apache Zeppelin啟動默認是匿名（anonymous）模式登錄的，也就是任何人都可以訪問，這個可以在/zeppelin/conf下的zeppelin-site.xml中看到：

<property>

  <name>zeppelin.anonymous.allowed</name>

  <value>true</value>

  <description>Anonymous user allowed by default</description>

</property>

description中寫道Anonymous user allowed by default（匿名用戶默認被允許），這樣我們訪問我們安裝的zepplin界面里是這樣的：

右上角顯示anonymous表示匿名模式。

接下來我們要做的就是如何通過修改配置來讓我們的zeppelin擁有驗證登錄的功能：

修改/zeppelin/conf/zeppelin-site.xml文件選項zeppelin.anonymous.allowed的value為false,表示不允許匿名訪問：

<property>

  	<name>zeppelin.anonymous.allowed</name>

  	<value>false</value>

  	<description>Anonymous user allowed by default</description>

    </property>

修改/zeppelin/conf/shiro.ini文件，顯然zeppelin采用了shiro作為他的驗證登錄權(quán)限控制框架，那么我們需要對shiro有一些了解，我們?nèi)タ丛撐募淖詈髱仔校?/li>

[urls]

# anon means the access is anonymous.

# authcBasic means Basic Auth Security

# authc means Form based Auth Security

# To enfore security, comment the line below and uncomment the next one

/api/version = anon

/** = anon

#/** = authc

顯然是對localhost:7878/#/**的進行驗證，對/**的不驗證，那我們就修改為對任何url訪問都需要驗證：把/**=anon修改為/**=authc,這樣重啟zeppelin后訪問我們的zeppelin主頁就變成這個樣子了：

看見右上角的Login按鈕了吧？對的，你現(xiàn)在zeppelin已經(jīng)需要登錄才能繼續(xù)訪問了，可是滿屏幕的去找也沒找到注冊的地方，那么我們通過什么賬號來進行登錄呢？繼續(xù)修改zeppelin/conf/shiro.ini文件：

[users]

# List of users with their password allowed to access Zeppelin.

# To use a different strategy (LDAP / Database / ...) check the shiro doc at http://shiro.apache.org/configuration.html#Configuration-INISections

admin = admin

user1 = password2, role1, role2

user2 = password3, role3

user3 = password4, role2

已經(jīng)給我們加了這些賬號了，看第一條注釋提供了用戶以及對應(yīng)的密碼用來允許訪問zeppelin，然后你自己可以在下面加一些用戶xxx = yyy，其中的角色也可以自行選擇，需要詳細了解的可以熟悉熟悉shiro的角色權(quán)限控制。重啟zeppelin用你知道的賬號去登錄吧~！

輸入對應(yīng)賬號進入主頁后選擇一個你已經(jīng)添加過的notebook進去然后去右上角看見有一把小鎖：

會顯示Note Permissions點擊后出現(xiàn)上圖所示可以填寫該notebook的Owners(所有者)、Readers（只讀用戶）、Writers(讀寫用戶)，這樣每一個notebook就可以歸屬于某一個具體的用戶了，避免了多用戶同時使用zeppelin可能造成的沖突。

還有很多其他功能值得你去發(fā)現(xiàn)、研究！

posted @ 2016-11-09 15:32 小人物_Amor 閱讀(3138) | 評論 (0) | 編輯收藏

Apache Zeppelin安裝及使用

Apache Zeppelin官網(wǎng)：http://zeppelin.apache.org/

Apache Zeppelin介紹：A web-based notebook that enables interactive data analytics. You can make beautiful data-driven, interactive and collaborative documents with SQL, Scala and more.

安裝說明：

下載地址：http://zeppelin.apache.org/download.html當(dāng)前最新版是0.6.1

點擊下載后解壓到指定文件夾，你的zeppelin就安裝完成了，很簡單。但是zeppelin依賴于jdk，所以使用zeppelin前還需要機器擁有jdk環(huán)境。

解壓完畢后需要配置幾個地方：

將conf中的zeppelin-env.sh.template與zeppelin-site.xml.template 重命名，去掉template
修改conf/zepplin-env.sh 新增

export SPARK_MASTER_IP=127.0.0.1

export SPARK_LOCAL_IP=127.0.0.1

修改 export ZEPPELIN_MEM="-Xmx2048m -XX:PermSize=256M"

需要注意的是lib下的jar包，默認帶的jackson-databind-2.5.3.jar包是無法使用的，這點不知道為什么zeppelin怎么處理的，需要將jackson-databind/jackson-annonations/jackson-core三個jar包全部替換成2.6.5版本的就可以了。

啟動zeppelin：進入bin目錄下執(zhí)行 ./zeppelin-daemon.sh start

然后瀏覽器訪問127.0.0.1：8080就進入如下頁面：

ok，你的zeppelin安裝成功了！

其實zeppelin就是一個java web項目，這樣理解起來似乎就容易點了，接下來為了可以使用sql統(tǒng)計數(shù)據(jù)，我們來操作一下如何添加interpreter：

首先修改conf/zeppelin-site.xml，添加org.apache.zeppelin.jdbc.JdbcInterpreter
進入lib目錄下上傳 JdbcInterpreter.jar、mysql-connection-.....jar兩個jar包
然后重啟zeppelin，進入web頁面的interpreter下，點擊create：添加完成之后是這個樣子：
然后進入notebook頁面：綁定剛剛添加的interpreter就可以使用了：

這樣一個JdbcInterpreter就添加完畢了。

至于以后再想和redis、solr一起使用也是相應(yīng)的加入jar包就可以了~

就我個人來說zeppelin可以滿足企業(yè)運營這塊的需求，包括日活、百度引流統(tǒng)計、ngnix日志分析、用戶行為分析、熱門詞匯、整體數(shù)據(jù)統(tǒng)計、多維度數(shù)據(jù)統(tǒng)計等等。

posted @ 2016-11-09 15:16 小人物_Amor 閱讀(2049) | 評論 (0) | 編輯收藏

java web面試題集錦

1.JDK和JRE的區(qū)別：

JDK是Java Development Kit。是面向開發(fā)人員使用的SDK，提供了java的開發(fā)環(huán)境以及運行環(huán)境。

JRE是Java Runtime Enviroment。是指java的運行環(huán)境，是面向java程序得使用者，而不是開發(fā)者。

2.序列化的目的：

Java中，一切都是對象，在分布式環(huán)境中經(jīng)常需要將Object從這一端網(wǎng)絡(luò)或設(shè)備傳遞到另一端。這就需要有一種可以在兩端傳輸數(shù)據(jù)的協(xié)議。Java序列化機制就是為了解決這個問題而產(chǎn)生。

以某種存儲形式使自定義對象持久化。

將對象從一個地方傳到另一個地方。

3.equals和==的區(qū)別：

基本數(shù)據(jù)類型應(yīng)該用“==”來比較他們的值。

當(dāng)比較對象時候，如果對象里重寫了equals方法，比如String，Integer，Date這些類，比較對象的內(nèi)存地址應(yīng)該用“==”，比較對象的值用“equals”，如果沒有重寫equals方法，兩者本質(zhì)上是相同的，都是比較值。

4.什么時候使用Comparator and Comparable 接口

當(dāng)需要排序的集合或數(shù)組不是單純的數(shù)字類型的時候，通常可以使用Comparator或Comparable，以簡單的方式實現(xiàn)對象排序和自定義排序。

Comparable用在對象本身，說明這個對象是可以被比較的，也就是說可以被排序的。（String和Integer之所以可以比較大小，是因為它們都實現(xiàn)了Comparable接口，并實現(xiàn)了compareTo()方法）。

Compator用在對象外，相當(dāng)于定義了一個排序算法。

5.轉(zhuǎn)發(fā)和重定向的區(qū)別：

轉(zhuǎn)發(fā)時URL不會改變，request請求內(nèi)的對象將可以繼續(xù)使用，重定向時瀏覽器URL會改變，之前的request會丟失，因此request里的數(shù)據(jù)也不會得到。

通常情況下轉(zhuǎn)發(fā)速度更快，而且能保持request內(nèi)的對象，但是轉(zhuǎn)發(fā)之后，瀏覽器的連接還在先前頁面所以可以重載先前頁面。

轉(zhuǎn)發(fā)：request.getRequestDispatcher("apage.jsp").forward(request, response);
重定向：response.sendRedirect("apage.jsp");

6.編譯期異常和運行時異常

編譯時異常可以捕捉，比如我們讀寫文件時候會拋出IOException，操作數(shù)據(jù)庫時會有SQLException，運行時異常不可以捕捉，比如數(shù)組下標溢出，空指針異常等

7.Struts1原理和Struts2原理以及區(qū)別和聯(lián)系，在什么項目中用過，有什么體會?

struts1原理：客戶端發(fā)送HttpServletRequest請求給ActionServlet，ActionServlet會檢索和用戶請求匹配的ActionMapping實例，如果不存在就返回請求路徑無效的信息，如果存在就會把請求的表單數(shù)據(jù)保存到ActionForm中去，如果ActionForm不存在就會創(chuàng)建一個ActionForm對象，然后再根據(jù)配置信息決定是否需要表單驗證，如果需要驗證就調(diào)用ActionForm的validate()方法，驗證通過后ActionServlet根據(jù)ActionMapping實例包含的映射信息決定將請求轉(zhuǎn)發(fā)給哪個Action，如果相應(yīng)的Action實例不存在就先創(chuàng)建這個Action然后調(diào)用Action的execute()方法。Action的execute()方法返回一個ActionForward對象，ActionServlet再把客戶請求轉(zhuǎn)發(fā)給ActionForward對象指向的jsp組件。

struts2原理：客戶端發(fā)送HttpServletRequest請求，請求被提交到一系列的Filter，首先是ActionContextCleanUp，然后是其他Filter，最后是FilterDispatcher。FilterDispatcher是Struts2的核心，就是MVC的Struts2實現(xiàn)中控制層的核心。FilterDispatcher詢問ActionMapper決定需要調(diào)用哪個Action，F(xiàn)ilterDispatcher會把請求交給ActionProxy，ActionProxy會根據(jù)Struts.xml配置文件找到需要調(diào)用的Action類。ActionProxy創(chuàng)建一個ActionInvocation實例，同時ActionInvocation通過代理模式調(diào)用Action類，調(diào)用之前會加載Action相關(guān)的所有攔截器，一旦Action執(zhí)行完畢，ActionInvocation根據(jù)Struts.xml配置文件返回對應(yīng)的result。

區(qū)別：1.Struts1是通過Servlet啟動的，struts1要求Action繼承一個抽象類，而不是接口，Struts2的Action類可以實現(xiàn)一個Action接口也可以實現(xiàn)其他接口。

2.struts1的Action是單例模式線程是不安全的，struts2是線程安全的，Action為每一個請求都生成了一個實例。

3.struts1是以ActionServlet為核心控制器，struts2是以FilterDispatcher為核心控制器。

執(zhí)行流程:

        a)struts1 
                    jsp發(fā)起httprequest請求->servlet捕獲->struts.xml->namespace+ActionName-> Action->填充表單setXxx()->action.execute()->”success”->Result->設(shè)置request屬性->跳轉(zhuǎn)目標頁
             b) Action(jsp發(fā)起httprequest請求，被過濾器捕獲)->FilterDispatcher->struts.xml->namespace+ActionName->new Action->填充表單setXxx()->action.execute()->”success”->Result->設(shè)置request屬性->跳轉(zhuǎn)目標頁

8.spring原理

spring的最大作用ioc/di,將類與類的依賴關(guān)系寫在配置文件中，程序在運行時根據(jù)配置文件動態(tài)加載依賴的類，降低的類與類之間的藕合度。它的原理是在applicationContext.xml加入bean標記,在bean標記中通過class屬性說明具體類名、通過property標簽說明該類的屬性名、通過constructor-args說明構(gòu)造子的參數(shù)。其一切都是反射，當(dāng)通過applicationContext.getBean(“id名稱”)得到一個類實例時，就是以bean標簽的類名、屬性名、構(gòu)造子的參數(shù)為準，通過反射實例對象，喚起對象的set方法設(shè)置屬性值、通過構(gòu)造子的newInstance實例化得到對象。正因為spring一切都是反射，反射比直接調(diào)用的處理速度慢，所以這也是spring的一個問題。
spring第二大作用就是aop，其機理來自于代理模式，代理模式有三個角色分別是通用接口、代理、真實對象。代理、真實對象實現(xiàn)的是同一接口，將真實對象作為代理的一個屬性，向客戶端公開的是代理，當(dāng)客戶端調(diào)用代理的方法時，代理找到真實對象，調(diào)用真實對象方法，在調(diào)用之前之后提供相關(guān)的服務(wù)，如事務(wù)、安全、日志。其名詞分別是代理、真實對象、裝備、關(guān)切點、連接點。

9.簡要概述一下SpringMVC和StrutsMVC

Spring的MVC框架主要由DispatcherServlet、處理器映射、處理器、視圖解析器、視圖組成。

1）DispatcherServlet接收到請求后，根據(jù)對應(yīng)配置文件中配置的處理器映射，找到對應(yīng)的處理器映射項（HandlerMapping），根據(jù)配置的映射規(guī)則，找到對應(yīng)的處理器（Handler）。
2）調(diào)用相應(yīng)處理器中的處理方法，處理該請求，處理器處理結(jié)束后會將一個ModelAndView類型的數(shù)據(jù)傳給DispatcherServlet，這其中包含了處理結(jié)果的視圖和視圖中要使用的數(shù)據(jù)。
3）DispatcherServlet 根據(jù)得到的ModelAndView中的視圖對象，找到一個合適的ViewResolver（視圖解析器），根據(jù)視圖解析器的配置，DispatcherServlet將視圖要顯示的數(shù)據(jù)傳給對應(yīng)的視圖，最后給瀏覽器構(gòu)造一個HTTP響應(yīng)。

DispatcherServlet是整個Spring MVC的核心。它負責(zé)接收HTTP請求組織協(xié)調(diào)Spring MVC的各個組成部分。其主要工作有以下三項：
1）截獲符合特定格式的URL請求。
2）初始化DispatcherServlet上下文對應(yīng)的WebApplicationContext，并將其與業(yè)務(wù)層、持久化層的WebApplicationContext建立關(guān)聯(lián)。
3）初始化Spring MVC的各個組成組件，并裝配到DispatcherServlet中。

StrutsMVC

1.當(dāng)啟動容器時，容器(tomcat、weblogic)實例化ActionServlet,初始化ActionServlet，在初始化
ActionServlet時加載struts-config.xml文件。
2.當(dāng)客戶通過url.do將請求發(fā)給ActionServlet,ActionServlet將處理轉(zhuǎn)發(fā)給助手RequestProcessor,RequestProcess通過struts-config.xml找到對應(yīng)的actionForm及 action，如果有ActionForm用已有的，沒有通過類的反射實例化一個新的ActionForm,放置到作用域?qū)ο螅ㄟ^反射

將表單域的值填充到actionForm中。如果有Action用已有的，沒有產(chǎn)生一個新的，通過反射調(diào)用action實例的execute方法，在執(zhí)行前將actionForm通過參數(shù)注入到execute方法中。
3.execute方法執(zhí)行結(jié)束前通過actionMapping找到actionForward轉(zhuǎn)發(fā)到另一個頁面。

10.Servlet的工作原理、生命周期

Servlet的工作原理：

Servlet 生命周期：Servlet 加載--->實例化--->服務(wù)--->銷毀。

init（）：在Servlet的生命周期中，僅執(zhí)行一次init()方法。它是在服務(wù)器裝入Servlet時執(zhí)行的，負責(zé)初始化Servlet 對象。可以配置服務(wù)器，以在啟動服務(wù)器或客戶機首次訪問Servlet時裝入Servlet。無論有多少客戶機訪問Servlet，都不會重復(fù)執(zhí)行 init（）。

service（）：它是Servlet的核心，負責(zé)響應(yīng)客戶的請求。每當(dāng)一個客戶請求一個HttpServlet對象，該對象的 Service()方法就要調(diào)用，而且傳遞給這個方法一個“請求”（ServletRequest）對象和一個“響應(yīng)” （ServletResponse）對象作為參數(shù)。在HttpServlet中已存在Service()方法。默認的服務(wù)功能是調(diào)用與HTTP請求的方法相應(yīng)的do功能。

destroy（）：僅執(zhí)行一次，在服務(wù)器端停止且卸載Servlet時執(zhí)行該方法。當(dāng)Servlet對象退出生命周期時，負責(zé)釋放占用的資源。一個Servlet在運行service()方法時可能會產(chǎn)生其他的線程，因此需要確認在調(diào)用destroy()方法時，這些線程已經(jīng)終止或完成。

Servlet工作原理：

1、首先簡單解釋一下Servlet接收和響應(yīng)客戶請求的過程，首先客戶發(fā)送一個請求，Servlet是調(diào)用service()方法對請求進行響應(yīng) 的，通過源代碼可見，service()方法中對請求的方式進行了匹配，選擇調(diào)用doGet,doPost等這些方法，然后再進入對應(yīng)的方法中調(diào)用邏輯層的方法，實現(xiàn)對客戶的響應(yīng)。在Servlet接口和GenericServlet中是沒有doGet（）、doPost（）等等這些方法的，HttpServlet中定義了這些方法，但是都是返回error信息，所以，我們每次定義一個Servlet的時候，都必須實現(xiàn)doGet或 doPost等這些方法。
2、每一個自定義的Servlet都必須實現(xiàn)Servlet的接口，Servlet接口中定義了五個方法，其中比較重要的三個方法涉及到 Servlet的生命周期，分別是上文提到的init(),service(),destroy()方法。GenericServlet是一個通用的，不特定于任何協(xié)議的Servlet,它實現(xiàn)了Servlet接口。而HttpServlet繼承于GenericServlet，因此 HttpServlet也實現(xiàn)了Servlet接口。所以我們定義Servlet的時候只需要繼承HttpServlet即可。
3、Servlet接口和GenericServlet是不特定于任何協(xié)議的，而HttpServlet是特定于HTTP協(xié)議的類，所以 HttpServlet中實現(xiàn)了service()方法，并將請求ServletRequest、ServletResponse 強轉(zhuǎn)為HttpRequest 和 HttpResponse。

11.OOA、OOD、OOP含義

Object-Oriented Analysis：面向?qū)ο蠓治龇椒?/span>

Object-Oriented Design：面向?qū)ο笤O(shè)計

Object Oriented Programming：面向?qū)ο缶幊?/span>

OOA是對系統(tǒng)業(yè)務(wù)調(diào)查了解之后根據(jù)面向?qū)ο蟮乃枷脒M行系統(tǒng)分析，在OOA分析的基礎(chǔ)上對系統(tǒng)根據(jù)面向?qū)ο蟮乃枷脒M行系統(tǒng)設(shè)計，從而能夠直接進行OOP面向?qū)ο缶幊獭?/span>

12.mysql分頁查詢

對于有大數(shù)據(jù)量的mysql表來說，使用LIMIT分頁存在很嚴重的性能問題。

查詢從第1000000之后的30條記錄：

SQL代碼1：平均用時6.6秒 SELECT * FROM `cdb_posts` ORDER BY pid LIMIT 1000000 , 30

SQL代碼2：平均用時0.6秒 SELECT * FROM `cdb_posts` WHERE pid >= (SELECT pid FROM `cdb_posts` ORDER BY pid LIMIT 1000000 , 1) LIMIT 30

因為要取出所有字段內(nèi)容，第一種需要跨越大量數(shù)據(jù)塊并取出，而第二種基本通過直接根據(jù)索引字段定位后，才取出相應(yīng)內(nèi)容，效率自然大大提升。

可以看出，越往后分頁，LIMIT語句的偏移量就會越大，兩者速度差距也會越明顯。

實際應(yīng)用中，可以利用類似策略模式的方式去處理分頁，比如判斷如果是一百頁以內(nèi)，就使用最基本的分頁方式，大于一百頁，則使用子查詢的分頁方式。

Oracle查詢：SELECT * FROM (SELECT A.*, ROWNUM RN FROM (SELECT * FROM TABLE_NAME) A WHERE ROWNUM <= 40) WHERE RN >= 21

13.單例模式、工廠模式、代理模式

枚舉實現(xiàn)單例模式：

public enum Singleton {

    /**
     * 定義一個枚舉的元素，它就代表了Singleton的一個實例。
     */
    
    uniqueInstance;
    
    /**
     * 單例可以有自己的操作
     */
    public void singletonOperation(){
        //功能處理
    }
  }

  懶漢同步單例模式：

  public class LazySingleton {

    private static LazySingleton instance = null;

/**

     * 私有默認構(gòu)造子

*/

    private LazySingleton(){}

/**

     * 靜態(tài)工廠方法

*/

    public static synchronized LazySingleton getInstance(){

        if(instance == null){

            instance = new LazySingleton();

        return instance;

工廠模式：http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html

代理模式：http://yangguangfu.iteye.com/blog/815787

未完待續(xù)...

posted @ 2014-10-08 16:50 小人物_Amor 閱讀(355) | 評論 (0) | 編輯收藏

【轉(zhuǎn)】Servlet 生命周期、工作原理

Servlet 生命周期：Servlet 加載--->實例化--->服務(wù)--->銷毀。
init（）：在Servlet的生命周期中，僅執(zhí)行一次init()方法。它是在服務(wù)器裝入Servlet時執(zhí)行的，負責(zé)初始化Servlet 對象。可以配置服務(wù)器，以在啟動服務(wù)器或客戶機首次訪問Servlet時裝入Servlet。無論有多少客戶機訪問Servlet，都不會重復(fù)執(zhí)行 init（）。
service（）：它是Servlet的核心，負責(zé)響應(yīng)客戶的請求。每當(dāng)一個客戶請求一個HttpServlet對象，該對象的 Service()方法就要調(diào)用，而且傳遞給這個方法一個“請求”（ServletRequest）對象和一個“響應(yīng)” （ServletResponse）對象作為參數(shù)。在HttpServlet中已存在Service()方法。默認的服務(wù)功能是調(diào)用與HTTP請求的方法相應(yīng)的do功能。
destroy（）：僅執(zhí)行一次，在服務(wù)器端停止且卸載Servlet時執(zhí)行該方法。當(dāng)Servlet對象退出生命周期時，負責(zé)釋放占用的資源。一個Servlet在運行service()方法時可能會產(chǎn)生其他的線程，因此需要確認在調(diào)用destroy()方法時，這些線程已經(jīng)終止或完成。

Tomcat 與 Servlet 是如何工作的：

步驟：

Web Client 向Servlet容器（Tomcat）發(fā)出Http請求
Servlet容器接收Web Client的請求
Servlet容器創(chuàng)建一個HttpRequest對象，將Web Client請求的信息封裝到這個對象中。
Servlet容器創(chuàng)建一個HttpResponse對象
Servlet容器調(diào)用HttpServlet對象的service方法，把HttpRequest對象與HttpResponse對象作為參數(shù)傳給 HttpServlet 對象。
HttpServlet調(diào)用HttpRequest對象的有關(guān)方法，獲取Http請求信息。
HttpServlet調(diào)用HttpResponse對象的有關(guān)方法，生成響應(yīng)數(shù)據(jù)。
Servlet容器把HttpServlet的響應(yīng)結(jié)果傳給Web Client。

Servlet工作原理：

2、每一個自定義的Servlet都必須實現(xiàn)Servlet的接口，Servlet接口中定義了五個方法，其中比較重要的三個方法涉及到 Servlet的生命周期，分別是上文提到的init(),service(),destroy()方法。GenericServlet是一個通用的，不特定于任何協(xié)議的Servlet,它實現(xiàn)了Servlet接口。而HttpServlet繼承于GenericServlet，因此 HttpServlet也實現(xiàn)了Servlet接口。所以我們定義Servlet的時候只需要繼承HttpServlet即可。

3、Servlet接口和GenericServlet是不特定于任何協(xié)議的，而HttpServlet是特定于HTTP協(xié)議的類，所以 HttpServlet中實現(xiàn)了service()方法，并將請求ServletRequest、ServletResponse 強轉(zhuǎn)為HttpRequest 和 HttpResponse。

創(chuàng)建Servlet對象的時機：

Servlet容器啟動時：讀取web.xml配置文件中的信息，構(gòu)造指定的Servlet對象，創(chuàng)建ServletConfig對象，同時將ServletConfig對象作為參數(shù)來調(diào)用Servlet對象的init方法。
在Servlet容器啟動后：客戶首次向Servlet發(fā)出請求，Servlet容器會判斷內(nèi)存中是否存在指定的Servlet對象，如果沒有則創(chuàng)建它，然后根據(jù)客戶的請求創(chuàng)建HttpRequest、HttpResponse對象，從而調(diào)用Servlet 對象的service方法。
Servlet Servlet容器在啟動時自動創(chuàng)建Servlet，這是由在web.xml文件中為Servlet設(shè)置的<load- on-startup>屬性決定的。從中我們也能看到同一個類型的Servlet對象在Servlet容器中以單例的形式存在。

<servlet>
        <servlet-name>Init</servlet-name>
        <servlet-class>org.xl.servlet.InitServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
</servlet>

posted @ 2014-10-08 15:16 小人物_Amor 閱讀(289) | 評論 (0) | 編輯收藏

Array.sort()、Collections.sort()以及Comparable、Comparator學(xué)習(xí)筆記

Arrays.sort(T[], Comparator < ? super T > c) 方法用于對象數(shù)組按用戶自定義規(guī)則排序。

Collections.sort(List<T>, Comparator < ? super T > c)方法用于對象集合按用戶自定義規(guī)則排序。

Compator用在對象外，相當(dāng)于定義了一個排序算法。

所以當(dāng)對象本身實現(xiàn)了Comparable接口，那么Arrays.sort(T[])就可以了。同理Collections.sort(List<T>)就可以了。

還是代碼來的直接：

package com.zx.ww.comparable;

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorTest {

    public static void main(String[] args) {
        Dog d1 = new Dog(2);

        Dog d2 = new Dog(1);

        Dog d3 = new Dog(3);

        Dog[] dogArray = {d1, d2, d3};

        printDogs(dogArray);

        Arrays.sort(dogArray, new DogSizeComparator());

        printDogs(dogArray);
    }

    public static void printDogs(Dog[] dogArray) {
        for (Dog dog : dogArray) {
            System.out.print(dog.size+" ");
        }
        System.out.println();
    }

}

class Dog{
    int size;
    public Dog(int size) {
        this.size = size;
    }
}

class DogSizeComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog dog1, Dog dog2) {
        // TODO Auto-generated method stub
        return dog1.size - dog2.size;
    }
}

輸出結(jié)果：

2 1 3
1 2 3

這是對象數(shù)組用了Comparator的結(jié)果。

下面看對象自身實現(xiàn)了Comparable接口的方式：

/**
*
*/
package com.zx.ww.comparable;

import java.util.Arrays;

/**
* @author wuwei
* 2014年9月29日
*/
public class User implements Comparable<Object>{

    private int id;

    private String name;

    private int age;

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }



    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        return this.age - ((User)o).getAge();
    }

    public static void main(String[] args) {
        User[] users = new User[] {new User(1,"zhangsan",28), new User(2,"lisi",25)};
        Arrays.sort(users);
        for (int i = 0; i < users.length; i++) {
            User user = users[i];
            System.out.println(user.getId()+" "+user.getAge());
        }
    }

}

輸出結(jié)果：

2 25
1 28

上述都是Arrays.sort()的應(yīng)用方式，同理Collections.sort()一樣的實現(xiàn)，代碼如下，比較簡單：

package com.zx.ww.comparable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionSortTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("ac");
        list.add("ab");
        list.add("aa");
        list.add("db");
        list.add("ca");

        for (String string : list) {
            System.out.print(string + " ");
        }
        System.out.println();
        Collections.sort(list);

        for (String string : list) {
            System.out.print(string + " ");
        }
        System.out.println();

        //對象A自身實現(xiàn)Comparable接口
        List<A> aList = new ArrayList<A>();
        aList.add(new A("wuwei", 1));
        aList.add(new A("zhangsan", 3));
        aList.add(new A("lisi", 2));
        for (A a : aList) {
            System.out.print(a+" ");
        }
        System.out.println();
        Collections.sort(aList);
        for (A a : aList) {
            System.out.print(a+" ");
        }
        System.out.println();

        //重寫Conparator接口方法
        List<B> bList = new ArrayList<B>();
        bList.add(new B("wuwei", 1));
        bList.add(new B("zhangsan", 3));
        bList.add(new B("lisi", 2));
        for (B b : bList) {
            System.out.print(b+" ");
        }
        System.out.println();
        Collections.sort(bList, new Comparator<B>() {

            @Override
            public int compare(B b1, B b2) {
                // TODO Auto-generated method stub
                return b1.getCount().compareTo(b2.getCount());
            }
        });
        for (B b : bList) {
            System.out.print(b+" ");
        }
        System.out.println();

    }


}

//對象A自身實現(xiàn)Comparable接口
class A implements Comparable<A>{

    private String name;

    private Integer order;

    public A(String name, Integer order) {
        this.name = name;
        this.order = order;
    }

    public String getName() {
        return name;
    }

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

    public Integer getOrder() {
        return order;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    public String toString() {
        return "name is " +name+" order is "+order;
    }

    @Override
    public int compareTo(A o) {
        // TODO Auto-generated method stub
        return this.order.compareTo(o.getOrder());
    }

}

class B{
    private String name;

    private Integer count;

    public B(String name, Integer count) {
        this.name = name;
        this.count = count;
    }

    public String getName() {
        return name;
    }

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

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }

    public String toString() {
        return "name is "+name+" count is "+count;
    }
}

輸出結(jié)果：

ac ab aa db ca
aa ab ac ca db
name is wuwei order is 1 name is zhangsan order is 3 name is lisi order is 2
name is wuwei order is 1 name is lisi order is 2 name is zhangsan order is 3
name is wuwei count is 1 name is zhangsan count is 3 name is lisi count is 2
name is wuwei count is 1 name is lisi count is 2 name is zhangsan count is 3

posted @ 2014-09-29 16:08 小人物_Amor 閱讀(1109) | 評論 (0) | 編輯收藏

快速、冒泡排序算法的性能比較

/**
*
*/
package com.zx.ww.arraysort;

import java.text.Collator;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Locale;

/**
* @author xue
* 2014年9月24日
*/
public class QuickSort {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            test();
        }
    }

    public static void test() {

        int len = 8000000;
        int[] array = new int[len];
        for (int i = 0; i < len; i++) {
            array[i] = (int)(Math.random()*10000);
        }

        Calendar cal_before = Calendar.getInstance();
        double before = cal_before.getTimeInMillis();
        System.out.println(cal_before.getTime());
        quickSort(array, 0, array.length-1);

        Calendar cal_after = Calendar.getInstance();
        double after = cal_after.getTimeInMillis();
        System.out.println(cal_after.getTime());


        double time = after-before;
        System.out.println("用時：" + time + "ms");
        System.out.println("==================================");

    }

    public static void quickSort(int[] array, int left, int right) {
        if(left < right) {
            int privot = getPrivot(array, left, right);
            quickSort(array, left, privot-1);
            quickSort(array, privot+1, right);
        }

    }


    //將數(shù)組劃分為兩個數(shù)組，左邊的數(shù)組都比中軸privot小，右邊的都比中軸privot大
    public static int getPrivot(int[] array, int left, int right) {

        int tmp = array[left];

        while(left < right) {

            while(left < right && array[right] >= tmp) {
                right--;
            }

            array[left] = array[right];

            while(left < right && array[left] <= tmp) {
                left++;
            }

            array[right] = array[left];

        }

        array[left] = tmp;

        return left;
    }

}

運行十次輸出的結(jié)果：

Thu Sep 25 13:09:40 CST 2014
Thu Sep 25 13:09:41 CST 2014
用時：1613.0ms
==================================
Thu Sep 25 13:09:41 CST 2014
Thu Sep 25 13:09:43 CST 2014
用時：1614.0ms
==================================
Thu Sep 25 13:09:43 CST 2014
Thu Sep 25 13:09:45 CST 2014
用時：1691.0ms
==================================
Thu Sep 25 13:09:45 CST 2014
Thu Sep 25 13:09:47 CST 2014
用時：1622.0ms
==================================
Thu Sep 25 13:09:47 CST 2014
Thu Sep 25 13:09:48 CST 2014
用時：1621.0ms
==================================
Thu Sep 25 13:09:49 CST 2014
Thu Sep 25 13:09:50 CST 2014
用時：1615.0ms
==================================
Thu Sep 25 13:09:50 CST 2014
Thu Sep 25 13:09:52 CST 2014
用時：1614.0ms
==================================
Thu Sep 25 13:09:52 CST 2014
Thu Sep 25 13:09:54 CST 2014
用時：1632.0ms
==================================
Thu Sep 25 13:09:54 CST 2014
Thu Sep 25 13:09:55 CST 2014
用時：1614.0ms
==================================
Thu Sep 25 13:09:56 CST 2014
Thu Sep 25 13:09:57 CST 2014
用時：1614.0ms
==================================

上述是快速排序八百萬條數(shù)據(jù)用時基本在1.6s左右。

接下來看冒泡排序：

/**
*
*/
package com.zx.ww.arraysort;

import java.text.Collator;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Comparator;
import java.util.Locale;

/**
* @author wuwei
* 2014年9月24日
*/
public class BubbleSort {

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            test();
        }

    }

    public static void test() {

        int len = 80000;
        int[] array = new int[len];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int)(Math.random()*10000);
        }

        Calendar calBefore = Calendar.getInstance();
        System.out.println(calBefore.getTime());

        bubbleSort(array);

        Calendar calAfter = Calendar.getInstance();
        System.out.println(calAfter.getTime());

        System.out.println("總共用時" + (calAfter.getTimeInMillis()-calBefore.getTimeInMillis()) + "ms");

        System.out.println("==========================");

    }

    public static void bubbleSort(int[] array) {

        int tmp;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-i-1; j++) {

                if(array[j] > array[j+1]) {
                    tmp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = tmp;
                }

            }
        }
    }

}

運行五次輸出如下結(jié)果：

Thu Sep 25 14:44:14 CST 2014
Thu Sep 25 14:44:23 CST 2014
總共用時8822ms
==========================
Thu Sep 25 14:44:23 CST 2014
Thu Sep 25 14:44:32 CST 2014
總共用時8829ms
==========================
Thu Sep 25 14:44:32 CST 2014
Thu Sep 25 14:44:41 CST 2014
總共用時8915ms
==========================
Thu Sep 25 14:44:41 CST 2014
Thu Sep 25 14:44:50 CST 2014
總共用時8748ms
==========================
Thu Sep 25 14:44:50 CST 2014
Thu Sep 25 14:44:58 CST 2014
總共用時8529ms
==========================

冒泡排序八萬條數(shù)據(jù)用時接近9s。

需要注意的是快速排序是八百萬條數(shù)據(jù)只用了1.6s左右。

posted @ 2014-09-25 13:09 小人物_Amor 閱讀(267) | 評論 (0) | 編輯收藏

根據(jù)集合里的Bean所包含的屬性對集合進行排序工具類

/**
*
*/
package com.infopatent.juangetljc.web.controller.util;

import java.lang.reflect.Field;
import java.text.Collator;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;

/**
* @author xue
* 2014年9月24日
*/
public class SortListByBeanPropertyUtil {

    //根據(jù)集合里的Bean擁有的屬性進行排序

    public static <T> void sort(List<T> list, final String sortProperty, final String sort) {

        if(list == null || sortProperty == null || "".equals(sortProperty) || list.isEmpty())
            return;

        Collections.sort(list, new Comparator<T>() {

            @Override
            public int compare(T t1, T t2) {
                Object o1 = new Object();
                Object o2 = new Object();
                try {
                    o1 = SortListByBeanPropertyUtil.getFieldValue(t1, sortProperty);
                    o2 = SortListByBeanPropertyUtil.getFieldValue(t2, sortProperty);

                } catch (Exception e) {
                    e.printStackTrace();
                }
                int result = 0;
                if(o1 == null) {
                    result = -1;
                }else if(o2 == null) {
                    result = 1;
                }else if(o1 instanceof String) {
                    result = Collator.getInstance(Locale.CHINESE).compare(o1, o2);
                }else{
                    result = ((Comparable)o1).compareTo(o2);
                }

                //是否降序排序
                if("desc".equalsIgnoreCase(sort)) {
                    result = 0-result;
                }

                return result;
            }

        });

    }

    //反射方法，反射出類型
    public static Object getFieldValue(Object obj, String fieldName) throws Exception {
        //反射出對象類型
        Class<?> cls = obj.getClass();
        //反射出類型字段
        Field field = cls.getDeclaredField(fieldName);
        //獲取屬性是，壓制java對訪問修飾符的檢查
        field.setAccessible(true);
        //在對象obj上讀取field屬性的值
        Object val = field.get(obj);
        return val;

    }

}

posted @ 2014-09-24 16:25 小人物_Amor 閱讀(348) | 評論 (0) | 編輯收藏

java讀取sql腳本文件并插入到mysql數(shù)據(jù)庫

    因為項目框架hibernate里的hibernate.hbm2ddl.auto屬性設(shè)置為create（為了使得開發(fā)人員只關(guān)注于實體類而不必去關(guān)心數(shù)據(jù)庫設(shè)計。。。），所以我們每次部署項目的時候都會把數(shù)據(jù)庫生成的表全刪除了然后根據(jù)實體類生成數(shù)據(jù)表，這樣就需要在maven項目寫一個測試類來初始化項目需要的一些基礎(chǔ)數(shù)據(jù)，如用戶、權(quán)限、資源、字典等。因為maven在構(gòu)建到特定的生命周期階段的時候會通過插件來執(zhí)行JUnit或者TestNG的測試用例，這個插件就是maven-surefire-plugin（這是需要配置的，當(dāng)然也可以禁止去執(zhí)行測試類，甚至禁止編譯測試類），需要了解的請學(xué)習(xí)相關(guān)maven文檔，或者參考http://blog.csdn.net/sin90lzc/article/details/7543262。
    考慮到上述因素，那么我就在src/test/java文件夾下新建一個測試類，那么這個測試類就會在clean install時候會執(zhí)行，那么在這個時候執(zhí)行數(shù)據(jù)初始化是合適的。因為初始化數(shù)據(jù)來自于sql腳本，所以我得讀取sql腳本的內(nèi)容并解析成相關(guān)的sql語句通過java的jdbc執(zhí)行sql語句。那就開始做吧。不多說，上代碼：

  1 package com.infopatent.juangetljc.core;
  2
  3 import java.io.BufferedReader;
  4 import java.io.FileInputStream;
  5 import java.io.InputStream;
  6 import java.sql.Connection;
  7 import java.sql.DriverManager;
  8 import java.sql.SQLException;
  9 import java.sql.Statement;
10 import java.util.ArrayList;
11 import java.util.Arrays;
12 import java.util.List;
13
14 import org.junit.Test;
15
16 import junit.framework.TestCase;
17
18 public class InitDataTest extends TestCase {
19
20     private String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8";
21     private String driver = "com.mysql.jdbc.Driver";
22     private String userName = "root";
23     private String password = "";
24     String filePathIn = "F://workspace/juange-tljc/juange-tljc-core/src/test/java/basedata.sql";
25
26     @Test
27     public void test() {
28
29         try {
30             execute(filePathIn);
31         } catch (Exception e) {
32             // TODO Auto-generated catch block
33             e.printStackTrace();
34         }
35     }
36
37     /*
38      * 讀取sql文件,獲取sql語句
39      * 返回所有sql語句的list集合
40      * */
41     private List<String> loadSql(String sqlFile) throws Exception {
42         List<String> sqlList = new ArrayList<String>();
43         /*
44          * 讀取文件的內(nèi)容并寫道StringBuffer中去
45          * */
46         InputStream sqlFileIn = new FileInputStream(sqlFile);
47         StringBuffer sqlSb = new StringBuffer();
48         byte[] buff = new byte[sqlFileIn.available()];
49         int byteRead = 0;
50         while((byteRead = sqlFileIn.read(buff)) != -1) {
51             sqlSb.append(new String(buff, 0, byteRead));
52         }
53         /*
54          * windows下?lián)Q行是/r/n，Linux下是/n，
55          * 此處需要根據(jù)導(dǎo)出的sql文件進行具體的處理，我在處理的時候
56          * 也遇到了很多的問題，如果我這個不行可以在網(wǎng)上找找別的解析方法
57          * */
58         String sqlArr[] = sqlSb.toString().split("(;\\s*\\rr\\n)|(;\\s*\\n)");
59         for(int i = 0; i<sqlArr.length; i++) {
60             String sql = sqlArr[i].replaceAll("--.*", "").trim();
61             if(!"".equals(sql)) {
62                 sqlList.add(sql);
63             }
64         }
65         return sqlList;
66
67     }
68
69     /*
70      * 傳入文件執(zhí)行sql語句
71      *
72      * */
73     private void execute(String sqlFile) throws SQLException {
74         Statement stmt = null;
75         List<String> sqlList = new ArrayList<String>();
76         Connection conn = getConnection();
77         try {
78             sqlList = loadSql(sqlFile);
79             conn.setAutoCommit(false);
80             stmt = conn.createStatement();
81             for (String sql : sqlList) {
82                 System.out.println(sql);
83                 stmt.addBatch(sql);
84             }
85             int[] rows = stmt.executeBatch();
86             System.out.println("Row count:" + Arrays.toString(rows));
87             conn.commit();
88             System.out.println("數(shù)據(jù)更新成功");
89         } catch (Exception e) {
90             e.printStackTrace();
91             conn.rollback();
92         }finally{
93             stmt.close();
94             conn.close();
95         }
96
97     }
98
99     /*
100      * 獲取sql連接
101      * */
102     private Connection getConnection(){
103         Connection conn = null;
104         try {
105             Class.forName(driver);
106             conn = DriverManager.getConnection(url, userName, password);
107             if(!conn.isClosed()) {
108                 System.out.println("數(shù)據(jù)庫連接成功!");
109             }
110         } catch (Exception e) {
111             e.printStackTrace();
112         }
113         return conn;
114     }
115 }
116

在這個過程中遇到了很多的問題，曾經(jīng)一度使我陷入迷糊狀態(tài)中，后來好好梳理了一下思路，一個一個的去排查問題終于成功了~
首先在讀取文件的時候，發(fā)現(xiàn)讀取的文件內(nèi)容顯示是正常的不是亂碼，但是插入到數(shù)據(jù)庫中就是亂碼，好吧，我又遇到了這種問題，我依次檢查了我java文件的編碼，數(shù)據(jù)庫的編碼，都設(shè)置為utf-8，url也加上編碼"jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8"。結(jié)果還是亂碼，那就再看看mysql下的my.ini文件中的編碼設(shè)置在[mysqld]節(jié)點下加上default-character-set=utf8（如果沒有就改為utf8），這下終于不是亂碼了。然后我開始maven clean install,去查看數(shù)據(jù)庫發(fā)現(xiàn)又出現(xiàn)了亂碼的問題，真是折磨人啊，我發(fā)現(xiàn)唯一不同的就是之前正常的插入數(shù)據(jù)是我在測試類下run as junit，而現(xiàn)在用的是maven clean install，剛接觸maven完全不知道癥結(jié)所在啊，百度一下，發(fā)現(xiàn)maven構(gòu)建到特定的生命周期時候運行測試用例是依靠maven-surefire-plugin這個插件的，而這個插件也需要指定字符集編碼的，于是我在項目的pom.xml中加入了如下代碼（本來竟然沒有！）：

1 <build>
2         <plugins>
3             <plugin>
4                 <groupId>org.apache.maven.plugins</groupId>
5                 <artifactId>maven-surefire-plugin</artifactId>
6                 <version>2.7.2</version>
7                 <configuration>
8                     <forkMode>once</forkMode>
9                     <argLine>-Dfile.encoding=UTF-8</argLine>
10                     <systemProperties>
11                         <property>
12                                 <name>net.sourceforge.cobertura.datafile</name>
13                                 <value>target/cobertura/cobertura.ser</value>
14                         </property>
15                     </systemProperties>
16                 </configuration>
17             </plugin>
18         </plugins>
19     </build>

這個時候再去maven clean install,終于不亂碼了，終于不亂碼了！花了我四個小時，長見識了！此處記錄自己遇到的問題以及如何解決，希望對各位有幫助！

posted @ 2014-07-29 15:07 小人物_Amor 閱讀(3335) | 評論 (0) | 編輯收藏

基于dtree的樹形菜單實現(xiàn)

各位如果想找合適的樹形菜單，不放試試dtree，去官網(wǎng)看看www.destroydrop.com/javascript/tree/，下載dtree.zip下來解壓之后有dtree.js,dtree.css,img文件夾,api.html,example01.html這幾個文件，可以看看api.html，里面有參數(shù)和方法說明，實際上在項目應(yīng)用時，我們是需要從數(shù)據(jù)庫里的菜單表里讀取數(shù)據(jù)進行樹形菜單構(gòu)建的，根據(jù)api.html里面的參數(shù)說明可建立一張s_menu的數(shù)據(jù)表：

CREATE TABLE `s_menu` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `pid` int(11) DEFAULT NULL COMMENT '父級id',
  `name` varchar(45) DEFAULT NULL COMMENT '菜單名稱',
  `url` varchar(255) DEFAULT NULL COMMENT '菜單url',
  `title` varchar(45) DEFAULT NULL COMMENT '鼠標放上去顯示的title',
  `target` varchar(45) DEFAULT NULL COMMENT '目標iframe',
  `icon` varchar(255) DEFAULT NULL COMMENT '菜單折疊時候顯示的圖片',
  `iconOpen` varchar(255) DEFAULT NULL COMMENT '菜單打開時候顯示的圖片',
  `open` int(1) DEFAULT '0' COMMENT '是否打開',
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;

并且插入一些測試數(shù)據(jù)來使用：

INSERT INTO `s_menu` VALUES ('1', '-1', '瀏覽器', '#', '瀏覽器', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('2', '1', 'IE', '#', 'IE瀏覽器', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('3', '2', 'IE6', '#', 'IE6', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('4', '2', 'IE7', '#', 'IE7', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('5', '2', 'IE8', '#', 'IE8', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('6', '2', 'IE10', '#', 'IE10', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('7', '1', 'Firefox', '#', 'Firefox', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('8', '7', 'Firefox15.0', '#', 'Firefox15.0', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('9', '7', 'Firefox15.1', '#', 'Firefox15.1', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('10', '1', '360瀏覽器', '#', '360瀏覽器', null, null, null, '0');
INSERT INTO `s_menu` VALUES ('11', '1', '搜狗瀏覽器', '#', '搜狗瀏覽器', null, null, null, '0');

接下來把解壓好的dtree.js以及dtree.css放到項目的對應(yīng)目錄下，并在頁面引入，后臺執(zhí)行方法我就不說了，就是查詢出s_menu里所有的數(shù)據(jù)就可以了，在jsp里面實現(xiàn)：

<%@ page contentType="text/html;charset=UTF-8" %>
<%@ include file="/common/taglibs.jsp" %>
<%@ page import="org.springframework.context.ApplicationContext,org.springframework.context.support.ClassPathXmlApplicationContext,com.zx.ww.entity.base.Menu,com.zx.ww.service.base.MenuManager,java.util.List"  %>
<%
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    MenuManager menuManager = (MenuManager)context.getBean("menuManager");
    List<Menu> menus = menuManager.findAllMenu();
    request.setAttribute("menus", menus);
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>SSH2</title>
    </head>
    <body>
        <table width="100%" height="100%" border="0" cellspacing="0" cellpadding="0">
            <tr>
                <td valign="top">
                    <div id="treearea" style="overflow: scroll;height:100%;width:100%"></div>
                </td>
            </tr>
        </table>
    </body>
</html>
<script type="text/javascript">
    var dtree = new dTree('dtree', '${ctx}/images/dtree/');
    dtree.config.folderLinks = true;
    dtree.config.useCookies = true;
    <c:forEach items="${menus}" var="menu">
        dtree.add(${menu.id},${menu.pid},"${menu.name}","${menu.url}","${menu.title}");
    </c:forEach>
    document.getElementById('treearea').innerHTML = dtree;

</script>

看效果：

這是從數(shù)據(jù)庫里讀出數(shù)據(jù)的方式，本地的話構(gòu)建這樣的數(shù)據(jù)就行了：

網(wǎng)上有很多關(guān)于dtree的說明，在此看不明白的再去網(wǎng)上找找別的，有說的比較詳細的PPT，關(guān)于各個參數(shù)以及方法說明都有~
ok，留著以后會有用的！

posted @ 2014-05-30 17:46 小人物_Amor 閱讀(1264) | 評論 (0) | 編輯收藏

輸入框自動提示開發(fā)使用

因為項目需要，需要做輸入框自動提示功能，之前我只是使用過這種功能，相信大家也都使用過，百度~現(xiàn)在要讓我自己做，好吧，還是百度一下，百度搜索“輸入框自動提示”，彈出一對頁面，也看了一堆文章，有自己開發(fā)的，也有插件的。

最后經(jīng)過幾次試驗，我選擇了JQuery.Autocomplete這款插件，還行吧用著，支持本地也支持ajax訪問服務(wù)器，這款插件是基于jquery的，各位若有項目需要使用的，可以嘗試一把。

源碼下載：JQuery.AutoComplete

本地自動提示的方式我就不說了，各位下載源碼之后看一下也就明白了，當(dāng)然不明白的也可以問我，說一下ajax訪問服務(wù)器的方式吧，直接上代碼最為直接：

$(function(){

        var onAutocompleteSelect =function(customer) {
　　　　　 $('#customerIdString').val(customer.data);
          };
          var options = {
              serviceUrl: '${pageContext.request.contextPath}/TCustomer/getAllCustomer.koala',//獲取數(shù)據(jù)的后臺頁面
              onSelect: onAutocompleteSelect,//選中之后的回調(diào)函數(shù)
              extraParams: {selectedCustomerName:$.trim($("#selectedCustomerName").val())},//動態(tài)參數(shù)值
              paramName: "selectedCustomerName",
              noCache: false, //是否啟用緩存默認是開啟緩存的
              max:10,
              autoFill:false
          };
        $('#selectedCustomerName').autocomplete(options);
});

這樣我們就可以把填入輸入框的值作為extraParams動態(tài)參數(shù)傳遞到后臺去，后臺直接request.getParameter("selectedCustomerName");就可以了。

值得注意的是，后臺應(yīng)該返回什么樣的數(shù)據(jù)格式，這個插件需要注意的地方就是這塊了，如果不是他要求的格式的話，頁面會報js錯誤的，要求的數(shù)據(jù)格式必須是這樣的json串：

{"query":"A","suggestions":[{"data":"114e69b4-87a9-4c2b-aed4-1727568a92a7","value":"AAA111"},{"data":"531b59ca-8618-48f4-a6e8-963320e10159","value":"小人物_Amor"}]}

query后面的A是我輸入框傳入的參數(shù)，根據(jù)A模糊查詢出兩組數(shù)據(jù)，并以json的格式放在key為suggestions里。

后臺代碼：

    @ResponseBody
    @RequestMapping("/getAllCustomer")
    public Object getAllCustomer(HttpServletRequest request,HttpServletResponse response)throws IOException{
        List<Object> queryCustomerList = new ArrayList<Object>();
        List<TCustomerDTO> allCustomer = new ArrayList<TCustomerDTO>();
        //獲取前臺帶過來的動態(tài)參數(shù)
        String selectedCustomerName = request.getParameter("selectedCustomerName");

        //得到包含selectedCustomerName參數(shù)的對象
        allCustomer = tCustomerApplication.findAllTCustomer();
        for (Iterator iterator = allCustomer.iterator(); iterator.hasNext();) {
            TCustomerDTO tCustomerDTO = (TCustomerDTO) iterator.next();
            if(tCustomerDTO.getName().contains(selectedCustomerName)){
                Map<String, Object> result = new HashMap<String, Object>();
                result.put("value", tCustomerDTO.getName());
                result.put("data", tCustomerDTO.getId());
                queryCustomerList.add(result);
            }
        }

        //構(gòu)造規(guī)定的json數(shù)據(jù)格式
        Map<String, Object> query_result = new HashMap<String, Object>();
        Object json = JSONArray.toJSON(queryCustomerList);
        query_result.put("query", selectedCustomerName);
        query_result.put("suggestions", json);
        Object json_map = JSONArray.toJSON(query_result);
        System.out.println(json_map);
        return json_map;
    }

OK了，其實很簡單，當(dāng)然你需要引入jquery，以及他所要求的其他兩個js文件，各位下載源碼后看示例就知道啦~

posted @ 2014-05-22 18:11 小人物_Amor 閱讀(1398) | 評論 (0) | 編輯收藏

常用鏈接

留言簿(1)

隨筆分類

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜