2016年6月19日
摘要: 1財務制度題庫 單選題 1．下列各會計要素，（ ）不是反映財務狀況的會計要素。 A.資產 B.負債 C.收入 ...
閱讀全文
var ssshsj = new Date( $("#ssshsj").val().replace(/-/g,"/"));
對于Ibatis操作Date/Time/DateTime，總結如下：
將pojo的屬性類型設置為java.sql.Date（或java.sql.Time, java.sql.Timestamp），此時會嚴格遵循這三種類型的語義。但此方法因存在前文中提到的性能問題，在JDK1.6以前的JDK版本中能少使用就少使用。
如果你想在pojo中使用java.util.Date， 則要注意：
完整的日期時間，要確保jdbcType為空，或為DATE,TIME以外的值
只需要時間，要指定jdbcType=”TIME”
只需要日期，要指定jdbcType=”DATE”
final OutputStream out = new FileOutputStream("D:/EDI/EDi.zip"); //實例文件輸出流
ArchiveOutputStream os = new ArchiveStreamFactory().createArchiveOutputStream(ArchiveStreamFactory.ZIP, out);
//實例化存檔輸出流，工廠方法創(chuàng)建zip的存檔輸出流
// File f1 = new File(file.getPath());
os.putArchiveEntry(new ZipArchiveEntry(file.getName())); //生成存檔文件名
IOUtils.copy(new FileInputStream(file), os); //添加拷貝存檔文件
os.closeArchiveEntry();
os.close();
//*************************
try {
File input = new File("D:/EDI/EDi.zip");//獲得下載文件路徑
contentType="application/octet-stream";
docStream = new FileInputStream(input);//獲得輸入流名稱
contentDisposition =URLEncoder.encode(input.getName() ,"UTF-8");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "download";
WEBWORK的文件下載機制。使用起來還是比較簡單的。下面是用法說明：
首先在一個ACTION中，如果判斷有權限進行文件下載。
則：
1、讀出該下載文件，并生成一個流。 文件名應當從請求的request中讀出，或從用戶的表中取出。
public String downLoadFile(String fileName){
try {
File input = new File("e:/engilish literature.doc");
docStream = new FileInputStream(input);
contentDisposition = "test.txt";
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "download";
}
2、將輸出導向到一個特殊的RESULT中去。叫做Steam Result。
<action name="register" class="com.job2easy.web.user.RegisterAction">
<result name="success" type="dispatcher">
<param name="location">/home/register-result.jsp</param>
</result>
<result name="input">
<param name="location">/home/register.jsp</param>
</result>
<result name="download" type="stream">
<param name="contentType">application/x-msdownload</param>
<param name="inputName">docStream</param>
<param name="bufferSize">1024</param>
<param name="contentDisposition">attachment;filename="${contentDisposition}"</param>
</result>
<interceptor-ref name="params"/>
</action>
3、這中間有幾個參數(shù)需要配置：
contentType設成 application/x-msdownload 就可以。這樣瀏覽器會保證彈出一個下載文件的對話框。
inputName 這個比較重要，這個名字是輸入流的名稱， 以后要steam result的實現(xiàn)類中為根據(jù)OGNL的表達式去查找的。
contentDisposition 這個是下載之后，保存在用戶端的文件名稱。${contentDisposition} 看一下代碼。如果寫成上述的方式，就有機會在ACTION中設置文件名。
4、另外一個參數(shù)：contentLength就是下載文件的大小，webwork的stream result似乎實現(xiàn)有問題，不能根據(jù)文件的大小動態(tài)進行設置，只能寫死。
這個參數(shù)的意義是告訴瀏覽下載的文件有多大，以便瀏覽器正確的顯示進度條。如果這個功能很重要的話，可以重新寫一個RESULT來實現(xiàn)。
http://blog.csdn.net/jackfrued/article/details/44921941
數(shù)據(jù)列出來如下：
ID NAME COUR SCORE
--- ------- ---- -----
1 name_1 語文 33
1 name_1 數(shù)學 63
1 name_1 英語 71
1 name_1 歷史 68
1 name_1 化學 94
2 name_2 語文 85
2 name_2 數(shù)學 4
2 name_2 英語 98
2 name_2 歷史 9
2 name_2 化學 12
3 name_3 語文 49
3 name_3 數(shù)學 96
3 name_3 英語 30
3 name_3 歷史 60
3 name_3 化學 2
要實現(xiàn)的行轉列的效果如下(或者類似的結果)：
ID NAME SCORES
--- ------- --------------------
1 name_1 33,63,71,94,68
2 name_2 85,4,98,12,9
3 name_3 49,2,60,96,30
通過case表達式
select id,name,sum(case when course='語文' then score end) "語文",
sum(case when course='數(shù)學' then score end) "數(shù)學",
sum(case when course='英語' then score end) "英語",
sum(case when course='歷史' then score end) "歷史",
sum(case when course='化學' then score end) "化學"
from HANG2LIE
group by id,name;
union有去重功能：
結構如下：
ID NAME Chinese Math English History Chemistry
--- ------- ---------- ---------- ---------- ---------- ----------
2 name_2 85 4 98 9 12
1 name_1 33 63 71 68 94
3 name_3 49 96 30 60 2
我們要實現(xiàn)如下的查詢效果：列轉行
ID NAME COUR SCORE
--- -------- ---- -----
2 name_2 語文 85
1 name_1 語文 33
3 name_3 語文 49
2 name_2 數(shù)學 4
1 name_1 數(shù)學 63
3 name_3 數(shù)學 96
2 name_2 英語 98
1 name_1 英語 71
3 name_3 英語 30
2 name_2 歷史 9
1 name_1 歷史 68
3 name_3 歷史 60
2 name_2 化學 12
1 name_1 化學 94
3 name_3 化學 2
1、集合查詢
實現(xiàn)的SQL語句：
select id,name,'語文' course,chinese score from lie2hang
union
select id,name,'數(shù)學' course,math score from lie2hang
union
select id,name,'英語' course,english score from lie2hang
union
select id,name,'歷史' course,history score from lie2hang
union
select id,name,'化學' course,chemistry score from lie2hang;
select * from (select A.*, rownum rn from T_CD_LOC A where rownum > 20) where rn <41 錯
select * from (select t.* ,rownum rn from T_CD_LOC t where rownum<=40) where rn>=20 對
firstIndex=0
pageNumber
pageSize=20
select * from (select A.*,rownum rn from T_CD_LOC a where rownum < ((firstIndex+pageNumber+1)*pageSize) where rn >((firstIndex+pageNumber)*pageSize)
js被緩存了，加控制版本 <script src="../lib_js/paymentplan.js?v=1"></script>
摘要: EhCache 分布式緩存/緩存集群開發(fā)環(huán)境：System：WindowsJavaEE Server：tomcat5.0.2.8、tomcat6JavaSDK： jdk6+IDE：eclipse、MyEclipse 6.6 開發(fā)依賴庫：JDK6、 JavaEE5、ehcache-core-2.5.2.jarEmail：hoojo_@126.comBlog：http://blog.csdn...
閱讀全文
3、JConsole監(jiān)控
JMX(Java Management Extensions)是一個為應用程序植入管理功能的框架。JMX是一套標準的代理和服務，實際上，用戶可以在任何Java應用程序中使用這些代理和服務實現(xiàn)管理。可以利用JDK的JConsole來訪問Tomcat JMX接口實施監(jiān)控，具體步驟如下：
1）首先，打開Tomcat5的bin目錄中的catalina.bat文件，添加：
JAVA_OPTS="-Xms512m -Xmx512m -Xmn256m -XX:PermSize=64m -XX:MaxPermSize=64m -Djava.rmi.server.hostname=192.168.222.132 -Dcom.sun.management.jmxremote.port=1090 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"
-Dcom.sun.management.jmxremote：代表開啟JMX的管理功能
2）重啟tomcat，并查看監(jiān)控端口（上面配置的1090）是否已啟動
3）打開jdk的bin目錄（如C:\Program Files\Java\jdk1.7.0_17\bin）下的JConsole，并輸入iP和監(jiān)控端口進行連接
監(jiān)控結果：
http://www.itzhai.com/hibernate-one-to-many-association-mapping-configuration-and-the-cascade-delete-problem.html首先舉一個簡單的一對多雙向關聯(lián)的配置：
一的一端：QuestionType類
package com.exam.entity;
import java.util.Set;
public class QuestionType {
private String typeName;
private char typeUniqueness;
private Set quesion;
public String getTypeName() {
return typeName;
}
public void setTypeName(String typeName) {
this.typeName = typeName;
}
public char getTypeUniqueness() {
return typeUniqueness;
}
public void setTypeUniqueness(
char typeUniqueness) {
this.typeUniqueness = typeUniqueness;
}
public Set getQuesion() {
return quesion;
}
public void setQuesion(Set quesion) {
this.quesion = quesion;
}
}
配置文件：
<hibernate-mapping
package="com.exam.entity">
<
class name="QuestionType" table="exam_question_type">
<id name="typeName" column="type_name"></id>
<property name="typeUniqueness" column="type_uniqueness"/>
<set name="quesion" inverse="true" cascade="delete">
<key column="question_type_name"/>
<one-to-many
class="Question"/>
</set>
</
class>
</hibernate-mapping>
多的一端：Question類
package com.exam.entity;
import java.util.Date;
public class Question {
private int questionNo;
private QuestionType questionType;
private String questionsTitle;
public int getQuestionNo() {
return questionNo;
}
public void setQuestionNo(
int questionNo) {
this.questionNo = questionNo;
}
public QuestionType getQuestionType() {
return questionType;
}
public void setQuestionType(QuestionType questionType) {
this.questionType = questionType;
}
public String getQuestionsTitle() {
return questionsTitle;
}
public void setQuestionsTitle(String questionsTitle) {
this.questionsTitle = questionsTitle;
}
}
配置文件：
<hibernate-mapping
package="com.exam.entity">
<
class name="Question" table="exam_question">
<id name="questionNo" column="question_no" >
<generator
class="increment" />
</id>
<many-to-one name="questionType" column="question_type_name"/>
<property name="questionsTitle" column="questions_title" length="200" />
</
class>
</hibernate-mapping>
首先說明一下一些常用的屬性：
<many-to-one>元素包含以下屬性：
name：設定映射的持久化類的屬性名
column：設定和持久化類的屬性對應的表的外鍵
class：設定持久化類的屬性的類型
cascade：設定是否級聯(lián)
lazy：設定是否延遲加載
<set>元素包含以下屬性：
name：設定映射的持久化類的屬性名
cascade：設置是否級聯(lián)
inverse：設定反向控制，如果為true則一的一端不維護外鍵
<key>：設定與所關聯(lián)的持久化類對應的表的外鍵。
one-to-many：設定所關聯(lián)的持久化類
如果要對一對多關聯(lián)映射進行級聯(lián)刪除，可以按照上面的舉例進行配置：
首先看到一的一端：
<set name="quesion" inverse="true" cascade="delete">
<key column="question_type_name"/>
<one-to-many
class="Question"/>
</set>
這里設置inverse表示一的一端不維護外鍵，設置cascade=”delete”表示刪除一的一端時對關聯(lián)到得多的所有的對象也一起刪除
再看到多的一端：
<many-to-one name="questionType" column="question_type_name"/>
這里的column表示外鍵的名，需要和一的一端設置的key標簽里的column保持一致，表示維護同一個鍵值。
可以按照如下的代碼執(zhí)行刪除操作：
session.beginTransaction();
QuestionType questionType = (QuestionType) session.load(QuestionType.
class, "判斷題");
session.delete(questionType);
session.getTransaction().commit();
這里使用load查上來的對象是持久狀態(tài)的（Persistent），只有是Persistent狀態(tài)的對象才可以使用session.delete()操作進行級聯(lián)刪除，由new創(chuàng)建的對象屬于Transient狀態(tài)，不能進行session.delete()操作。
需要先刪子表，再刪除主表，否則報錯
好文章
http://www.itzhai.com/hibernate-one-to-many-association-mapping-configuration-and-the-cascade-delete-problem.html
http://blog.csdn.net/itcareerist/article/details/5896143
http://www.cnblogs.com/xdp-gacl/p/4261895.html
http://www.ibm.com/developerworks/cn/linux/l-cn-socketftp/
http://blog.csdn.net/sweetsnow24/article/details/7447110
http://jingyan.baidu.com/article/b7001fe1738d9a0e7282dda6.html
http://wenku.baidu.com/link?url=YjPcc8q-E9jnAEqsEJQZ7juMw8TICa0q9ppU3ICqEyQJBl4JGQynegQT03DQA0oyA-CxGAtDKJ_pvuvo3prfVeLEsxzC7VUWjWMsQVAxht_
問題1：XML是什么？
答：XML即可擴展標記語言（Extensible Markup language），你可以根據(jù)自己的需要擴展XML。XML中可以輕松定義
, 等自定義標簽，而在HTML等其他標記語言中必須使用預定義的標簽，比如，而不能使用用戶定義的標簽。使用DTD和XML Schema標準化XML結構。XML主要用于從一個系統(tǒng)到另一系統(tǒng)的數(shù)據(jù)傳輸，比如企業(yè)級應用的客戶端與服務端。
問題2：DTD與XML Schema有什么區(qū)別？
答：DTD與XML Schema有以下區(qū)別：DTD不使用XML編寫而XML Schema本身就是xml文件，這意味著XML解析器等已有的XML工具可以用來處理XML Schema。而且XML Schema 是設計于DTD之后的，它提供了更多的類型來映射xml文件不同的數(shù)據(jù)類型。DTD即文檔類型描述（Document Type definition）是定義XML文件結構的傳統(tǒng)方式。
問題3：XPath是什么？
答：XPath是用于從XML文檔檢索元素的XML技術。XML文檔是結構化的，因此XPath可以從XML文件定位和檢索元素、屬性或值。從數(shù)據(jù)檢索方面來說，XPath與SQL很相似，但是它有自己的語法和規(guī)則。
問題4：XSLT是什么?
答：XSLT也是常用的XML技術，用于將一個XML文件轉換為另一種XML，HTML或者其他的格式。XSLT為轉換XML文件詳細定義了自己的語法，函數(shù)和操作符。通常由XSLT引擎完成轉換，XSLT引擎讀取XSLT語法編寫的XML樣式表或者XSL文件的指令。XSLT大量使用遞歸來執(zhí)行轉換。一個常見XSLT使用就是將XML文件中的數(shù)據(jù)作為HTML頁面顯示。XSLT也可以很方便地把一種XML文件轉換為另一種XML文檔。
問題5：什么是XML元素和屬性
答：最好舉個例子來解釋。下面是簡單的XML片斷。
Xml代碼
6758.T
2300
例子中id是元素的一個屬性，其他元素都沒有屬性。
問題6：什么是格式良好的XML
答：這個問題經常在電話面試中出現(xiàn)。一個格式良好的XML意味著該XML文檔語法上是正確的，比如它有一個根元素，所有的開放標簽合適地閉合，屬性值必須加引號等等。如果一個XML不是格式良好的，那么它可能不能被各種XML解析器正確地處理和解析。
問題7：XML命名空間是什么？它為什么很重要？
答：XML命名空間與Java的package類似，用來避免不同來源名稱相同的標簽發(fā)生沖突。XML命名空間在XML文檔頂部使用xmlns屬性定義，語法為xmlns:prefix=’URI’。prefix與XML文檔中實際標簽一起使用。下面例子為XML命名空間的使用。
Xml代碼
837363223
問題8：DOM和SAX解析器有什么區(qū)別
答：這又是一道常見面試題，不僅出現(xiàn)在XML面試題中，在Java面試中也會問到。DOM和SAX解析器的主要區(qū)別在于它們解析XML文檔的方式。使用DOM解析時，XML文檔以樹形結構的形式加載到內存中，而SAX是事件驅動的解析器。
問題9：XML CDATA是什么
答：這道題很簡單也很重要，但很多編程人員對它的了解并不深。CDATA是指字符數(shù)據(jù)，它有特殊的指令被XML解析器解析。XML解析器解析XML文檔中所有的文本，比如This is name of person，標簽的值也會被解析，因為標簽值也可能包含XML標簽，比如First Name。CDATA部分不會被XML解析器解析。
問題10：Java的XML數(shù)據(jù)綁定是什么
答：Java的XML綁定指從XML文件中創(chuàng)建類和對象，使用Java編程語言修改XML文檔。XML綁定的Java API，JAXB提供了綁定XML文檔和Java對象的便利方式。另一個可選的XML綁定方法是使用開源庫，比如XML Beans。Java中XML綁定的一個最大的優(yōu)勢就是利用Java編程能力創(chuàng)建和修改XML文檔。
以上的XML面試問答題收集自很多編程人員，但它們對于使用XML技術的每個人都是有用的。由于XML具有平臺獨立的特性，XPath，XSLT，XQuery等XML技術越來越重要。盡管XML有冗余和文檔體積大等缺點，但它在web服務以及帶寬、速率作為次要考慮因素的系統(tǒng)間數(shù)據(jù)傳輸起很大作用，被廣泛用于跨平臺數(shù)據(jù)傳輸。
http://www.cnblogs.com/qanholas/p/3904833.html
SQL SERVER 理論上有32767個邏輯連接，SQL SERVER根據(jù)系統(tǒng)自行調配連接池。
首先 ，操作系統(tǒng)的用戶數(shù)：即同時通過網絡連接到這臺電腦上面的用戶限制，以5用戶操作系統(tǒng)，搭建的文件服務器為例，去同時訪問這個文件服務器的網絡用戶為5個。
下面說說SQL server,購買數(shù)據(jù)庫有兩種方式，1、根據(jù)用戶數(shù)購買。2、根據(jù)cpu個數(shù)購買。
根據(jù)用戶數(shù)購買，假如你購買了一個50用戶的數(shù)據(jù)庫，那么可以通過網絡訪問數(shù)據(jù)庫的人數(shù)限制為50。
根據(jù)cpu個數(shù)購買的數(shù)據(jù)庫訪問人數(shù)不受限制，服務器上面有幾顆cpu就要買幾個授權的SQL server,但是如果你只買一個授權的話數(shù)據(jù)庫也可以正常運行，但是微軟認為你的數(shù)據(jù)庫不合法。就如同盜版系統(tǒng)。
一個連接不等于一個用戶，單獨一個用戶可以有超過一個的連接，單獨一個連接可以有超過一個用戶。
你可以運行里面輸入perfmon，然后加入下面兩個計數(shù)器進行對比
SQLServer: General Statistics — Logical Connections:與系統(tǒng)建立的邏輯連接數(shù)。SQLServer: General Statistics — User Connections:連接到系統(tǒng)的用戶數(shù)。
打個比喻
sql server是你家的房子
用戶數(shù) 是你家房子鑰匙
連接數(shù) 是你家房子能進去的人
不是很恰當，但是基本能說明問題
一個房子有多少個鑰匙是明確的，但是每個鑰匙是可以讓多個人進去
也就是說，sql server的用戶是可以登陸sql server進行操作的，而連接數(shù)指的是使用某個用戶名登陸的為了執(zhí)行某個具體操作的一個連接。
通常一個SQL SERVER 查詢器，一個ADOCONNECTION是一個連接。
在SQL Server里查看當前連接的在線用戶數(shù)
use master
select loginame,count(0) from sysprocesses
group by loginame
order by count(0) desc
select nt_username,count(0) from sysprocesses
group by nt_username
order by count(0) desc
如果某個SQL Server用戶名test連接比較多,查看它來自的主機名:
select hostname,count(0) from sysprocesses where loginame='test'
group by hostname
order by count(0) desc
如果某個SQL Server用戶名test連接比較多,查看它最后一次操作的時間范圍分組:
select convert(varchar,last_batch,111),count(0) from sysprocesses where loginame='test'
group by convert(varchar,last_batch,111)
order by count(0) desc
如果從主機(www)來的連接比較多,可以查看它的進程詳細情況
select * from??sysprocesses where hostname='www'
如果www機器主要提供網頁服務,可能是asp程序處理連接時出了問題, 生成殺這些進程的SQL語句:
select 'kill '+convert(varchar,spid) from sysprocesses where hostname='www'
如果這樣的問題頻繁出現(xiàn),可以寫一個存儲過程sp_KillIdleSpids.sql,
寫一個作業(yè), 執(zhí)行它, 來自動殺掉從主機(www)來但已經一天沒有響應的用戶連接.
?
?
?
--------------------------------
SQL Server的用戶及權限?
?sysadmin 可以在 SQL Server 中執(zhí)行任何活動?
serveradmin 可以設置服務器范圍的配置選項 關閉服務器?
setupadmin 可以管理鏈接服務器和啟動過程?
securityadmin 可以管理登錄和 CREATE DATABASE 權限 還可以讀取錯誤日志和更改密碼?
processadmin 可以管理在 SQL Server 中運行的進程?
dbcreator 可以創(chuàng)建 更改和除去數(shù)據(jù)庫?
diskadmin 可以管理磁盤文件?
bulkadmin 可以執(zhí)行 BULK INSERT 語句? ......
最大連接數(shù)是指數(shù)據(jù)庫能承受的最大并發(fā)訪問數(shù)量
SQL Server的并發(fā)用戶數(shù)或者license怎么理解？ 華軟論壇 2005-12-06 13:38:55 在 MS-SQL Server / 基礎類 提問
盜版的有并發(fā)用戶數(shù)的限制嗎？正版好像有10用戶，50用戶的版本，如果用C/S架構的話，每個客戶端連接算不算一個用戶？
后來有段時間好像改到 只按CPU購買License了。現(xiàn)在又好像見到購買連接數(shù)的license.
講了這么一堆，想告訴你的是，如果你只有10用戶的License，其實也是沒有限制的。這是微軟的市場人員親口告訴我的。 [華 軟 網]
歡迎轉載，但請保留出處，本文章轉自[華軟網] 原文鏈接：http://www.huarw.com/db/dbbbs/MSSQLServer/200512/735120.html
你指的是購買許可吧？
SQL 提供3種購買方式
1) Processor license. (按CPU購買)
要求為運行SQL Server 2000的操作系統(tǒng)上的每個CPU購買許可. 這種方式不需要購買客戶端訪問許可.
2) Server plus device CALs. (服務器許可加每設備客戶端訪問許可)
運行SQL Server 2000的服務器需要一個許可, 每個訪問SQL Server 2000的設備需要一個客戶端訪問許可.
3) Server plus user CALs. (服務器許可加每用戶客戶端訪問許可)
運行SQL Server 2000的服務器需要一個許可, 每個訪問SQL Server 2000的用戶需要一個客戶端訪問許可
2、每客戶
每客戶授權模式要求每個將訪問 SQL Server 2000 服務器的設備都具有一個客戶端訪問許可證。對于客戶端連接到不止一個服務器的網絡，每客戶模式通常更劃算。
在編輯框中，選擇要授權的設備數(shù)。
選擇授權模式：
使用該對話框設置授權模式，以使客戶端可以訪問 Microsoft? SQL Server? 的該實例。SQL Server 2000 支持兩種客戶端訪問授權模式，一個用于設備，另一個用于處理器。
設備可以是工作站、終端或運行連接到 SQL Server 實例的 SQL Server 應用程序的任何其它設備。
處理器指的是安裝在運行 SQL Server 2000 實例的計算機上的中央處理器 (CPU)。一個計算機上可以安裝多個處理器，從而需要多個處理器許可證。
一旦設置了授權模式便無法再更改。可以在安裝 SQL Server 之后添加設備或處理器許可證，這使用 "控制面板 "中的 SQL Server 2000 授權安裝實用工具來進行。
1、授權模式
當從 "控制面板 "訪問該對話框時，安裝過程中選擇的模式在默認情況下為選中，同時顯示以前選擇的設備數(shù)或處理器數(shù)。
2、每客戶
每客戶授權模式要求每個將訪問 SQL Server 2000 服務器的設備都具有一個客戶端訪問許可證。對于客戶端連接到不止一個服務器的網絡，每客戶模式通常更劃算。
在編輯框中，選擇要授權的設備數(shù)。
3、處理器許可證
使用處理器許可，安裝在運行 SQL Server 的計算機上的每個處理器都需要一個許可證。處理器許可證允許任意數(shù)目的設備訪問服務器，無論它們是通過 Intranet 還是 Internet。
使用處理器許可，SQL Server 2000 可以利用每個安裝的處理器，并支持不限數(shù)目的客戶端設備。通過 Internet 提供對 SQL Server 數(shù)據(jù)庫的訪問的客戶或擁有大量用戶的客戶通常選擇處理器許可證。
在編輯框中選擇要授權的處理器數(shù)。
SQL Server安裝成功后，重起計算機后SQL Server自動啟動服務。
10用戶不是指的連接用戶
在創(chuàng)建自定義控制臺時，可以給控制臺指派兩種常用訪問選項中的一種：作者模式或用戶模式。依次有三個級別的用戶模式，因此共有四種默認訪問控制臺的選項：
作者模式
用戶模式－完全訪問
用戶模式－受限訪問，多窗口
用戶模式－受限訪問，單窗口
你安裝的是企業(yè)版,10個客戶端是指你能夠在別的機子上只能安裝10個Sql客戶端同它連接
http://i-lolo.iteye.com/blog/1611562
在進入網絡通信之前，讓我們來普及一點網絡基礎概念。如果你是有一定的計算機網絡基礎，請直接跳到第五點之后開始閱讀。
第一、 什么是計算機網絡？
書本上那些文縐縐的概念我們可以不去理，我告訴你，我們兩臺電腦連在一起就組成了一個計算機網絡。其實我們的電腦甚至是全世界的電腦都是連著的，只要你的電腦連著網，你就在這個巨大的計算機網絡里，你也許會問為什么我和他們是連著的啊？大家知道自己是怎么上的網？ADSL是吧，撥號上網。換個比方說吧，我們在公司我們的電腦通過網線，雙絞線，然后是Hub（集線器），連接到胡哥的電腦，然后胡哥的機子通過撥號，ADSL，連到電信的網關那兒，然后中國電信通過海底光纜和美國電信網關連接，然后再像剛剛我們連接中國電信一樣，逆推過去，連接到美國每一臺聯(lián)網的計算機。所以說只要你連著網，你就是和全世界的在線用戶連著。這是一個巨大的計算機網絡。非常巨大。
第二、 計算機網絡的主要功能？
資源共享、信息傳輸與集中處理、均衡負荷與分布處理、綜合信息服務（www/綜合數(shù)字網絡 ISDN）。這些個功能，不多說。這些你不平時都在用么？你的資源能夠上傳共享給其他人，有的人平時還很喜歡聊QQ，是吧，所以上面說的這四個也許還有更多的什么功能都是些冠冕堂皇的話，稍微看下就好。用了自然就曉得了。
第三、 什么是網絡通信協(xié)議？
我來問你，為什么你說話身邊的人能夠聽的懂，別人說的話你為什么也能夠聽懂，而為什么如果你去對一個外國人說話或者一個外國人來和你說話你們卻互相聽不懂呢？你會說廢話嘛因為我說的是中文，是漢語，中國人說的都是漢語，而外國人說的是另一種語言，是外語。就是這樣，網絡通信協(xié)議就像我們的中文一樣，她就是我們之間的共同語言，他規(guī)定了我們之間怎么說話，我先說什么你再說什么，你怎么說，而我應該怎么聽。而網絡通信得先規(guī)定約定一些俗成的網絡通信協(xié)議，先說好，兩臺計算機之間什么收發(fā)信息，信息格式是什么，信息怎么發(fā)，怎么接收，而萬一出錯怎么辦怎么處理。沒有了這個協(xié)議，兩臺電腦就不知道互相之間怎么說話，就像你對一頭大母豬說完愛你，而人家根本就不知道你在說什么。
在這兒和大家提一下網絡協(xié)議的分層思想。學過計算機網絡的同學都知道有兩種基本的國際標準分層模型，一個是OSI參考模型，一個是TCP/IP參考模型。OSI參考模型，是國際標準化組織搞出來的開放互聯(lián)傳統(tǒng)模型，一共有七層：物理/數(shù)據(jù)鏈路/網絡/傳輸/會話/表示/應用。學網絡和硬件的一般都要熟悉這七層標準，至于這七層都是干嘛的，大家自己問度娘或者自己看關于網絡的書去。（中南大學高陽教授主編了一本叫《計算機網絡原理與實用技術》的書，里邊很詳盡的介紹了這個OSI參考模型，沒記錯的話應該是在第一章1.4.5里，是放在TCP/IP協(xié)議之后的……）這里就不多說了，因為對于咱們編程的軟件人員來說，實際當中的應用，是分為四層，也就是TCP/IP參考模型。最底層物理+數(shù)據(jù)鏈路層/網絡層/傳輸層/應用層。我們編的程序是位于應用層，所以說，我們一直是在和哪一層打交道？TCP/IP層。我們編寫一個程序發(fā)送一些數(shù)據(jù)，發(fā)給傳輸層，TCP/IP層，在這一層對數(shù)據(jù)進行封裝，按照先前約定的協(xié)議，然后走向下一層，通過網線，再走到物理數(shù)據(jù)鏈路層，這時候數(shù)據(jù)就變成了一連串的01010101，到達對面之后逆推上面的過程，進行解封，ok，信息發(fā)送完畢。這兒涉及到比較多的網絡底層，目前我們不需要過多了解，因為我們要做的工作不需要了解牽扯到到這么底層的東西，如果你想深入了解或者今后你想做殺毒軟件什么的，去讀《TCP/IP詳解》。
第四、 IP——（Internet Protocol網絡之間互連的協(xié)議）？
你不用管其他的，你只需要知道IP這個東西給我們做出的最大貢獻，就是給我們每一臺電腦提供了一個獨一無二的IP地址。你想我的機器要和你的機器交流說話，我得知道你的機器叫什么，你的機器得有一個獨一無二的區(qū)別標識，否則的話我就不知道傳的信息有沒有傳到你那兒，也不知道這信息到底傳給誰。IP地址這東西我們都知道吧？像我的本機IP: 113.240.187.242 這是湖南省長沙市的IP。他是由四個字節(jié)組成的（也就是說每一個值不能超過255）。（這個是IPV4，能夠組成將近四億多地址，現(xiàn)在已經出來了IPV6，高檔貨，八個字節(jié)，地址數(shù)是IPV4的幾何倍數(shù)）IPV4的IP地址按照其網絡IP段和主機IP段占的字節(jié)數(shù)分ABC三類網。這個這里不說，大家自己去了解，好吧？拿高陽教授的那本書翻翻。順帶看看子網掩碼啊網關啊什么的。自己去了解。在這兒我就累得給你敲了。
第五、 TCP協(xié)議和UDP協(xié)議？
好了，上一步里我們通過獨一無二的IP地址找到了對方連在了一起。我們可以通話了，關于通話我們有兩種方式：
第一、 TCP協(xié)議，什么叫TCP協(xié)議？Transmission Control Protocol 傳輸控制協(xié)議TCP是一種面向連接（連接導向）的、可靠的、基于字節(jié)流的運輸層（Transport layer）通信協(xié)議。什么叫可靠的？打個比方，我們打電話，上一步通過IP找到對方就相當于撥號打通了你的電話，你拿起電話接了，我說一句“喂？”，如果你這邊不回應，我就會杵這兒一直“喂”下去，是不？因為不知道你那邊到底接到了聽到了我的話沒有，所以你這邊一定要告訴我你聽到了你收到了我剛剛的那句信息，我才會接著給你說下面的話給你發(fā)下面的數(shù)據(jù)。我每發(fā)一次信息我要你給我確認收到了，然后我再給你發(fā)接下來的東西，這個就叫可靠。在TCP/IP協(xié)議里邊這叫“三次握手”機制。怎么握手，握手是怎么回事，問度娘，好吧？
第二、 UDP協(xié)議。User Datagram Protocol的簡稱， 中文名是用戶數(shù)據(jù)報協(xié)議，是 OSI 參考模型中一種無連接的傳輸層協(xié)議。UDP這種方式相對于TCP來說更加簡單。UDP說話就是，我給你說一句話，你聽沒聽到我不管。就像發(fā)電報，“黃河黃河我是長江！”哐當一下就發(fā)出去了。不管黃河收到沒有。兩種方式一種安全可靠但是慢，一種簡單快捷但是不可靠。根據(jù)不同的需求選擇。像我們平時聊QQ開視頻啊什么的，用的就是UDP，因為我們傳輸?shù)倪@些個數(shù)據(jù)丟個一兩個包什么的無所謂，頂多就是視頻多了幾個馬賽克，是吧。那么平時我們玩的網絡游戲，像CF啊魔獸世界啊，是哪一種呢？自己想，好吧？
第三、 中南-馬志丹 http://java-mzd.javaeye.com 驚喜看得到！
基礎普及完了，接下來我們來看看為什么要去做網絡通信。這一段我就簡單點說。在計算機剛出來那會兒 ，那時候的人們都覺得計算機這東西就是主要為計算而存在的就是一個計算工具，但是自從1983年起，TCP\IP協(xié)議的出現(xiàn)，讓計算機從此轉變?yōu)榱巳藗兊囊粋€交流工具。自那以后，只要你有一臺電腦，不管你是開網頁看電影，還是上人人找朋友，不管你是登郵箱收發(fā)郵件，還是登QQ聊天，你的生活的方方面面都離不開那電腦屏幕后邊的網絡技術。換句話說，如果沒有了網絡通信技術，電腦以及大多數(shù)軟件將會失去他們原有的生命力。就像一棵大樹沒有根。沒有網絡通信就沒有如今繁榮的QQ世界，沒有了網絡通信，世界上那些個IT巨頭諸如IBM諸如谷歌，將會如斷線風箏落日殘陽。我想說，如果你不懂網絡通信技術，你就不是一個合格的程序員，如果你不精通網絡通信技術，你就無法開發(fā)出一款真正優(yōu)秀的營運軟件！除非你想永遠停留在枯燥的單機時代，你想讓自己的技術永遠留在表層。
現(xiàn)在，讓我們來考慮如何實現(xiàn)。
在做實現(xiàn)之前，我想先讓大家明白幾個概念：
1） Socket
A. 兩個Java應用程序可通過一個雙向的網絡通信連接實現(xiàn)數(shù)據(jù)交換，這個雙向鏈路的一端稱為一個Socket
B. Socket通常用來實現(xiàn)client-server連接
C. Java.net包中定義的兩個類Socket和ServerSocket，分別用來實現(xiàn)雙向連接的client和server端
D. 建立連接時所需要的尋址信息為遠程計算機的IP地址和端口號（Port number）
上面我們提到了IP地址，那是每一臺電腦獨一無二的一個地址標識，是為了對方計算機能夠找得到你給你發(fā)信息。建立連接我們很顯然需要這個信息才能夠完成。那么這個端口號又是用來干什么的呢？舉個例子，假如說我電腦上現(xiàn)在上著人人和QQ，你的電腦上也是上著人人和QQ，如果我用QQ給你發(fā)一條消息他怎么知道就發(fā)到你的QQ上而不會在你的人人上呢？是吧？所以說光用IP地址是無法區(qū)分到不同的應用程序的。所以需要端口號來達到這個作用。端口號在計算機內部是用兩個字節(jié)來表示，也就是說總共有65536個端口。在這兒需要注意下面兩個點：
?1.1024之前的端口我們自己編的程序不要征用它，因為這些端口是給系統(tǒng)用的。比如說80端口，胡哥給咱們講過的。干嘛的？負責處理HTTP上網訪問網頁等等的端口。還有就是21端口，F(xiàn)TP的，是吧？還有其他的一些著名端口，想知道問度娘去，好吧？在這里就不羅嗦了。
?2.TCP端口和UDP端口是分開的，比如說TCP有個8888端口，他和你的UDP8888端口是不一樣的。
?3.上述每一類有65536個端口。也就是說我們的計算機能夠運行131072個程序，只要你電腦吃得消。
既然要實現(xiàn)通信，那我們肯定要確定兩個通信對象，一個是服務器對象server，一個是客戶端對象client。我們需要知道，這兩個對象是兩個應用程序，他們的對話，是兩個不同的程序之間的對話。你會說我只有兩個對象也還沒法實現(xiàn)他們之間的交互啊，不用急，我也知道他們兩個不是神仙會心有靈犀。兩個對象之間想要實現(xiàn)互相之間的信息交互，就必須要有一個通道。這個通道就像是一根管子，一頭扎在服務器端，一頭插在客戶端。信息就在這根管子里來來往往。這根管子怎么插呢，插在哪兒呢？這個時候就需要用到剛剛提到的Socket了。
Socket的意思呢就是一個插座，服務器和客戶端各有一個插座，安插在各自的一個端口上，管子插在這兩個插座上，然后在他們這兩個端口上接入數(shù)據(jù)流。Socket通常用來實現(xiàn)server-client連接。Java里面有一個包java.net，他下邊有定義了兩個類，Socket和ServerSocket，分別用來實現(xiàn)雙向連接的server端和client端。
接下來我們來建立TCP服務器端和客戶端。
服務器端：我們用的是ServerSocket，新建一個server插座，并且交給他一個端口號，這個插座他有一個非常方便的構造方法ServerSocket(int port)，讓他知道自己監(jiān)聽哪一個端口，然后新建一個socket對象，開機，并用.accept語句讓他處在待機狀態(tài)，等待接受client的接入。一旦有客戶端接入就將它賦給新建的Socket對象，并且用.getInputStream以及.getOutputStream命令獲得他的輸入輸出流。這個流，就是一根管子，信息都在這根管子里流通。這樣說東西不怎么好說，那么我們就在這個流上面再包一層，將這個流封裝成DataOutputStream(),DataInputStream。然后就可以利用輸出流（這個是相對于服務器來說，這個輸出流到了客戶端就成了輸入流了）來.write信息，利用輸入流來.read()獲取客戶端發(fā)來的信息。Ok，接收完了，.close關閉輸入輸出流，以及關閉socket，關機。
客戶端：寫法和服務器端有點類似，新建一個插座，這兒需要留意的是，客戶端需要用到的插座是Socket而不是ServerSocket，新建一個Socket牌插座，同樣用他的Socket（String host，int port）構造方法方法給他一個IP地址和端口號，讓它撥打區(qū)號以及具體電話號，這個和服務器端的IP地址以及端口號要一致，ok，這個時候server就相當于申請連接到服務器的某一個端口上了。兩個程序就等于是連接上了。但是有些人就會問了啊，這只是客戶端申請連接，人家服務器接不接受呢。好，前面我們的服務器不是提到了.accept么，這個方法就是用來接受客戶端的，這個時候就是：你申請連接，我接受連接，接下來，照著上面服務器一樣，客戶端也獲取到自己的輸入輸出流，封裝，用輸出流寫出信息。咱們之間就可以互相通信了。還有一個問題啊，要是如果有另一個客戶端接入了呢？簡單，那就再.accept一下。如果有N多客戶端接入，那就不斷的.accept，不斷循環(huán)它。這個問題大家都知道可以用while語句。
具體的敲法，請看我給大家附上的代碼實現(xiàn)。下面給大家看下Socket通信模型。看著這個模型，再回頭看看上面給大家嘮叨的那些個點，我想大家都知道服務器和客戶端該怎么去寫怎么去實現(xiàn)通信了吧？
好了，這一段“三分鐘讓你看懂”到此就結束了，想來大家對網絡通信也該有了一個相對清晰的認識。如果你還想了解學習更多的網絡通信方面的知識，如果你還想知道如何去實現(xiàn)一些更多的通信功能，比如建立公共聊天室實現(xiàn)群聊，又比如建立一個以互聯(lián)網為基礎的以網絡畫板為主體的協(xié)助平臺，又比如，你想做一個自己的軟件來實現(xiàn)像QQ一樣MSN一樣或者像人人桌面一樣的各種功能……請繼續(xù)關注我們的隨后更新。請記住，我們是ZCL，我們是一群簡單快樂的牧碼人！
后記：第一篇正兒八經的技術日志，4K多全手打，這樣說起來應該蠻自豪的感覺。但是說實話還是覺得自己寫的有些亂。自己只是把課堂上老師們講的一些知識點，根據(jù)自己敲的代碼以及做了的一些課堂筆記，羅列了出來。也查了一些在線資料和書籍，像度娘，像學校發(fā)的那本我都沒怎么動過的《計算機網絡原理和實用技術》。在前面花了好些篇幅來講計算機網絡基礎知識，是因為我給自己定下的目標就是讓任何一個人甚至你是沒怎么學過接觸過java或者計算機網絡這一塊，看了我的博客之后，都能夠對網絡通信有一個比較清晰的認識，而讓接觸過java的人知道怎么樣初步的去實現(xiàn)兩個軟件或者說程序之間的通信，知道他們之間是怎么回事兒并且自己動手實現(xiàn)它。這確實是一個有點難度的過程。但是你如果把這個都搞定了，那么，你的java網絡通信就基本可以說入了一個門了。我似乎聽見了胡哥用他那一慣的口吻在我身后說，這種程度，要說入門還早的很呢！當然咯，就算我現(xiàn)在做到網絡畫圖板做到網絡文件傳輸，也感覺自己只是進了一個門，門后的世界無比之大，等待我們不斷的去探索，去創(chuàng)新，去創(chuàng)造它。生命有限，學海無涯；人有老時，學無止境嘛。發(fā)現(xiàn)的問題蠻多。但獲得的收獲也不少。果然檢驗自己是否學會掌握一個東西的最好辦法就是嘗試著去教給別人。只有你能夠很清晰的把事兒給別人說清楚了教會了，你才能說自己懂了。寫完這篇博客，感覺自己對網絡通信的理解又加深了一些，對其中的一些知識點的掌握也更加牢靠了一些。只言片語薄聞淺見，希望大家多多批評不吝賜教！
最后的最后：用胡哥的一句話來與君共勉吧！
標準即平庸，合格即廢物。
（附）服務器端代碼：
Java代碼 收藏代碼
package con120722;
import java.net.*;
import java.io.*;
public class Server
{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server()
{
try
{
ss = new ServerSocket(10000);
while (true)
{
socket = ss.accept();
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
String line = in.readLine();
out.println("you input is :" + line);
out.close();
in.close();
socket.close();
}
}
catch (IOException e)
{}
}
public static void main(String[] args)
{
new Server();
}
}
客戶端代碼：
Java代碼 收藏代碼
package con120722;
Java代碼 收藏代碼
import java.io.*;
import java.net.*;
public class Client
{
Socket socket;
BufferedReader in;
PrintWriter out;
public Client()
{
try
{
socket = new Socket("localhost", 10000);
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
BufferedReader line = new BufferedReader(new InputStreamReader(System.in));
out.println(line.readLine());
line.close();
out.close();
in.close();
socket.close();
}
catch (IOException e)
{}
}
public static void main(String[] args)
{
new Client();
}
}
http://www.cnblogs.com/mingforyou/archive/2012/03/03/2378143.html
http://www.educity.cn/wenda/450855.html
Eclipse崩潰，錯誤提示：
MyEclipse has detected that less than 5% of the 64MB of Perm
Gen (Non-heap memory) space remains. It is strongly recommended
that you exit and restart MyEclipse with new virtual machine memory
paramters to increase this memory. Failure to do so can result in
data loss. The recommended Eclipse memory parameters are:
eclipse.exe -vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M
1.參數(shù)的含義
-vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M
-vmargs 說明后面是VM的參數(shù)，所以后面的其實都是JVM的參數(shù)了
-Xms128m JVM初始分配的堆內存
-Xmx512m JVM最大允許分配的堆內存，按需分配
-XX:PermSize=64M JVM初始分配的非堆內存
-XX:MaxPermSize=128M JVM最大允許分配的非堆內存，按需分配
我們首先了解一下JVM內存管理的機制，然后再解釋每個參數(shù)代表的含義。
1)堆(Heap)和非堆(Non-heap)內存
按照官方的說法：“Java 虛擬機具有一個堆，堆是運行時數(shù)據(jù)區(qū)域，所有類實例和數(shù)組的內存均從此處分配。堆是在 Java 虛擬機啟動時創(chuàng)建的。”“在JVM中堆之外的內存稱為非堆內存(Non-heap memory)”。
可以看出JVM主要管理兩種類型的內存：堆和非堆。簡單來說堆就是Java代碼可及的內存，是留給開發(fā)人員使用的；非堆就是JVM留給自己用的，
所以方法區(qū)、JVM內部處理或優(yōu)化所需的內存(如JIT編譯后的代碼緩存)、每個類結構(如運行時常數(shù)池、字段和方法數(shù)據(jù))以及方法和構造方法的代碼都在非堆內存中。
堆內存分配
JVM初始分配的堆內存由-Xms指定，默認是物理內存的1/64；JVM最大分配的堆內存由-Xmx指定，默認是物理內存的1/4。默認空余堆內存小于40%時，JVM就會增大堆直到-Xmx的最大限制；
空余堆內存大于70%時，JVM會減少堆直到-Xms的最小限制。因此服務器一般設置-Xms、-Xmx 相等以避免在每次GC 后調整堆的大小。
說明：如果-Xmx 不指定或者指定偏小，應用可能會導致java.lang.OutOfMemory錯誤，此錯誤來自JVM，不是Throwable的，無法用try...catch捕捉。
非堆內存分配
JVM使用-XX:PermSize設置非堆內存初始值，默認是物理內存的1/64；由XX:MaxPermSize設置最大非堆內存的大小，默認是物理內存的1/4。（還有一說：MaxPermSize缺省值和-server -client選項相關，
-server選項下默認MaxPermSize為64m，-client選項下默認MaxPermSize為32m。這個我沒有實驗。）
上面錯誤信息中的PermGen space的全稱是Permanent Generation space，是指內存的永久保存區(qū)域。還沒有弄明白PermGen space是屬于非堆內存，還是就是非堆內存，但至少是屬于了。
XX:MaxPermSize設置過小會導致java.lang.OutOfMemoryError: PermGen space 就是內存益出。
說說為什么會內存益出：
（1）這一部分內存用于存放Class和Meta的信息，Class在被 Load的時候被放入PermGen space區(qū)域，它和存放Instance的Heap區(qū)域不同。
（2）GC(Garbage Collection)不會在主程序運行期對PermGen space進行清理，所以如果你的APP會LOAD很多CLASS 的話,就很可能出現(xiàn)PermGen space錯誤。
這種錯誤常見在web服務器對JSP進行pre compile的時候。
2)JVM內存限制(最大值)
首先JVM內存限制于實際的最大物理內存，假設物理內存無限大的話，JVM內存的最大值跟操作系統(tǒng)有很大的關系。簡單的說就32位處理器雖然可控內存空間有4GB,但是具體的操作系統(tǒng)會給一個限制，
這個限制一般是2GB-3GB（一般來說Windows系統(tǒng)下為1.5G-2G，Linux系統(tǒng)下為2G-3G），而64bit以上的處理器就不會有限制了。
2. 為什么有的機器我將-Xmx和-XX:MaxPermSize都設置為512M之后Eclipse可以啟動，而有些機器無法啟動？
通過上面對JVM內存管理的介紹我們已經了解到JVM內存包含兩種：堆內存和非堆內存，另外JVM最大內存首先取決于實際的物理內存和操作系統(tǒng)。所以說設置VM參數(shù)導致程序無法啟動主要有以下幾種原因：
1) 參數(shù)中-Xms的值大于-Xmx，或者-XX:PermSize的值大于-XX:MaxPermSize；
2) -Xmx的值和-XX:MaxPermSize的總和超過了JVM內存的最大限制，比如當前操作系統(tǒng)最大內存限制，或者實際的物理內存等等。說到實際物理內存這里需要說明一點的是，
如果你的內存是1024MB，但實際系統(tǒng)中用到的并不可能是1024MB，因為有一部分被硬件占用了。
3. 為何將上面的參數(shù)寫入到eclipse.ini文件Eclipse沒有執(zhí)行對應的設置？
那為什么同樣的參數(shù)在快捷方式或者命令行中有效而在eclipse.ini文件中是無效的呢？這是因為我們沒有遵守eclipse.ini文件的設置規(guī)則：
參數(shù)形如“項 值”這種形式，中間有空格的需要換行書寫，如果值中有空格的需要用雙引號包括起來。比如我們使用-vm C:/Java/jre1.6.0/bin/javaw.exe參數(shù)設置虛擬機，
在eclipse.ini文件中要寫成這樣：
-vm
C:/Java/jre1.6.0/bin/javaw.exe
-vmargs
-Xms128M
-Xmx512M
-XX:PermSize=64M
-XX:MaxPermSize=128M
實際運行的結果可以通過Eclipse中“Help”-“About Eclipse SDK”窗口里面的“Configuration Details”按鈕進行查看。
另外需要說明的是，Eclipse壓縮包中自帶的eclipse.ini文件內容是這樣的：
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
-vmargs
-Xms40m
-Xmx256m
其中–launcher.XXMaxPermSize（注意最前面是兩個連接線）跟-XX:MaxPermSize參數(shù)的含義基本是一樣的，我覺得唯一的區(qū)別就是前者是eclipse.exe啟動的時候設置的參數(shù)，
而后者是eclipse所使用的JVM中的參數(shù)。其實二者設置一個就可以了，所以這里可以把–launcher.XXMaxPermSize和下一行使用#注釋掉。
4. 其他的啟動參數(shù)。 如果你有一個雙核的CPU，也許可以嘗試這個參數(shù):
-XX:+UseParallelGC
讓GC可以更快的執(zhí)行。（只是JDK 5里對GC新增加的參數(shù)）
補充：
如果你的WEB APP下都用了大量的第三方jar，其大小超過了服務器jvm默認的大小，那么就會產生內存益出問題了。
解決方法： 設置MaxPermSize大小
可以在myelipse里選中相應的服務器比如tomcat5，展開里面的JDK子項頁面，來增加服務器啟動的JVM參數(shù)設置：
-Xms128m
-Xmx256m
-XX:PermSize=128M
-XX:MaxNewSize=256m
-XX:MaxPermSize=256m
或者手動設置MaxPermSize大小,比如tomcat，
修改TOMCAT_HOME/bin/catalina.bat，在echo "Using CATALINA_BASE: $CATALINA_BASE"上面加入以下行：
JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
建議：將相同的第三方jar文件移置到tomcat/shared/lib目錄下，這樣可以減少jar 文檔重復占用內存
1.JVM內存管理的機制
內存空間劃分為：Sun JDK在實現(xiàn)時遵照JVM規(guī)范，將內存空間劃分為堆、JVM方法棧、方法區(qū)、本地方法棧、PC寄存器。
堆： 堆用于存儲對象實例及數(shù)組值，可以認為Java中所有通過new創(chuàng)建的對象的內存都在此分配，Heap中對象所占用的內存由GC進行回收，在32位操作系統(tǒng)上最大為2GB，在64位操作系統(tǒng)上則沒有限制，其大小可通過-Xms和-Xmx來控制，-Xms為JVM啟動時申請的最小Heap內存，默認為物理內存的1/64但小于1GB；-Xmx為JVM可申請的最大Heap內存，默認為物理內存的1/4但小于1GB，默認當空余堆內存小于40%時，JVM會增大Heap到-Xmx指定的大小，可通過-XX:MinHeapFreeRatio=來指定這個比例；當空余堆內存大于70%時，JVM會減小Heap的大小到-Xms指定的大小，可通過-XX:MaxHeapFreeRatio=來指定這個比例，對于運行系統(tǒng)而言，為避免在運行時頻繁調整Heap 的大小，通常將-Xms和-Xmx的值設成一樣。
JVM方法棧： 為線程私有，其在內存分配上非常高效。當方法運行完畢時，其對應的棧幀所占用的內存也會自動釋放。當JVM方法棧空間不足時，會拋出StackOverflowError的錯誤，在Sun JDK中可以通過-Xss來指定其大小。
方法區(qū)： 要加載的類的信息（名稱、修飾符等）、類中的靜態(tài)變量、類中定義為final類型的常量、類中的Field信息、類中的方法信息。方法區(qū)域也是全局共享的，在一定條件下它也會被GC，當方法區(qū)域要使用的內存超過其允許的大小時，會拋出OutOfMemory的錯誤信息。在Sun JDK中這塊區(qū)域對應Permanet Generation，又稱為持久代，默認最小值為16MB，最大值為64MB，可通過-XX:PermSize及-XX:MaxPermSize來指定最小值和最大值。
本地方法棧： 用于支持native方法的執(zhí)行，存儲了每個native方法調用的狀態(tài)。在Sun JDK的實現(xiàn)中，和JVM方法棧是同一個。
PC寄存器： 占用的可能為CPU寄存器或操作系統(tǒng)內存。
2.Java堆和棧的區(qū)別
Java把內存劃分成兩種：一種是棧內存，一種是堆內存。
在函數(shù)中定義的一些基本類型的變量和對象的引用變量都在函數(shù)的棧內存中分配。當在一段代碼塊定義一個變量時，Java就在棧中為這個變量分配內存空間，當超過變量的作用域后，Java會自動釋放掉為該變量所分配的內存空間，該內存空間可以立即被另作他用。
堆內存用來存放由new創(chuàng)建的對象和數(shù)組。在堆中分配的內存，由Java虛擬機的自動垃圾回收器來管理。在堆中產生了一個數(shù)組或對象后，還可以在棧中定義一個特殊的變量，讓棧中這個變量的取值等于數(shù)組或對象在堆內存中的首地址，在棧中的這個特殊的變量就變成了數(shù)組或者對象的引用變量，以后就可以在程序中使用棧內存中的引用變量來訪問堆中的數(shù)組或者對象，引用變量相當于為數(shù)組或者對象起的一個別名，或者代號。
引用變量是普通變量，定義時在棧中分配內存，引用變量在程序運行到作用域外釋放。而數(shù)組＆對象本身在堆中分配，即使程序運行到使用new產生數(shù)組和對象的語句所在地代碼塊之外，數(shù)組和對象本身占用的堆內存也不會被釋放，數(shù)組和對象在沒有引用變量指向它的時候，才變成垃圾，不能再被使用，但是仍然占著內存，在隨后的一個不確定的時間被垃圾回收器釋放掉。這個也是java比較占內存的主要原因。但是在寫程序的時候，可以人為的控制。
3.Java內存泄露和內存溢出
內存泄漏：分配出去的內存回收不了
內存溢出：指系統(tǒng)內存不夠用了
http://zhidao.baidu.com/link?url=gQ4IAoIl07v0sxITrvasf8LwMwmFELou2d-6w11tqNHsNNdxQvDTg5f-EMlS0HSrAOG0mqw0DoBocICbuSfTvK
第一對所有的代碼包括頁面中的java代碼都進行一遍徹底的回顧檢查，
1.對那些靜態(tài)(static)的對象要特別留神，特別是類型為Map,List,Set的，靜態(tài)的變量會一直駐存在內存中，生命周期比較長，不會被垃圾器回收。
2．對于代碼，要審查是否生成了大量的冗余的對象，還有一些邏輯業(yè)務處理的類，
算法是否過于復雜，調整算法，對于代碼認真審查，再仔細重構一遍代碼，能提高代碼質量，提高程序運行穩(wěn)定性。
3.Java中的內存溢出大都是因為棧中的變量太多了。其實內存有的是。建議不用的盡量設成null以便回收，多用局部變量，少用成員變量。
1），變量所包含的對象體積較大，占用內存較多。
2），變量所包含的對象生命周期較長。
3），變量所包含的對象數(shù)據(jù)穩(wěn)定。
4），該類的對象實例有對該變量所包含的對象的共享需求。
4．在我的程序中對靜態(tài)變量的優(yōu)化后，使程序占用內存量至少提升了5k-10k。所以也不容忽視。
第二還有就是String類相關的東西：
1．字符串累加的時候一定要用StringBuffer的append方法，不要使用+操作符連接兩個字符串。差別很大。而且在循環(huán)或某些重復執(zhí)行的動作中不要去創(chuàng)建String對象，因為String對象是要用StringBuffer對象來處理的，一個String對象應該是產生了 3個對象（大概是這樣：））。
2．字符串length()方法來取得字符串長度的時候不要把length放到循環(huán)中，可以在循環(huán)外面對其取值。(包括vector的size方法)。特別是循環(huán)次數(shù)多的時候，盡量把length放到循環(huán)外面。
int size = xmlVector.size();
for (int i = 2; i < size; i++) {
...
}
3 .寫代碼的時候處理內存溢出
try{
//do sth
....
}catch (outofmemoryerror e){//可以用一個共通函數(shù)來執(zhí)行.
system.out.print (“no memory! ”);
system.gc();
//do sth again
....
}
4.對于頻繁申請內存和釋放內存的操作,還是自己控制一下比較好,但是System.gc()的方法不一定適用，最好使用finallize強制執(zhí)行或者寫自己的finallize方法。 Java 中并不保證每次調用該方法就一定能夠啟動垃圾收集，它只不過會向JVM發(fā)出這樣一個申請，到底是否真正執(zhí)行垃圾收集，一切都是個未知數(shù)。
1.優(yōu)化程序2.改進算法3.增加jvm內存分配
http://www.jb51.net/article/77470.htm
http://www.php100.com/html/program/jquery/2013/0905/6004.html
http://bhsc-happy.iteye.com/blog/678163
http://www.cnblogs.com/Javame/p/3881187.html
JMX
Java Management Extensions，Java管理擴展，初步看了些資料，以為是專門管理，監(jiān)控jvm的一些信息的，特別是visual VM這個監(jiān)控jvm的東西，還有一個添加JMX連接的時候（我自己想錯了，那樣的話應該叫jvm Management Extensions），其實他能使得基于java語言開發(fā)的程序能被管理，并且是可擴展的。
Jdk以前是通過JVMPI之類來監(jiān)測Java程序運行中的jvm和系統(tǒng)的一系列情況，現(xiàn)在通過jmx就可以做到，這是通過java.lang.management 包來實現(xiàn)的，這個包是 JMX 在 JDK方面 的一個應用，并不是表示jmx就是一個監(jiān)控jvm的東西。
我們可以用jmx來監(jiān)控我們的系統(tǒng)，通過公布API的方式，但是，這里采用監(jiān)控這個詞，也是受了前面的例子的影響，實際上，個人覺得，就可以用jmx來開發(fā)我們的系統(tǒng)。
現(xiàn)在的jboss，hibernate，tomcat各種應用都號稱實現(xiàn)了JMX規(guī)范，將可管理，可調用的MBean注冊到MBeanServer中，通過一種類似“web服務”的方式公布出去，并且伴有一個名字，可以通過該名字找到該MBean。并且，這里的MBean是可以被管理的，說到這里又想到了OSGI。
JMX與Web Service
個人認為，我們實現(xiàn)JMX規(guī)范，將東西發(fā)布出去，和通過web Service的方式是很類似的，也是可以遠程調用的，只是相對的web Service的方式更加SOA一些，不過JMX號稱也要提供對非java客戶端的支持，也就是跨語言了吧。。。
現(xiàn)在的JMX連接方式：
JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/server"); JMXConnector jmxc = JMXConnectorFactory.connect(url, null);
看了下源碼，貌似還是通過RMI來實現(xiàn)的，不知道它要怎么實現(xiàn)非java客戶端支持。
從這里，我覺得JMX可以實現(xiàn)的，我們也都可以通過web Service實現(xiàn)，只是看在它有個“M”上，以后如果有什么系統(tǒng)管理，監(jiān)控方面的，可以考慮使用它，也許開發(fā)，個人覺得還是使用web service好一些。
說到這里，感覺OSGI與JMX也好像，在看到JMX能夠對MBean進行管理的時候，我就覺得跟OSGI很像，OSGI管理的是Bundle，找了找資源，原來早就有人考慮過了：
http://teamojiao.iteye.com/blog/438334
順便，在查資料的時候，發(fā)現(xiàn)一個東西，
if your question means, how to manage an OSGi runtime with JMX, you should have a look at MAEXO (http://code.google.com/p/maexo/). With MAEXO bundles up and running you will transparently get MBeans for a fair amount of services of the OSGi runtime as well as MBeans for your own services and bundles. Just have a look at the screencast.
摘一些話：僅做參考
<網友回復>
一個大系統(tǒng)中，各內部模塊系統(tǒng)之間的基于接口方式的互相調用和治理，使用ｊｍｘ是最佳方案．
帶來的好處是
1.面向接口，遠程調用對于開發(fā)人員是透明的，模塊在調用ｊｍｘ接口時，與調用本地方法幾乎相同．
2.可視化的治理界面， 通過 Jconsole等ｊｍｘ客戶端，可以實時監(jiān)控系統(tǒng)，并且可實時調用方法進行某些操作．
典型應用場景：
某聊天系統(tǒng)，一臺服務器作為 在線用戶列表服務器 A1， ｎ臺服務器為用戶提供聊天業(yè)務處理 N1 ,N2,N3...，
一臺服務器作為后臺治理系統(tǒng)A2．
系統(tǒng)治理員現(xiàn)在進行下面這樣一個操作，察看某用戶是否在線，找到該用戶，發(fā)現(xiàn)其在線，則將該用戶加入黑名單，并踢下線．
對應的ｊｍｘ接口可以由以下幾個：
A1為A2提供查詢在線用戶ｊｍｘ接口，加入黑名單接口，kickout接口，
Ａ１為N1..等服務器提供以下接口： 注冊業(yè)務服務器，添加在線用戶．查找黑名單用戶
N1...到N3為Ａ１提供kickout接口．
因此在上面的踢下線操作，則由用戶在A2的ｗｅｂ界面發(fā)出，交由A1執(zhí)行，A1記錄黑名單之后，再找到用戶所在業(yè)務服務器調用N1提供的接口讓用戶下線．
以上情形是在生產環(huán)境下的部署，而在開發(fā)工作，則可以將A1,A2,N...N3等功能合并在一個應用中調試． 由于使用的是ｊｍｘ接口，在本地調試合并之后，可以直接調用應用內部接口方法．
這樣借助ｊｍｘ實現(xiàn)的應用模塊的靈活組裝與拆分，使得系統(tǒng)的可以根據(jù)負載需要，根據(jù)性能情況，靈活的拆分和整合部署分布式的應用．
替代方案，選擇webservice,xmlrpc等，但是這些都需要手工編寫或用工具生成大量的代碼來輔助完成接口間的java對象序列化 。
經典ｊｍｘ案例：
１．Ｊｂｏｓｓ．使用ｊｍｘ治理內部的各個ｓｅｒｖｉｃｅ。
2． 基于ｊａｖａ的開源網管軟件 Hyperic HQ ，通過ｊｍｘ與各被治理資源進行通訊和信息采集．
<網友回復>JMX是一個治理的框架。
當我們想使用JMX的時候，就要問，我們的系統(tǒng)當中有需要監(jiān)控治理的資源或者對象嗎？實事求是一點，我們不能為了想使用一個高端的技術，就歪曲系統(tǒng)的本來面目。
假如第一個問題是肯定的，接下來就是看這些資源是否有生命周期。
經典案例：jboss就是將所有可部署的組件作為資源來治理，這些組建都有其生命周期。這個理念甚至延伸到了其系統(tǒng)內部，將其內部的服務作為組件納入到 JMX中來，成就了jboss基于jmx的微內核系統(tǒng)。
http://www.cnblogs.com/linzheng/archive/2011/01/23/1942328.html
http://www.ibm.com/developerworks/cn/linux/l-cn-socketftp/
一，網絡編程中兩個主要的問題
一個是如何準確的定位網絡上一臺或多臺主機，另一個就是找到主機后如何可靠高效的進行數(shù)據(jù)傳輸。
在TCP/IP協(xié)議中IP層主要負責網絡主機的定位，數(shù)據(jù)傳輸?shù)穆酚桑蒊P地址可以唯一地確定Internet上的一臺主機。
而TCP層則提供面向應用的可靠（tcp）的或非可靠（UDP）的數(shù)據(jù)傳輸機制，這是網絡編程的主要對象，一般不需要關心IP層是如何處理數(shù)據(jù)的。
目前較為流行的網絡編程模型是客戶機/服務器（C/S）結構。即通信雙方一方作為服務器等待客戶提出請求并予以響應。客戶則在需要服務時向服務器提 出申請。服務器一般作為守護進程始終運行，監(jiān)聽網絡端口，一旦有客戶請求，就會啟動一個服務進程來響應該客戶，同時自己繼續(xù)監(jiān)聽服務端口，使后來的客戶也 能及時得到服務。
二，兩類傳輸協(xié)議：TCP；UDP
TCP是Tranfer Control Protocol的 簡稱，是一種面向連接的保證可靠傳輸?shù)膮f(xié)議。通過TCP協(xié)議傳輸，得到的是一個順序的無差錯的數(shù)據(jù)流。發(fā)送方和接收方的成對的兩個socket之間必須建 立連接，以便在TCP協(xié)議的基礎上進行通信，當一個socket（通常都是server socket）等待建立連接時，另一個socket可以要求進行連接，一旦這兩個socket連接起來，它們就可以進行雙向數(shù)據(jù)傳輸，雙方都可以進行發(fā)送 或接收操作。
UDP是User Datagram Protocol的簡稱，是一種無連接的協(xié)議，每個數(shù)據(jù)報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，因此能否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。
比較：
UDP：1，每個數(shù)據(jù)報中都給出了完整的地址信息，因此無需要建立發(fā)送方和接收方的連接。
2，UDP傳輸數(shù)據(jù)時是有大小限制的，每個被傳輸?shù)臄?shù)據(jù)報必須限定在64KB之內。
3，UDP是一個不可靠的協(xié)議，發(fā)送方所發(fā)送的數(shù)據(jù)報并不一定以相同的次序到達接收方
TCP：1，面向連接的協(xié)議，在socket之間進行數(shù)據(jù)傳輸之前必然要建立連接，所以在TCP中需要連接
時間。
2，TCP傳輸數(shù)據(jù)大小限制，一旦連接建立起來，雙方的socket就可以按統(tǒng)一的格式傳輸大的
數(shù)據(jù)。
3，TCP是一個可靠的協(xié)議，它確保接收方完全正確地獲取發(fā)送方所發(fā)送的全部數(shù)據(jù)。
應用：
1，TCP在網絡通信上有極強的生命力，例如遠程連接（Telnet）和文件傳輸（FTP）都需要不定長度的數(shù)據(jù)被可靠地傳輸。但是可靠的傳輸是要付出代價的，對數(shù)據(jù)內容正確性的檢驗必然占用計算機的處理時間和網絡的帶寬，因此TCP傳輸?shù)男什蝗鏤DP高。
2，UDP操作簡單，而且僅需要較少的監(jiān)護，因此通常用于局域網高可靠性的分散系統(tǒng)中client/server應用程序。例如視頻會議系統(tǒng)，并不要求音頻視頻數(shù)據(jù)絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。
三，基于Socket的java網絡編程
1，什么是Socket
網絡上的兩個程序通過一個雙向的通訊連接實現(xiàn)數(shù)據(jù)的交換，這個雙向鏈路的一端稱為一個Socket。Socket通常用來實現(xiàn)客戶方和服務方的連接。Socket是TCP/IP協(xié)議的一個十分流行的編程界面，一個Socket由一個IP地址和一個端口號唯一確定。
但是，Socket所支持的協(xié)議種類也不光TCP/IP一種，因此兩者之間是沒有必然聯(lián)系的。在Java環(huán)境下，Socket編程主要是指基于TCP/IP協(xié)議的網絡編程。
2，Socket通訊的過程
Server端Listen(監(jiān)聽)某個端口是否有連接請求，Client端向Server 端發(fā)出Connect(連接)請求，Server端向Client端發(fā)回Accept（接受）消息。一個連接就建立起來了。Server端和Client 端都可以通過Send，Write等方法與對方通信。
對于一個功能齊全的Socket，都要包含以下基本結構，其工作過程包含以下四個基本的步驟：
（1） 創(chuàng)建Socket；
（2） 打開連接到Socket的輸入/出流；
（3） 按照一定的協(xié)議對Socket進行讀/寫操作；
（4） 關閉Socket.（在實際應用中，并未使用到顯示的close，雖然很多文章都推薦如此，不過在我的程序中，可能因為程序本身比較簡單，要求不高，所以并未造成什么影響。）
3，創(chuàng)建Socket
創(chuàng)建Socket
java在包java.net中提供了兩個類Socket和ServerSocket，分別用來表示雙向連接的客戶端和服務端。這是兩個封裝得非常好的類，使用很方便。其構造方法如下：
Socket(InetAddress address, int port);
Socket(InetAddress address, int port, boolean stream);
Socket(String host, int prot);
Socket(String host, int prot, boolean stream);
Socket(SocketImpl impl)
Socket(String host, int port, InetAddress localAddr, int localPort)
Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
ServerSocket(int port);
ServerSocket(int port, int backlog);
ServerSocket(int port, int backlog, InetAddress bindAddr)
其中address、host和port分別是雙向連接中另一方的IP地址、主機名和端 口號，stream指明socket是流socket還是數(shù)據(jù)報socket，localPort表示本地主機的端口號，localAddr和 bindAddr是本地機器的地址（ServerSocket的主機地址），impl是socket的父類，既可以用來創(chuàng)建serverSocket又可 以用來創(chuàng)建Socket。count則表示服務端所能支持的最大連接數(shù)。例如：學習視頻網 http://www.xxspw.com
Socket client = new Socket("127.0.01.", 80);
ServerSocket server = new ServerSocket(80);
注意，在選擇端口時，必須小心。每一個端口提供一種特定的服務，只有給出正確的端口，才 能獲得相應的服務。0~1023的端口號為系統(tǒng)所保留，例如http服務的端口號為80,telnet服務的端口號為21,ftp服務的端口號為23, 所以我們在選擇端口號時，最好選擇一個大于1023的數(shù)以防止發(fā)生沖突。
在創(chuàng)建socket時如果發(fā)生錯誤，將產生IOException，在程序中必須對之作出處理。所以在創(chuàng)建Socket或ServerSocket是必須捕獲或拋出例外。
4，簡單的Client/Server程序
1. 客戶端程序
import java.io.*;
import java.net.*;
public class TalkClient {
public static void main(String args[]) {
try{
Socket socket=new Socket("127.0.0.1",4700);
//向本機的4700端口發(fā)出客戶請求
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系統(tǒng)標準輸入設備構造BufferedReader對象
PrintWriter os=new PrintWriter(socket.getOutputStream());
//由Socket對象得到輸出流，并構造PrintWriter對象
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket對象得到輸入流，并構造相應的BufferedReader對象
String readline;
readline=sin.readLine(); //從系統(tǒng)標準輸入讀入一字符串
while(!readline.equals("bye")){
//若從標準輸入讀入的字符串為 "bye"則停止循環(huán)
os.println(readline);
//將從系統(tǒng)標準輸入讀入的字符串輸出到Server
os.flush();
//刷新輸出流，使Server馬上收到該字符串
System.out.println("Client:"+readline);
//在系統(tǒng)標準輸出上打印讀入的字符串
System.out.println("Server:"+is.readLine());
//從Server讀入一字符串，并打印到標準輸出上
readline=sin.readLine(); //從系統(tǒng)標準輸入讀入一字符串
} //繼續(xù)循環(huán)
os.close(); //關閉Socket輸出流
is.close(); //關閉Socket輸入流
socket.close(); //關閉Socket
}catch(Exception e) {
System.out.println("Error"+e); //出錯，則打印出錯信息
}
}
}
2. 服務器端程序
import java.io.*;
import java.net.*;
import java.applet.Applet;
public class TalkServer{
public static void main(String args[]) {
try{
ServerSocket server=null;
try{
server=new ServerSocket(4700);
//創(chuàng)建一個ServerSocket在端口4700監(jiān)聽客戶請求
}catch(Exception e) {
System.out.println("can not listen to:"+e);
//出錯，打印出錯信息
}
Socket socket=null;
try{
socket=server.accept();
//使用accept()阻塞等待客戶請求，有客戶
//請求到來則產生一個Socket對象，并繼續(xù)執(zhí)行
}catch(Exception e) {
System.out.println("Error."+e);
//出錯，打印出錯信息
}
String line;
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket對象得到輸入流，并構造相應的BufferedReader對象
PrintWriter os=newPrintWriter(socket.getOutputStream());
//由Socket對象得到輸出流，并構造PrintWriter對象
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系統(tǒng)標準輸入設備構造BufferedReader對象
System.out.println("Client:"+is.readLine());
//在標準輸出上打印從客戶端讀入的字符串
line=sin.readLine();
//從標準輸入讀入一字符串
while(!line.equals("bye")){
//如果該字符串為 "bye"，則停止循環(huán)
os.println(line);
//向客戶端輸出該字符串
os.flush();
//刷新輸出流，使Client馬上收到該字符串
System.out.println("Server:"+line);
//在系統(tǒng)標準輸出上打印讀入的字符串
System.out.println("Client:"+is.readLine());
//從Client讀入一字符串，并打印到標準輸出上
line=sin.readLine();
//從系統(tǒng)標準輸入讀入一字符串
} //繼續(xù)循環(huán)
os.close(); //關閉Socket輸出流
is.close(); //關閉Socket輸入流
socket.close(); //關閉Socket
server.close(); //關閉ServerSocket
}catch(Exception e){
System.out.println("Error:"+e);
//出錯，打印出錯信息
}
}
}
5，支持多客戶的client/server程序
前面的Client/Server程序只能實現(xiàn)Server和一個客戶的對話。在實際應用 中，往往是在服務器上運行一個永久的程序，它可以接收來自其他多個客戶端的請求，提供相應的服務。為了實現(xiàn)在服務器方給多個客戶提供服務的功能，需要對上 面的程序進行改造，利用多線程實現(xiàn)多客戶機制。服務器總是在指定的端口上監(jiān)聽是否有客戶請求，一旦監(jiān)聽到客戶請求，服務器就會啟動一個專門的服務線程來響 應該客戶的請求，而服務器本身在啟動完線程之后馬上又進入監(jiān)聽狀態(tài)，等待下一個客戶的到來。
1. java_home C:\jdk1.6.0_30
2. Path ;%java_home%\bin
3. classpath .;%java_home%\lib\dt.jar;%java_home%\lib\tools.jar
http://www.cnblogs.com/sunada2005/p/3577799.html
http://greemranqq.iteye.com/blog/1774258
http://www.cnblogs.com/-lpf/p/4317281.html
我在項目開發(fā)過程中，經常要改動JAVA/JSP 文件，但是又不想從新啟動服務器(服務器從新啟動花時間)，想直接獲得（debug）結果.有兩種方式熱部署 和熱加載：
1.熱加載：在server.xml -> context 屬性中 設置 reloadable="true"
Java代碼
- <Context docBase="xxx" path="/xxx" reloadable="true"/>
2. 熱部署：在server.xml -> context 屬性中 設置 autoDeploy="true"
Java代碼
- <Context docBase="xxx" path="/xxx" autoDeploy="true"/>
3.區(qū)別：
熱加載：服務器會監(jiān)聽 class 文件改變，局部進行加載，不清空session ，不釋放內存。開發(fā)中用的多，但是要考慮內存溢出的情況。
熱部署： 整個項目從新部署，包括你從新打上.war 文件。 會清空session ，釋放內存。項目打包的時候用的多。
也可以通過Eclipse上設置實現(xiàn)上述配置文件的修改
Eclipse的工程名右鍵: properties->Tomcat->General->Make this context as reloadable(reloadable="true")不要選中 Eclipse的工程名右鍵:Tomcat project->Update Context Definition
注意:source 屬性有些版本不支持，容易出錯，去掉就行
二。
不重啟Tomcat有兩種方式：熱部署、熱加載
熱部署：容器狀況在運行時重新部署整個項目。這類環(huán)境下一般整個內存會清空,重新加載，這類方式
有可能會造成sessin丟失等環(huán)境。tomcat 6確實可以熱部署了,而且對話也沒丟.
熱加載：最好是在調試過程中使用，免患上整個項目加載,Debug標準樣式支持熱加載。容器狀況在運行時重
新加載轉變編譯后的類。在這類環(huán)境下內存不會清空,sessin不會丟失,但容易造成內存溢出,或者找不到方
法。一般轉變類的布局和模型就會有異常，在已經有的變量和方法中轉變是不會出問題的(Eclipse、
MyEclipse8、JBuilder、IntelliJ IDEA…)。
常用的一定第二種：熱加載了，設置如下！
在tomcat的conf中的server.xml中的host設置中添加<Context path="/test"
docBase="D:/develop/test"
debug="0" privileged="true" reloadable="true"/>
reloadable="true" !最重要
它內里有很多屬性,意義如下：
1>path:指定拜候該web應用的URL進口；
2>docBase:指定web應用的文件路徑，可以給定絕對路徑，也可以給定相對于<Host>的appBase屬性【默認
指向tomcat的webapps】的相對于徑；要是Web應用是個war文件，則指定war文件的路徑。
3>className:指定使成為事實Context組件的Java類的名字，這個Java類必須使成為事實org.apache.catalina.Context
接口，該屬性的默認值為org.apache.catalina.StandardContext。
4>reloadable:要是這個屬性設置為true,Tomcat服務器在運行狀況下會監(jiān)視在WEB-INF/classess和WEB-
INF/lib目次下的class文件的改動，以及監(jiān)視web應用的WEB-INF/web.xml文件的改動。要是檢測到的class
文件或者web.xml文件被更新，服務器會自動加載Web應用。該屬性的默認值為false.在web應用的開發(fā)和調
試階段，把reloadable設為true,可以方便對web應用的調試。在web應用正式發(fā)布階段，把reloadable設為
false,可以減低tomcat的運行負荷，提高Tomcat的運行性能。
5>cachingAllowed:要是為true,標示允許啟用靜態(tài)資源的緩存。使用緩存能提高拜候靜態(tài)資源的效率。
tomcat把那一些時常被客戶端拜候的靜態(tài)資源(如:HTML文檔、圖片文件和聲響文件等)放在緩存中，當客戶再
次拜候有關靜態(tài)資源時，Tomcat只需直接從緩存中讀取相關數(shù)據(jù)，無須反復讀取文件系統(tǒng)中的文件。該屬
性的默認值為true.
6>cacheMaxSize:設定靜態(tài)資源的緩存的最大容量，以K為單元。要是，要是該屬性為100,表示100K，默認
為10240(即10M)。
7>workDir:指定web應用的工作目次。Tomcat在運行時會把與這個web應用相關的臨應試文章件放在此目次下。
8>uppackWar:要是此項設為true,表示將把web應用的war文件睜開為開放目次布局后再運行。要是設為
false,則直接運行war文件。該屬性的默認值為true。
同志們，使用tomcat6.0的注意了啊。當你使用我的方法設置tomcat后，你的myeclipse報如下錯誤時，不要驚慌，這是正確的，且聽我解釋。
console報錯：
警告: [SetPropertiesRule]{Server/Service/Engine/Host/Context} Setting property ' debug' to '0' did not find a matching property. 這是由于你使用的是tomcat6.0,由于它路程經過過程其他途徑對debug="0"這個屬性進行了使成為事實，所以這搭不能再有此屬性。你只要將它去掉，就能夠沒事了啟動了。 也就是說去掉debug="0“，萬事OK，呵呵。
(轉)
-------------------------------------------------------------
針對需要重新啟動tomcat的服務,重新啟動方式為:
安裝版:tomcat/bin/shotdown.bat 關閉tomcat服務
tomcat/bin/startup.bat 開啟tomcat服務
或者-->我的電腦-->管理-->服務和應用程序/服務-->找到Apache Tomcat重啟
http://blog.sina.com.cn/s/blog_3c9872d00102w00y.html
Apache與Tomcat整合應用是一個老話題，不算新技能，但對非運維人員在配置過程中或許也會遇到一些問題。這里只是把自己多回配置的過程做一個摘錄，供自己翻閱并望對過路的人有用。
Apache是當下在Windows、Unix、Linux 等操作系統(tǒng)中最流行的Web服務器軟件之一，其反應速度快、運行效率高，不僅支持HTML等靜態(tài)頁面，在加載插件后也可支持 PHP 頁面等。Tomcat是Apache軟件基金協(xié)會與Sun公司聯(lián)合開發(fā)的Web服務器，除支持HTML靜態(tài)頁面外，還是JSP、Servlet等JAVA WEB應用的服務器。在相同運行環(huán)境下，Tomcat對靜態(tài)頁面的反應速度沒有Apache靈敏，整合 Apache與Tomcat能使系統(tǒng)運行于一個良好環(huán)境下，實現(xiàn)JAVA的動態(tài)與靜態(tài)頁面分離，不僅讓系統(tǒng)更安全，同時也可提高系統(tǒng)效率。
一、JAVA應用基礎架構
通用的JAVA應用架構如下，包括WEB Server、APP Server和DB Server三個部分：
1、WEB Server
WEB Server置于企業(yè)防火墻外，這個防火墻也可以認為是一個CISCO路由器，在CISCO路由器上開放兩個端口為：80和443，其中：
80端口：用于正常的http訪問
443端口：用于https訪問，即如果你在ie里打入https://xxx.xxx.xx這樣的地址，默認走的是443這個端口
WebServer專門用于解析HTML、JS（JavaScript）、CSS、JPG/GIF等圖片格式文件、TXT、VBSCRIPT、PHP等“靜態(tài)”網頁內容。
2、APP Server
APP Server置于企業(yè)防火墻內，它和Web Server之間的連接必須且一定為內部IP連接。App Server用于解析我們的任何需要Java編譯器才能解析的“動態(tài)”網頁，其實App Server本身也能解析任何靜態(tài)網頁的。在應用中我們這樣來想一下：我們讓負責專門解析靜態(tài)網頁的Web Server來解析html等內容，而讓App Server專門用于解析任何需要Java編譯器才能解析的東西，讓它們各司其職。這樣作的好處：
1）為App Server“減壓”，同時也提高了性能；
2）不用再把8080這個端口暴露在internet上，也很安全，畢竟我們的App Server上是有我們的代碼的，就算是編譯過的代碼也容易被“反編譯”，這是很不安全的；
3）為將來進一步的“集群擴展”打好了基礎。
3、DB Server
比方說我們用MySQL，它需要通過3306與App Server進行連接，那么這個1521我們稱為數(shù)據(jù)庫連接端口，如果把它暴露在Internet上就比較危險，就算密碼很復雜，但 對于高明的黑客來說，要攻破你的口令也只是時間上的問題而己。因此我們把我們的DB Server也和App Server一樣，置于內網的防火墻，任何的DB連接與管理只能通過內網來訪問。
二、系統(tǒng)安裝與配置
系統(tǒng)安裝包括MySQL的安裝，WEB Server即Apache的安裝，App Server即Tomcat的安裝。關于這三個系統(tǒng)安裝網上相關的文檔很多，此處略去。以下主要摘錄需要重點配置的內容。
1、Apache的配置
做技術的人應該都會Apache的基礎配置，如果不會確實需要學一學。
Apache的配置主要集中在httpd.conf文件中，它位于Apache的安裝目錄下，比如我的是在“C:\webserver\apache\apache22\conf”目錄下。用Ultraedit或Notepad++編輯器打開文件，通常需要修改的內容包括ServerName、DocumentRoot、VirtualHost內容等。此處我修改的內容包括：
1）DocumentRoot原目錄為C:/webserver/apache/apache22/htdocs，修改為D:/WWW/apache/htdocs，將網站發(fā)布路徑與Apache安裝路徑分開；
2）找到如下紅色標示內容：
Options FollowSymLinks
AllowOverride None
Order deny,allow
deny from all
把這個”deny from all”改成”allow fromall’。
Options FollowSymLinks
AllowOverride None
Order deny,allow
allow from all
以免訪問Apache根目錄下的文件時出現(xiàn)以下錯誤提示：
3）再找到下面這樣的行
Options FollowSymLinks indexes
把它注掉改成下面這樣
#Options FollowSymLinks indexes
Options None
以免在訪問Apache目錄時出現(xiàn)直接列表顯示子目錄或目錄下文件的不安全情況，如下圖樣子：
以上配置修改完成后重啟Apache服務，保證要能正常運行。
三、Apache與Tomcat的整合配置
Apache(Web Server)負責處理HTML靜態(tài)內容，Tomcat(App Server)負責處理動態(tài)內容；原理圖如下：
上述架構的原理是： 在Apache中裝載一個模塊，這個模塊叫mod_jk； Apache通過80端口負責解析任何靜態(tài)web內容； 任何不能解析的內容，用表達式告訴mod_jk，讓mod_jk派發(fā)給相關的App Server去解釋。
因此，首先把 mod_jk-1.2.31-httpd-2.2.3（可從網上搜索下載該模塊，如http://download.csdn.net/detail/shangkaikuo/4494837）拷貝到 "/Apache2.2/modules" 目錄下。接下來：
1、添加workers.properties文件
在 “/Tomcat 8.0/conf ” 文件夾下（也可以是其它目錄下）增加 workers.properties 文件，輸入以下內容。（將其中相應目錄替換成自己本地tomcat或jre安裝目錄）
#讓mod_jk模塊認識Tomcat
workers.tomcat_home=d:/webserver/tomcat/tomcat8
#讓mod_jk模塊認識JRE
workers.java_home=C:/java/jdk1.8.0_45/jre
#指定文件路徑分割符
ps=/
##
#工作端口，此端口應該與server.xml中Connector元素的AJP/1.3協(xié)議所使用的端口相匹配
worker.list=AJP13
worker.AJP13.port=8009
#Tomcat服務器的地址
worker.AJP13.host=localhost
#類型
worker.AJP13.type=ajp13
#負載平衡因數(shù)
worker.AJP13.lbfactor=1
**注意：worker.list=AJP13中，AJP13為自定義名稱，但此名稱必須與下文所述的 “/Apache 2.2/conf/httpd.conf ” 文件中，JkMount指令對應的名稱相匹配。
2、httpd.conf文件中添加配置內容
加入workers.properties文件后，可修改 “/Apache 2.2/conf/httpd.conf ” 文件，加入以下配置，注意JkMount指令中的變量必須與worker.list所配置的名稱相同。
# 此處mod_jk-1.2.31-httpd-2.2.3文件為你下載的文件
LoadModule jk_module modules/mod_jk-1.2.31-httpd-2.2.3.so
# 指定tomcat監(jiān)聽配置文件地址
JkWorkersFile "C:/webserver/tomcat/tomcat8/conf/workers.properties"
#JkWorkersFile "C:/webserver/apache/apache22/conf/workers.properties"
# 指定日志存放位置
JkLogFile "C:/webserver/tomcat/tomcat8/logs/mod_jk2.log"
JkLogLevel info
-virtualhost *-
ServerName localhost
DocumentRoot "C:/webserver/tomcat/tomcat8/webapps"
DirectoryIndex index.html index.htm index.jsp index.action
ErrorLog logs/shsc-error_log.txt
CustomLog logs/shsc-access_log.txt common
JkMount /*WEB-INF AJP13
JkMount /*j_spring_security_check AJP13
JkMount /*.action AJP13
JkMount /servlet/* AJP13
JkMount /*.jsp AJP13
JkMount /*.do AJP13
JkMount /*.action AJP13
-/virtualhost-
上述配置中的紅色內容是為了告訴Apache哪些交給Tomcat去處理，其它的都交由Apache自身去處理。
其中綠色的兩句比較關鍵，分別告訴：Apache載入一個額外的插件，用于連接tomcat； 連接時的配置參數(shù)描述位于Tomcat安裝目錄的/conf目錄下的一個叫workers.properties文件中，mod_jk一般使用ajp13協(xié)議連接，使用的是tomcat的8009端口。
完成以上配置后，重啟 Apache、Tomcat。此時Apache、Tomcat的默認目錄為 "C:/Program Files/Apache Software Foundation/Tomcat 7.0/webapps ”,Apache使用默認的80端口、Tomcat端口改成1080或其它非8080默認端口（修改是為了安全，也可以不用修改）。在Tomcat默認目錄下添加test目錄，在該目錄下加入index.jsp頁面，然后通過http://localhost/test/index.jsp試試是否可以正常訪問，如頁面可正常訪問，證明整合配置已經成功。
至此，似乎整個配置工作已經完成，但是如果你想試著把靜態(tài)的HTML頁面放到Apache的htdocs發(fā)布目錄下，把JSP等動態(tài)內容放到Tomcat的webapps目錄下（該目錄下不存放*.html文件），然后通過http://localhost/index.html想訪問Apache目錄下的內容，你會發(fā)現(xiàn)404之類的不能訪問的錯誤。如何解決，這里暫時賣個關子.......如果你能看出問題，能容易解決掉，就誠摯為你點個贊！
http://www.jfox.info/guan-yu-Tomcat-he-Tomcat-de-mian-shi-wen-ti
http://www.jfox.info/guan-yu-Tomcat-he-Tomcat-de-mian-shi-wen-ti
關于Tomcat和Tomcat的面試問題
一、Tomcat的缺省是多少，怎么修改
Tomcat的缺省端口號是8080.
修改Tomcat端口號：
1.找到Tomcat目錄下的conf文件夾
2.進入conf文件夾里面找到server.xml文件
3.打開server.xml文件
4.在server.xml文件里面找到下列信息
maxThreads=”150″ minSpareThreads=”25″ maxSpareThreads=”75″
enableLookups=”false” redirectPort=”8443″ acceptCount=”100″
connectionTimeout=”20000″ disableUploadTimeout=”true” />
5.把port=”8080″改成port=”8888″，并且保存
6.啟動Tomcat，并且在IE瀏覽器里面的地址欄輸入http://127.0.0.1:8888/
7、tomcat默認采用的BIO模型，在幾百并發(fā)下性能會有很嚴重的下降。tomcat自帶還有NIO的模型，另外也可以調用APR的庫來實現(xiàn)操作系統(tǒng)級別控制。
NIO模型是內置的，調用很方便，只需要將上面配置文件中protocol修改成 org.apache.coyote.http11.Http11NioProtocol，重啟即可生效。如下面的參數(shù)配置，默認的是HTTP/1.1。
<Connector port=”8080″
protocol=”org.apache.coyote.http11.Http11NioProtocol”
connectionTimeout=”20000″
redirectPort=”8443″
maxThreads=”500″
minSpareThreads=”20″
acceptCount=”100″
disableUploadTimeout=”true”
enableLookups=”false”
URIEncoding=”UTF-8″ />
二、tomcat 如何優(yōu)化？
1、優(yōu)化連接配置.這里以tomcat7的參數(shù)配置為例，需要修改conf/server.xml文件，修改連接數(shù)，關閉客戶端dns查詢。
參數(shù)解釋：
URIEncoding=”UTF-8″ :使得tomcat可以解析含有中文名的文件的url，真方便，不像apache里還有搞個mod_encoding，還要手工編譯
maxSpareThreads : 如果空閑狀態(tài)的線程數(shù)多于設置的數(shù)目，則將這些線程中止，減少這個池中的線程總數(shù)。
minSpareThreads : 最小備用線程數(shù)，tomcat啟動時的初始化的線程數(shù)。
enableLookups : 這個功效和Apache中的HostnameLookups一樣，設為關閉。
connectionTimeout : connectionTimeout為網絡連接超時時間毫秒數(shù)。
maxThreads : maxThreads Tomcat使用線程來處理接收的每個請求。這個值表示Tomcat可創(chuàng)建的最大的線程數(shù)，即最大并發(fā)數(shù)。
acceptCount : acceptCount是當線程數(shù)達到maxThreads后，后續(xù)請求會被放入一個等待隊列，這個acceptCount是這個隊列的大小，如果這個隊列也滿了，就直接refuse connection
maxProcessors與minProcessors : 在 Java中線程是程序運行時的路徑，是在一個程序中與其它控制線程無關的、能夠獨立運行的代碼段。它們共享相同的地址空間。多線程幫助程序員寫出CPU最 大利用率的高效程序，使空閑時間保持最低，從而接受更多的請求。
通常Windows是1000個左右，Linux是2000個左右。
useURIValidationHack:
我們來看一下tomcat中的一段源碼：
【security】
if (connector.getUseURIValidationHack()) {
String uri = validate(request.getRequestURI());
if (uri == null) {
res.setStatus(400);
res.setMessage(“Invalid URI”);
throw new IOException(“Invalid URI”);
} else {
req.requestURI().setString(uri);
// Redoing the URI decoding
req.decodedURI().duplicate(req.requestURI());
req.getURLDecoder().convert(req.decodedURI(), true);
可以看到如果把useURIValidationHack設成”false”，可以減少它對一些url的不必要的檢查從而減省開銷。
enableLookups=”false” ： 為了消除DNS查詢對性能的影響我們可以關閉DNS查詢，方式是修改server.xml文件中的enableLookups參數(shù)值。
disableUploadTimeout ：類似于Apache中的keeyalive一樣
給Tomcat配置gzip壓縮(HTTP壓縮)功能
compression=”on” compressionMinSize=”2048″
compressableMimeType=”text/html,text/xml,text/javascript,text/css,text/plain”
HTTP 壓縮可以大大提高瀏覽網站的速度，它的原理是，在客戶端請求網頁后，從服務器端將網頁文件壓縮，再下載到客戶端，由客戶端的瀏覽器負責解壓縮并瀏覽。相對于普通的瀏覽過程HTML,CSS,Javascript , Text ，它可以節(jié)省40%左右的流量。更為重要的是，它可以對動態(tài)生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等輸出的網頁也能進行壓縮，壓縮效率驚人。
1)compression=”on” 打開壓縮功能
2)compressionMinSize=”2048″ 啟用壓縮的輸出內容大小，這里面默認為2KB
3)noCompressionUserAgents=”gozilla, traviata” 對于以下的瀏覽器，不啟用壓縮
4)compressableMimeType=”text/html,text/xml” 壓縮類型
最后不要忘了把8443端口的地方也加上同樣的配置，因為如果我們走https協(xié)議的話，我們將會用到8443端口這個段的配置，對吧？
<!–enable tomcat ssl–>
<Connector port=”8443″ protocol=”HTTP/1.1″
URIEncoding=”UTF-8″ minSpareThreads=”25″ maxSpareThreads=”75″
enableLookups=”false” disableUploadTimeout=”true” connectionTimeout=”20000″
acceptCount=”300″ maxThreads=”300″ maxProcessors=”1000″ minProcessors=”5″
useURIValidationHack=”false”
compression=”on” compressionMinSize=”2048″
compressableMimeType=”text/html,text/xml,text/javascript,text/css,text/plain”
SSLEnabled=”true”
scheme=”https” secure=”true”
clientAuth=”false” sslProtocol=”TLS”
keystoreFile=”d:/tomcat2/conf/shnlap93.jks” keystorePass=”aaaaaa”
/>
好了，所有的Tomcat優(yōu)化的地方都加上了。
2、優(yōu)化JDK
Tomcat默認可以使用的內存為128MB,Windows下,在文件{tomcat_home}/bin/catalina.bat，Unix下，在文件$CATALINA_HOME/bin/catalina.sh的前面，增加如下設置：
JAVA_OPTS=”‘$JAVA_OPTS” -Xms[初始化內存大小] -Xmx[可以使用的最大內存]
或
設置環(huán)境變量：export JAVA_OPTS=””$JAVA_OPTS” -Xms[初始化內存大小] -Xmx[可以使用的最大內存]”
一般說來，你應該使用物理內存的 80% 作為堆大小。如果本機上有Apache服務器，可以先折算Apache需要的內存，然后修改堆大小。建議設置為70％；建議設置[[初始化內存大小]等于[可以使用的最大內存]，這樣可以減少平凡分配堆而降低性能。
本例使用加入環(huán)境變量的方式：
# vi /etc/profile
加入：export JAVA_OPTS=””$JAVA_OPTS” -Xms700 —Xmx700
# source /etc/profile
【參數(shù)說明】
-Xms 是指設定程序啟動時占用內存大小。一般來講，大點，程序會啟動的 快一點，但是也可能會導致機器暫時間變慢。
-Xmx 是指設定程序運行期間最大可占用的內存大小。如果程序運行需要占 用更多的內存，超出了這個設置值，就會拋出OutOfMemory 異常。
-Xss 是指設定每個線程的堆棧大小。這個就要依據(jù)你的程序，看一個線程 大約需要占用多少內存，可能會有多少線程同時運行等。
-XX:PermSize設置非堆內存初始值，默認是物理內存的1/64 。
-XX:MaxPermSize設置最大非堆內存的大小，默認是物理內存的1/4。
三、tomcat 有那幾種Connector 運行模式？
tomcat的運行模式有3種.修改他們的運行模式.3種模式的運行是否成功,可以看他的啟動控制臺,或者啟動日志.或者登錄他們的默認頁面http://localhost:8080/查看其中的服務器狀態(tài)。
1)bio
默認的模式,性能非常低下,沒有經過任何優(yōu)化處理和支持.
2)nio
利用java的異步io護理技術,no blocking IO技術.
想運行在該模式下，直接修改server.xml里的Connector節(jié)點,修改protocol為
<Connector port=”80″ protocol=”org.apache.coyote.http11.Http11NioProtocol”
connectionTimeout=”20000″
URIEncoding=”UTF-8″
useBodyEncodingForURI=”true”
enableLookups=”false”
redirectPort=”8443″ />
啟動后,就可以生效。
3)apr
安裝起來最困難,但是從操作系統(tǒng)級別來解決異步的IO問題,大幅度的提高性能.
必須要安裝apr和native，直接啟動就支持apr。下面的修改純屬多余，僅供大家擴充知識,但仍然需要安裝apr和native
如nio修改模式,修改protocol為org.apache.coyote.http11.Http11AprProtocol
http://zhidao.baidu.com/link?url=6FrnwvBQEZhjM-ooNCuiAra7T6qi9FsFhFvkHBKaOjqovZR86OCsIePi-05nM-fxRrlInEGbElSxlhgO6X7JsaGNdQdNrQ2xE58wglgeQO3
http://blog.csdn.net/liaq325/article/details/8281550
摘自以上
spring httpInvoke
spring httpInvoke 基于spring架構的服務器之間的遠程調用實現(xiàn)。通過spring httpInvoke，可以調用遠程接口，進行數(shù)據(jù)交互、業(yè)務邏輯操作
服務器端：(被調用一方)
- public class User implements Serializable{//必須實現(xiàn)serializable接口，遠程調用的基礎
- private String username;
- private Date birthday;
- //構造方法
- //set get 方法
- }
- public interface UserService{
- User getUser(String username);
- }
- public UserServiceImpl implements UserService{
- //實現(xiàn)userService
- }
暴露給調用端：服務的實現(xiàn)，接口
- <bean id="userService" class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
- <property name="service">
- <bean class="com.cd.Liaq.UserServiceImpl"/>
- </property>
- <property name="serviceInterface">
- <value>com.cd.Liaq.UserService</value>
- </property>
- </bean>
- <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
- 第一種：<property name="urlMap">
- <map>
- <entry key="TestUser" value-ref="userService"/>
- </map>
- </property>
- 第二種：<prop key="/TestUser">userService</prop>
- </bean>
- <!-- spring遠程調用 -->
- <servlet>
- <servlet-name>remote</servlet-name>
- <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
- <load-on-startup>1</load-on-startup>
- </servlet>
- <servlet-mapping>
- <servlet-name>remote</servlet-name>
- <url-pattern>/remoting/*</url-pattern>
- </servlet-mapping>
- <!-- 通過http連接遠程系統(tǒng) -->
- <bean id="memberService"
- class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
- <property name="serviceUrl">
- <value>http://192.9.200.123:8080/MemberSystem/remoting/memberService</value>
- </property>
- <property name="serviceInterface">
- <value>com.cd.Liaq.UserService</value>
- </property>
- </bean>
- <bean id="memberService"
- class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
- <property name="serviceUrl">
- <value>http://192.9.200.123:8080/MemberSystem/remoting/memberService</value>
- </property>
- <property name="serviceInterface">
- <value>com.cd.Liaq.UserService</value>
- </property>
- <property name="httpInvokerRequestExecutor"> //使用指定的執(zhí)行器執(zhí)行
- <ref bean="httpInvokerRequestExecutor" />
- </property>
- </bean>
- <bean id="httpInvokerRequestExecutor" class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">
- <property name="httpClient">
- <bean class="org.apache.commons.httpclient.HttpClient">
- <property name="connectionTimeout" value="2000" />
- <property name="timeout" value="5000" />
- </bean>
- </property>
- </bean>
- <bean id="httpInvokerRequestExecutor" class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">
- <property name="httpClient">
- <bean class="org.apache.commons.httpclient.HttpClient">
- <property name="connectionTimeout" value="2000" />
- <property name="timeout" value="5000" />
- <property name="httpConnectionManager">//控制連接
- <ref bean="multiThreadedHttpConnectionManager" />
- </property>
- </bean>
- </property>
- </bean>
- <bean id="multiThreadedHttpConnectionManager" class="org.apache.commons.httpclient.MultiThreadedHttpConnectionManager">
- <property name="params">
- <bean class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">
- <property name="maxTotalConnections" value="600" />
- <property name="defaultMaxConnectionsPerHost" value="512" />
- </bean>
- </property>
- </bean>
- <property name="connectionTimeout" value="2000" />
- <property name="timeout" value="5000" />
摘要: http://www.cnblogs.com/hoojo/archive/2012/07/19/2599534.htmlhttp://www.cnblogs.com/hellowood23/p/5210267.htmlhttp://blog.csdn.net/ni_hao_ya/article/details/9344779http://www.cnblogs.com/hellowood23/p/...
閱讀全文