2014年9月25日
摘要: 需求描述：公司通過APP產(chǎn)品分享出去的需求和簡歷是做了一個H5頁面作為分享的鏈接，通過APP分享出去自然是沒問題，也是第一次分享，之后通過微信打開H5頁面后想再次分享出去時候就變成了一個鏈接了，而不是自己定制的卡片模式，初次分享后如下：但是打開以后的H5頁面再分享出去就變成這個樣子了：也就是說需要在H5頁面做微信分享的相關(guān)工作，JS-SDK上場了，首先看看JS-SDK的官方說明文檔：https:/...
閱讀全文
posted @
2016-12-16 17:05 小人物_Amor 閱讀(3565) |
評論 (0) |
編輯 收藏Apache Zeppelin啟動默認(rèn)是匿名（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（匿名用戶默認(rèn)被允許），這樣我們訪問我們安裝的zepplin界面里是這樣的：
右上角顯示anonymous表示匿名模式。
接下來我們要做的就是如何通過修改配置來讓我們的zeppelin擁有驗(yàn)證登錄的功能：
- 修改/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作為他的驗(yàn)證登錄權(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/#/**的進(jìn)行驗(yàn)證，對/**的不驗(yàn)證，那我們就修改為對任何url訪問都需要驗(yàn)證：把/**=anon修改為/**=authc,這樣重啟zeppelin后訪問我們的zeppelin主頁就變成這個樣子了：
看見右上角的Login按鈕了吧？對的，你現(xiàn)在zeppelin已經(jīng)需要登錄才能繼續(xù)訪問了，可是滿屏幕的去找也沒找到注冊的地方，那么我們通過什么賬號來進(jìn)行登錄呢？繼續(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，其中的角色也可以自行選擇，需要詳細(xì)了解的可以熟悉熟悉shiro的角色權(quán)限控制。重啟zeppelin用你知道的賬號去登錄吧~！
輸入對應(yīng)賬號進(jìn)入主頁后選擇一個你已經(jīng)添加過的notebook進(jìn)去然后去右上角看見有一把小鎖：
會顯示Note Permissions點(diǎn)擊后出現(xiàn)上圖所示可以填寫該notebook的Owners(所有者)、Readers（只讀用戶）、Writers(讀寫用戶)，這樣每一個notebook就可以歸屬于某一個具體的用戶了，避免了多用戶同時使用zeppelin可能造成的沖突。
還有很多其他功能值得你去發(fā)現(xiàn)、研究！
posted @
2016-11-09 15:32 小人物_Amor 閱讀(3152) |
評論 (0) |
編輯 收藏
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.
安裝說明：
點(diǎn)擊下載后解壓到指定文件夾，你的zeppelin就安裝完成了，很簡單。但是zeppelin依賴于jdk，所以使用zeppelin前還需要機(jī)器擁有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包，默認(rèn)帶的jackson-databind-2.5.3.jar包是無法使用的，這點(diǎn)不知道為什么zeppelin怎么處理的，需要將jackson-databind/jackson-annonations/jackson-core三個jar包全部替換成2.6.5版本的就可以了。
啟動zeppelin：進(jìn)入bin目錄下執(zhí)行 ./zeppelin-daemon.sh start
然后瀏覽器訪問127.0.0.1：8080就進(jìn)入如下頁面：
ok，你的zeppelin安裝成功了！
其實(shí)zeppelin就是一個java web項目，這樣理解起來似乎就容易點(diǎn)了，接下來為了可以使用sql統(tǒng)計數(shù)據(jù)，我們來操作一下如何添加interpreter：
- 首先修改conf/zeppelin-site.xml，添加org.apache.zeppelin.jdbc.JdbcInterpreter
- 進(jìn)入lib目錄下上傳 JdbcInterpreter.jar、mysql-connection-.....jar兩個jar包
- 然后重啟zeppelin，進(jìn)入web頁面的interpreter下，點(diǎn)擊create：添加完成之后是這個樣子：
- 然后進(jìn)入notebook頁面：
綁定剛剛添加的interpreter就可以使用了：
這樣一個JdbcInterpreter就添加完畢了。
至于以后再想和redis、solr一起使用也是相應(yīng)的加入jar包就可以了~
就我個人來說zeppelin可以滿足企業(yè)運(yùn)營這塊的需求，包括日活、百度引流統(tǒng)計、ngnix日志分析、用戶行為分析、熱門詞匯、整體數(shù)據(jù)統(tǒng)計、多維度數(shù)據(jù)統(tǒng)計等等。
posted @
2016-11-09 15:16 小人物_Amor 閱讀(2055) |
評論 (0) |
編輯 收藏1.JDK和JRE的區(qū)別：
JDK是Java Development Kit。是面向開發(fā)人員使用的SDK，提供了java的開發(fā)環(huán)境以及運(yùn)行環(huán)境。
JRE是Java Runtime Enviroment。是指java的運(yùn)行環(huán)境，是面向java程序得使用者，而不是開發(fā)者。
2.序列化的目的：
Java中，一切都是對象，在分布式環(huán)境中經(jīng)常需要將Object從這一端網(wǎng)絡(luò)或設(shè)備傳遞到另一端。這就需要有一種可以在兩端傳輸數(shù)據(jù)的協(xié)議。Java序列化機(jī)制就是為了解決這個問題而產(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，以簡單的方式實(shí)現(xiàn)對象排序和自定義排序。
Comparable用在對象本身，說明這個對象是可以被比較的，也就是說可以被排序的。（String和Integer之所以可以比較大小，是因?yàn)樗鼈兌紝?shí)現(xiàn)了Comparable接口，并實(shí)現(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.編譯期異常和運(yùn)行時異常
編譯時異常可以捕捉，比如我們讀寫文件時候會拋出IOException，操作數(shù)據(jù)庫時會有SQLException，運(yùn)行時異常不可以捕捉，比如數(shù)組下標(biāo)溢出，空指針異常等
7.Struts1原理和Struts2原理以及區(qū)別和聯(lián)系，在什么項目中用過，有什么體會?
struts1原理：客戶端發(fā)送HttpServletRequest請求給ActionServlet，ActionServlet會檢索和用戶請求匹配的ActionMapping實(shí)例，如果不存在就返回請求路徑無效的信息，如果存在就會把請求的表單數(shù)據(jù)保存到ActionForm中去，如果ActionForm不存在就會創(chuàng)建一個ActionForm對象，然后再根據(jù)配置信息決定是否需要表單驗(yàn)證，如果需要驗(yàn)證就調(diào)用ActionForm的validate()方法，驗(yàn)證通過后ActionServlet根據(jù)ActionMapping實(shí)例包含的映射信息決定將請求轉(zhuǎn)發(fā)給哪個Action，如果相應(yīng)的Action實(shí)例不存在就先創(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實(shí)現(xiàn)中控制層的核心。FilterDispatcher詢問ActionMapper決定需要調(diào)用哪個Action，F(xiàn)ilterDispatcher會把請求交給ActionProxy，ActionProxy會根據(jù)Struts.xml配置文件找到需要調(diào)用的Action類。ActionProxy創(chuàng)建一個ActionInvocation實(shí)例，同時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類可以實(shí)現(xiàn)一個Action接口也可以實(shí)現(xiàn)其他接口。
2.struts1的Action是單例模式線程是不安全的，struts2是線程安全的，Action為每一個請求都生成了一個實(shí)例。
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)目標(biāo)頁
b) Action(jsp發(fā)起httprequest請求，被過濾器捕獲)->FilterDispatcher->struts.xml->namespace+ActionName->new Action->填充表單setXxx()->action.execute()->”success”->Result->設(shè)置request屬性->跳轉(zhuǎn)目標(biāo)頁
8.spring原理
spring的最大作用ioc/di,將類與類的依賴關(guān)系寫在配置文件中，程序在運(yùn)行時根據(jù)配置文件動態(tài)加載依賴的類，降低的類與類之間的藕合度。它的原理是在applicationContext.xml加入bean標(biāo)記,在bean標(biāo)記中通過class屬性說明具體類名、通過property標(biāo)簽說明該類的屬性名、通過constructor-args說明構(gòu)造子的參數(shù)。其一切都是反射，當(dāng)通過applicationContext.getBean(“id名稱”)得到一個類實(shí)例時，就是以bean標(biāo)簽的類名、屬性名、構(gòu)造子的參數(shù)為準(zhǔn)，通過反射實(shí)例對象，喚起對象的set方法設(shè)置屬性值、通過構(gòu)造子的newInstance實(shí)例化得到對象。正因?yàn)閟pring一切都是反射，反射比直接調(diào)用的處理速度慢，所以這也是spring的一個問題。
spring第二大作用就是aop，其機(jī)理來自于代理模式，代理模式有三個角色分別是通用接口、代理、真實(shí)對象。代理、真實(shí)對象實(shí)現(xiàn)的是同一接口，將真實(shí)對象作為代理的一個屬性，向客戶端公開的是代理，當(dāng)客戶端調(diào)用代理的方法時，代理找到真實(shí)對象，調(diào)用真實(shí)對象方法，在調(diào)用之前之后提供相關(guān)的服務(wù)，如事務(wù)、安全、日志。其名詞分別是代理、真實(shí)對象、裝備、關(guān)切點(diǎn)、連接點(diǎ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的核心。它負(fù)責(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)實(shí)例化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用已有的，沒有通過類的反射實(shí)例化一個新的ActionForm,放置到作用域?qū)ο螅ㄟ^反射
- 將表單域的值填充到actionForm中。如果有Action用已有的，沒有產(chǎn)生一個新的，通過反射調(diào)用action實(shí)例的execute方法，在執(zhí)行前將actionForm通過參數(shù)注入到execute方法中。
- 3.execute方法執(zhí)行結(jié)束前通過actionMapping找到actionForward轉(zhuǎn)發(fā)到另一個頁面。
10.Servlet的工作原理、生命周期
Servlet的工作原理：
Servlet 生命周期：Servlet 加載--->實(shí)例化--->服務(wù)--->銷毀。 init（）：在Servlet的生命周期中，僅執(zhí)行一次init()方法。它是在服務(wù)器裝入Servlet時執(zhí)行的，負(fù)責(zé)初始化Servlet 對象。可以配置服務(wù)器，以在啟動服務(wù)器或客戶機(jī)首次訪問Servlet時裝入Servlet。無論有多少客戶機(jī)訪問Servlet，都不會重復(fù)執(zhí)行 init（）。 service（）：它是Servlet的核心，負(fù)責(zé)響應(yīng)客戶的請求。每當(dāng)一個客戶請求一個HttpServlet對象，該對象的 Service()方法就要調(diào)用，而且傳遞給這個方法一個“請求”（ServletRequest）對象和一個“響應(yīng)” （ServletResponse）對象作為參數(shù)。在HttpServlet中已存在Service()方法。默認(rèn)的服務(wù)功能是調(diào)用與HTTP請求的方法 相應(yīng)的do功能。 destroy（）： 僅執(zhí)行一次，在服務(wù)器端停止且卸載Servlet時執(zhí)行該方法。當(dāng)Servlet對象退出生命周期時，負(fù)責(zé)釋放占用的資 源。一個Servlet在運(yùn)行service()方法時可能會產(chǎn)生其他的線程，因此需要確認(rèn)在調(diào)用destroy()方法時，這些線程已經(jīng)終止或完成。
Servlet工作原理：
1、首先簡單解釋一下Servlet接收和響應(yīng)客戶請求的過程，首先客戶發(fā)送一個請求，Servlet是調(diào)用service()方法對請求進(jìn)行響應(yīng) 的，通過源代碼可見，service()方法中對請求的方式進(jìn)行了匹配，選擇調(diào)用doGet,doPost等這些方法，然后再進(jìn)入對應(yīng)的方法中調(diào)用邏輯層 的方法，實(shí)現(xiàn)對客戶的響應(yīng)。在Servlet接口和GenericServlet中是沒有doGet（）、doPost（）等等這些方法 的，HttpServlet中定義了這些方法，但是都是返回error信息，所以，我們每次定義一個Servlet的時候，都必須實(shí)現(xiàn)doGet或 doPost等這些方法。
2、每一個自定義的Servlet都必須實(shí)現(xiàn)Servlet的接口，Servlet接口中定義了五個方法，其中比較重要的三個方法涉及到 Servlet的生命周期，分別是上文提到的init(),service(),destroy()方法。GenericServlet是一個通用的，不 特定于任何協(xié)議的Servlet,它實(shí)現(xiàn)了Servlet接口。而HttpServlet繼承于GenericServlet，因此 HttpServlet也實(shí)現(xiàn)了Servlet接口。所以我們定義Servlet的時候只需要繼承HttpServlet即可。
3、Servlet接口和GenericServlet是不特定于任何協(xié)議的，而HttpServlet是特定于HTTP協(xié)議的類，所以 HttpServlet中實(shí)現(xiàn)了service()方法，并將請求ServletRequest、ServletResponse 強(qiáng)轉(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(jìn)行系統(tǒng)分析，在OOA分析的基礎(chǔ)上對系統(tǒng)根據(jù)面向?qū)ο蟮乃枷脒M(jìn)行系統(tǒng)設(shè)計，從而能夠直接進(jìn)行OOP面向?qū)ο缶幊獭?/span>
12.mysql分頁查詢
對于有大數(shù)據(jù)量的mysql表來說，使用LIMIT分頁存在很嚴(yán)重的性能問題。
查詢從第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
因?yàn)橐〕鏊凶侄蝺?nèi)容，第一種需要跨越大量數(shù)據(jù)塊并取出，而第二種基本通過直接根據(jù)索引字段定位后，才取出相應(yīng)內(nèi)容，效率自然大大提升。
可以看出，越往后分頁，LIMIT語句的偏移量就會越大，兩者速度差距也會越明顯。
實(shí)際應(yīng)用中，可以利用類似策略模式的方式去處理分頁，比如判斷如果是一百頁以內(nèi)，就使用最基本的分頁方式，大于一百頁，則使用子查詢的分頁方式。
Oracle查詢：SELECT * FROM (SELECT A.*, ROWNUM RN FROM (SELECT * FROM TABLE_NAME) A WHERE ROWNUM <= 40) WHERE RN >= 21
13.單例模式、工廠模式、代理模式
枚舉實(shí)現(xiàn)單例模式：
public enum Singleton {
/**
* 定義一個枚舉的元素，它就代表了Singleton的一個實(shí)例。
*/
uniqueInstance;
/**
* 單例可以有自己的操作
*/
public void singletonOperation(){
//功能處理
}
}
懶漢同步單例模式：
public class LazySingleton { private static LazySingleton instance = null;
/**
* 私有默認(rèn)構(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 閱讀(358) |
評論 (0) |
編輯 收藏- Servlet 生命周期：Servlet 加載--->實(shí)例化--->服務(wù)--->銷毀。
- init（）：在Servlet的生命周期中，僅執(zhí)行一次init()方法。它是在服務(wù)器裝入Servlet時執(zhí)行的，負(fù)責(zé)初始化Servlet 對象。可以配置服務(wù)器，以在啟動服務(wù)器或客戶機(jī)首次訪問Servlet時裝入Servlet。無論有多少客戶機(jī)訪問Servlet，都不會重復(fù)執(zhí)行 init（）。
- service（）：它是Servlet的核心，負(fù)責(zé)響應(yīng)客戶的請求。每當(dāng)一個客戶請求一個HttpServlet對象，該對象的 Service()方法就要調(diào)用，而且傳遞給這個方法一個“請求”（ServletRequest）對象和一個“響應(yīng)” （ServletResponse）對象作為參數(shù)。在HttpServlet中已存在Service()方法。默認(rèn)的服務(wù)功能是調(diào)用與HTTP請求的方法 相應(yīng)的do功能。
- destroy（）： 僅執(zhí)行一次，在服務(wù)器端停止且卸載Servlet時執(zhí)行該方法。當(dāng)Servlet對象退出生命周期時，負(fù)責(zé)釋放占用的資 源。一個Servlet在運(yùn)行service()方法時可能會產(chǎn)生其他的線程，因此需要確認(rè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工作原理：
1、首先簡單解釋一下Servlet接收和響應(yīng)客戶請求的過程，首先客戶發(fā)送一個請求，Servlet是調(diào)用service()方法對請求進(jìn)行響應(yīng) 的，通過源代碼可見，service()方法中對請求的方式進(jìn)行了匹配，選擇調(diào)用doGet,doPost等這些方法，然后再進(jìn)入對應(yīng)的方法中調(diào)用邏輯層 的方法，實(shí)現(xiàn)對客戶的響應(yīng)。在Servlet接口和GenericServlet中是沒有doGet（）、doPost（）等等這些方法 的，HttpServlet中定義了這些方法，但是都是返回error信息，所以，我們每次定義一個Servlet的時候，都必須實(shí)現(xiàn)doGet或 doPost等這些方法。
2、每一個自定義的Servlet都必須實(shí)現(xiàn)Servlet的接口，Servlet接口中定義了五個方法，其中比較重要的三個方法涉及到 Servlet的生命周期，分別是上文提到的init(),service(),destroy()方法。GenericServlet是一個通用的，不 特定于任何協(xié)議的Servlet,它實(shí)現(xiàn)了Servlet接口。而HttpServlet繼承于GenericServlet，因此 HttpServlet也實(shí)現(xiàn)了Servlet接口。所以我們定義Servlet的時候只需要繼承HttpServlet即可。
3、Servlet接口和GenericServlet是不特定于任何協(xié)議的，而HttpServlet是特定于HTTP協(xié)議的類，所以 HttpServlet中實(shí)現(xiàn)了service()方法，并將請求ServletRequest、ServletResponse 強(qiáng)轉(zhuǎn)為HttpRequest 和 HttpResponse。
創(chuàng)建Servlet對象的時機(jī)：
- 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 閱讀(292) |
評論 (0) |
編輯 收藏Arrays.sort(T[], Comparator < ? super T > c) 方法用于對象數(shù)組按用戶自定義規(guī)則排序。
Collections.sort(List<T>, Comparator < ? super T > c)方法用于對象集合按用戶自定義規(guī)則排序。
Comparable用在對象本身，說明這個對象是可以被比較的，也就是說可以被排序的。（String和Integer之所以可以比較大小，是因?yàn)樗鼈兌紝?shí)現(xiàn)了Comparable接口，并實(shí)現(xiàn)了compareTo()方法）。
Compator用在對象外，相當(dāng)于定義了一個排序算法。
還是代碼來的直接：
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é)果。
下面看對象自身實(shí)現(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()一樣的實(shí)現(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自身實(shí)現(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自身實(shí)現(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 閱讀(1118) |
評論 (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;
}
}
運(yùn)行十次輸出的結(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;
}
}
}
}
}
運(yùn)行五次輸出如下結(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 閱讀(274) |
評論 (0) |
編輯 收藏