javaurl參數
『壹』 java怎樣獲取url參數
如果是javaweb 項目，那麼非常簡單，直接調用 HttpServletRequest 對象的 .getParamter("參數名稱") 方法即可得到。
如果是普通java 項目：
/**
* 獲取網址的指定參數值
*
* @param url
* 網址
* @param parameter
* 參數名稱
* @author cevencheng
* @return
*/
public static String getParameter(String url, String parameter, String defaultValue) {
try {
final String charset = "utf-8";
url = URLDecoder.decode(url, charset);
if (url.indexOf('?') != -1) {
final String contents = url.substring(url.indexOf('?') + 1);
HashMap<String, String> map = new HashMap<String, String>();
String[] keyValues = contents.split("&");
for (int i = 0; i < keyValues.length; i++) {
String key = keyValues[i].substring(0, keyValues[i].indexOf("="));
String value = keyValues[i].substring(keyValues[i].indexOf("=") + 1);
if (key.equals(parameter)) {
if (value == null || "".equals(value.trim())) {
return defaultValue;
}
return value;
}
map.put(key, value);
}
}
return null;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
『貳』 java url參數去重
言歸正傳。
所謂的Url去重（我一直沒找到對應的英文，URL Filtering ?），就是爬蟲將重復抓取的URL去除，避免多次抓取同一網頁。爬蟲一般會將待抓取的URL放在一個隊列中，從抓取後的網頁中提取到新的URL，在他們被放入隊列之前，首先要確定這些新的URL沒有被抓取過，如果之前已經抓取過了，就不再放入隊列。
最直觀的做法 – hash表
為了盡快把整個爬蟲搭建起來，最開始的URL去重採用方案是一個內存中的HashSet，這是最直觀的方法，所有人都能想得到。HashSet中放置的就是URL的字元串，任何一個新的URL首先在HashSet中進行查找，如果HashSet中沒有，就將新的URL插入HashSet，並將URL放入待抓取隊列。
這個方案的好處是它的去重效果精確，不會漏過一個重復的URL。它的缺點是，我的爬蟲第二天早上就掛了，Out Of Memory。因為隨著抓取網頁的增加，HashSet會一直無限制的增長。另外，網路中的很多URL其實是很長的，有大量的URL長度達到上百個字元。當然，因為我的爬蟲是跑在一個小伺服器上，JVM的內存本來就不多，否則它應該能再多撐1-2天。
簡單估算一下，假設單個URL的平均長度是100 byte（我覺著這已經非常保守了），那麼抓取1000萬的URL就需要：
100 byte * 10 000 000 = 1 GB
而1000萬URL在整個互聯網中實在是滄海一粟。可以了解，需要多大的內存才能裝下所有URL的HashSet。
壓縮URL
為了我的爬蟲能再多撐幾天，同時不想改動太多的代碼，第二個版本增加了一個小功能，就是HashSet中不存儲原始的URL，而是將URL壓縮後再放進去。貌似有不少paper中討論過如何對URL進行壓縮，包括新浪微博中的短URL其實也是個不錯的方案，可惜這些方法我都不會。為了偷懶，我直接用MD5對URL做編碼。
MD5的結果是128 bit也就是16 byte的長度。相比於之間估計的URL平均長度100byte已經縮小了好幾倍，可以多撐好多天了。
當然，哪怕找個一個可以壓縮到極致的演算法，隨著URL越來越多，終有一天會Out Of Memory。所以，這個方案不解決本質問題。
MD5另外一個問題是，有可能兩個相同的URL被映射成同一個MD5值，這樣的話，它們中有一個就永遠不會被抓取了。我不太確定的是，這個概率會有多大。如果非常小的話，這微小的誤差倒也不會有太大影響。
Bloom Filter
基於內存的HashSet的方法存在一個本質的問題，就是它消耗的內存是隨著URL的增長而不斷增長的。除非能夠保證內存的大小能夠容納下所有需要抓取的URL，否則這個方案終有一天會到達瓶頸。
這時候就會想，要找一個類似於HashSet的但所消耗的內存相對固定而不會不斷增長的方案，於是自然想到了Bloom Filter。關於Bloom Filter的概念這里就不多談了，網上隨處可以找到。我簡單嘗試了一下Bloom Filter，但是很快就放棄了。基於Bloom Filter的方案有幾個問題：
第一個是理論上的。Bloom Filter會將一些正常的樣本（在我這就是沒有抓取過的URL）過濾掉，即所謂的False Positive。當然，這概率有多大，取決於Bloom Filter的參數設置。但這引出了下一個問題；
第二個是實踐中的，即Bloom Filter的那幾個參數應該如何設置？m，k，n應該設置成多少才合適，這個我沒有經驗，而且可能需要反復的實驗和測試才能夠比較好的確定下來；
以上兩個問題還不是我放棄Bloom Filter的根本原因，真實的原因是我在做的是一個爬蟲框架，上面可以會啟動很多的爬蟲任務，每個任務可能抓取自己特定的URL，而且任務之間是獨立的。這樣，對於每個任務都需要有一個Bloom Filter，雖然對於單一任務它使用Bloom Filter所消耗的內存是固定的，但是任務的增多會導致更多的Bloom Filter，從而導致更多的內存消耗。仍然存在內存溢出的可能。
但如果只是一個抓取任務，那麼採用Bloom Filter應該是一個非常不錯的選擇。
BerkeleyDB
我終於明白我所需要的其實是一個可以放在disk上的去重方案，這樣，內存溢出將永遠成不了可能。很早就知道有BerkeleyDB這么一個東西，但第一次真正了解還是在Amazon的Dynamo那篇論文中提到過採用了BerkeleyDB作為單機上的底層存儲。當時覺著這東西真另類，原來還有叫做「DB」的東西卻不支持SQL。那時候還沒有NOSQL這詞，把這樣的東西叫做non-relational database。
BerkeleyDB是一個key-value database，簡單的說，就是一個在disk上的hash表，這也是為什麼它可以被用來做URL去重的原因。它另外一個另類的地方是，它是和程序運行在同一個進程空間中的，而不像一般的db，是做為單獨的程序運行。
這里附上Heritrix中使用BerkeleyDB做URL去重的代碼，一探究竟：（代碼位於Heritrix源代碼的org.archive.crawler.util.BdbUriUniqFilter）
有一堆做初始化和配置的函數就直接忽略了，真正相關的函數就只有兩個：
[java] view plain
/**
* Create fingerprint.
* Pubic access so test code can access createKey.
* @param uri URI to fingerprint.
* @return Fingerprint of passed <code>url</code>.
*/
public static long createKey(CharSequence uri) {
String url = uri.toString();
int index = url.indexOf(COLON_SLASH_SLASH);
if (index > 0) {
index = url.indexOf('/', index + COLON_SLASH_SLASH.length());
}
CharSequence hostPlusScheme = (index == -1)? url: url.subSequence(0, index);
long tmp = FPGenerator.std24.fp(hostPlusScheme);
return tmp | (FPGenerator.std40.fp(url) >>> 24);
}
[java] view plain
/**
* value: only 1 byte
*/
private static DatabaseEntry ZERO_LENGTH_ENTRY = new DatabaseEntry(
new byte[0]);
protected boolean setAdd(CharSequence uri) {
DatabaseEntry key = new DatabaseEntry();
LongBinding.longToEntry(createKey(uri), key);
long started = 0;
OperationStatus status = null;
try {
if (logger.isLoggable(Level.INFO)) {
started = System.currentTimeMillis();
}
status = alreadySeen.putNoOverwrite(null, key, ZERO_LENGTH_ENTRY);
if (logger.isLoggable(Level.INFO)) {
aggregatedLookupTime +=
(System.currentTimeMillis() - started);
}
} catch (DatabaseException e) {
logger.severe(e.getMessage());
}
if (status == OperationStatus.SUCCESS) {
count++;
if (logger.isLoggable(Level.INFO)) {
final int logAt = 10000;
if (count > 0 && ((count % logAt) == 0)) {
logger.info("Average lookup " +
(aggregatedLookupTime / logAt) + "ms.");
aggregatedLookupTime = 0;
}
}
}
if(status == OperationStatus.KEYEXIST) {
return false; // not added
} else {
return true;
}
}
簡單解釋一下：
第一個函數createKey是在做URL的壓縮，它將任意長度的URL轉換成一個long型的值。long型的取值范圍有2^64，因此兩個URL映射成同一個long型值的概率應該挺低的。但我也沒太細看這個函數，所以它的效果到底如何不確定。
第二個函數setAdd就是將被壓縮的URL寫入到BerkeleyDB。之前說過，BerkeleyDB是一個key-value database，它的每條記錄都包括了一個key和一個value。但是在URL去重中，value不重要（比如我們之前內存中用的也是HashSet而不是HashMap），因此這里統一用一個byte長度的值來表示value，就是這個static變數ZERO_LENGTH_ENTRY。
別看setAdd有這么多行，真正有用的就這一行：
[java] view plain
status = alreadySeen.putNoOverwrite(null, key, ZERO_LENGTH_ENTRY);
將壓縮後得到的long型值作為key，ZERO_LENGTH_ENTRY作為value插入到BerkeleyDB中，如果db中已經有了這個long型值，就會返回OperationStatus.KEYEXIST，表示對應的URL之前已經抓取到了，那麼這個URL就不會放入待抓取隊列中。
最後
比較遺憾的是，我還沒抽出空對BerkeleyDB這個方案做性能測試，不確定它每秒能執行多少次setAdd操作，是否足夠滿足我們性能的要求。以後補上。
另外，雖然我不了解，但我認為像網路這樣專業的搜索引擎，它的爬蟲的URL去重方案可能比這里列舉的要復雜的多，畢竟那個的各方面的要求也要更高。
『叄』 java獲取url參數以及參數值
參數名一定得是固定的，所傳的參數如果是是字元串需要和別的字元串比較的話可以用toLowerCase()
統一為小寫，或者用toUpperCase()統一為大寫。
『肆』 java怎麼獲取url參數
request.getParameter("參數名");
『伍』 java構造方法URL(URL urlobj,String urlSpecifier)是什麼意思
有參構造：
意思是你使用這個構造方法創建對象的時候需要給他傳遞兩個參數。一個參數是URL類型（對象本身的類型），另一個字元串類型。列如 URL rul = new URL(new URL(),"str");
源碼：
public URL(URL context, String spec) throws MalformedURLException {
this(context, spec, null);
}
兩個參數的構造里調用了三個參數的構造。
具體三參數的構造可以參考源碼
/**
* Creates a URL by parsing the given spec with the specified handler
* within a specified context. If the handler is null, the parsing
* occurs as with the two argument constructor.
*
* @param context the context in which to parse the specification.
* @param spec the {@code String} to parse as a URL.
* @param handler the stream handler for the URL.
* @exception MalformedURLException if no protocol is specified, or an
* unknown protocol is found, or {@code spec} is {@code null}.
* @exception SecurityException
* if a security manager exists and its
* {@code checkPermission} method doesn't allow
* specifying a stream handler.
* @see java.net.URL#URL(java.lang.String, java.lang.String,
* int, java.lang.String)
* @see java.net.URLStreamHandler
* @see java.net.URLStreamHandler#parseURL(java.net.URL,
* java.lang.String, int, int)
*/
public URL(URL context, String spec, URLStreamHandler handler)
throws MalformedURLException
{
String original = spec;
int i, limit, c;
int start = 0;
String newProtocol = null;
boolean aRef=false;
boolean isRelative = false;
// Check for permission to specify a handler
if (handler != null) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkSpecifyHandler(sm);
}
}
try {
limit = spec.length();
while ((limit > 0) && (spec.charAt(limit - 1) <= ' ')) {
limit--; //eliminate trailing whitespace
}
while ((start < limit) && (spec.charAt(start) <= ' ')) {
start++; // eliminate leading whitespace
}
if (spec.regionMatches(true, start, "url:", 0, 4)) {
start += 4;
}
if (start < spec.length() && spec.charAt(start) == '#') {
/* we're assuming this is a ref relative to the context URL.
* This means protocols cannot start w/ '#', but we must parse
* ref URL's like: "hello:there" w/ a ':' in them.
*/
aRef=true;
}
for (i = start ; !aRef && (i < limit) &&
((c = spec.charAt(i)) != '/') ; i++) {
if (c == ':') {
String s = spec.substring(start, i).toLowerCase();
if (isValidProtocol(s)) {
newProtocol = s;
start = i + 1;
}
break;
}
}
// Only use our context if the protocols match.
protocol = newProtocol;
if ((context != null) && ((newProtocol == null) ||
newProtocol.equalsIgnoreCase(context.protocol))) {
// inherit the protocol handler from the context
// if not specified to the constructor
if (handler == null) {
handler = context.handler;
}
// If the context is a hierarchical URL scheme and the spec
// contains a matching scheme then maintain backwards
// compatibility and treat it as if the spec didn't contain
// the scheme; see 5.2.3 of RFC2396
if (context.path != null && context.path.startsWith("/"))
newProtocol = null;
if (newProtocol == null) {
protocol = context.protocol;
authority = context.authority;
userInfo = context.userInfo;
host = context.host;
port = context.port;
file = context.file;
path = context.path;
isRelative = true;
}
}
if (protocol == null) {
throw new MalformedURLException("no protocol: "+original);
}
// Get the protocol handler if not specified or the protocol
// of the context could not be used
if (handler == null &&
(handler = getURLStreamHandler(protocol)) == null) {
throw new MalformedURLException("unknown protocol: "+protocol);
}
this.handler = handler;
i = spec.indexOf('#', start);
if (i >= 0) {
ref = spec.substring(i + 1, limit);
limit = i;
}
/*
* Handle special case inheritance of query and fragment
* implied by RFC2396 section 5.2.2.
*/
if (isRelative && start == limit) {
query = context.query;
if (ref == null) {
ref = context.ref;
}
}
handler.parseURL(this, spec, start, limit);
} catch(MalformedURLException e) {
throw e;
} catch(Exception e) {
MalformedURLException exception = new MalformedURLException(e.getMessage());
exception.initCause(e);
throw exception;
}
}
『陸』 java 能獲取帶參數的url嗎
解析url,本想用正則表達式處理，但正則表達式速度較慢。用split處理一下就可以了。
package RequestPackage;
import java.util.HashMap;
import java.util.Map;
public class CRequest {
/**
* 解析出url請求的路徑，包括頁面
* @param strURL url地址
* @return url路徑
*/
public static String UrlPage(String strURL)
{
String strPage=null;
String[] arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>0)
{
if(arrSplit.length>1)
{
if(arrSplit[0]!=null)
{
strPage=arrSplit[0];
}
}
}
return strPage;
}
/**
* 去掉url中的路徑，留下請求參數部分
* @param strURL url地址
* @return url請求參數部分
*/
private static String TruncateUrlPage(String strURL)
{
String strAllParam=null;
String[] arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>1)
{
if(arrSplit.length>1)
{
if(arrSplit[1]!=null)
{
strAllParam=arrSplit[1];
}
}
}
return strAllParam;
}
/**
* 解析出url參數中的鍵值對
* 如 "index.jsp?Action=del&id=123"，解析出Action:del,id:123存入map中
* @param URL url地址
* @return url請求參數部分
*/
public static Map<String, String> URLRequest(String URL)
{
Map<String, String> mapRequest = new HashMap<String, String>();
String[] arrSplit=null;
String strUrlParam=TruncateUrlPage(URL);
if(strUrlParam==null)
{
return mapRequest;
}
//每個鍵值為一組 www.2cto.com
arrSplit=strUrlParam.split("[&]");
for(String strSplit:arrSplit)
{
String[] arrSplitEqual=null;
arrSplitEqual= strSplit.split("[=]");
//解析出鍵值
if(arrSplitEqual.length>1)
{
//正確解析
mapRequest.put(arrSplitEqual[0], arrSplitEqual[1]);
}
else
{
if(arrSplitEqual[0]!="")
{
//只有參數沒有值，不加入
mapRequest.put(arrSplitEqual[0], "");
}
}
}
return mapRequest;
}
}
測試類
package RequestPackage;
import java.util.Map;
public class TestCRequest {
/**用於測試CRequest類
* @param args
*/
public static void main(String[] args) {
// 請求url
String str = "index.jsp?Action=del&id=123&sort=";
//url頁面路徑
System.out.println(CRequest.UrlPage(str));
//url參數鍵值對
String strRequestKeyAndValues="";
Map<String, String> mapRequest = CRequest.URLRequest(str);
for(String strRequestKey: mapRequest.keySet()) {
String strRequestValue=mapRequest.get(strRequestKey);
strRequestKeyAndValues+="key:"+strRequestKey+",Value:"+strRequestValue+";";
}
System.out.println(strRequestKeyAndValues);
//獲取無效鍵時，輸出null
System.out.println(mapRequest.get("page"));
}
}
『柒』 java怎麼獲取url上的參數
解析url,本想用正則表達式處理，但正則表達式速度較慢。用split處理一下就可以了。
package RequestPackage;
import java.util.HashMap;
import java.util.Map;
public class CRequest {
/**
* 解析出url請求的路徑，包括頁面
* @param strURL url地址
* @return url路徑
*/
public static String UrlPage(String strURL)
{
String strPage=null;
String[] arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>0)
{
if(arrSplit.length>1)
{
if(arrSplit[0]!=null)
{
strPage=arrSplit[0];
}
}
}
return strPage;
}
/**
* 去掉url中的路徑，留下請求參數部分
* @param strURL url地址
* @return url請求參數部分
*/
private static String TruncateUrlPage(String strURL)
{
String strAllParam=null;
String[] arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>1)
{
if(arrSplit.length>1)
{
if(arrSplit[1]!=null)
{
strAllParam=arrSplit[1];
}
}
}
return strAllParam;
}
/**
* 解析出url參數中的鍵值對
* 如 "index.jsp?Action=del&id=123"，解析出Action:del,id:123存入map中
* @param URL url地址
* @return url請求參數部分
*/
public static Map<String, String> URLRequest(String URL)
{
Map<String, String> mapRequest = new HashMap<String, String>();
String[] arrSplit=null;
String strUrlParam=TruncateUrlPage(URL);
if(strUrlParam==null)
{
return mapRequest;
}
//每個鍵值為一組 www.2cto.com
arrSplit=strUrlParam.split("[&]");
for(String strSplit:arrSplit)
{
String[] arrSplitEqual=null;
arrSplitEqual= strSplit.split("[=]");
//解析出鍵值
if(arrSplitEqual.length>1)
{
//正確解析
mapRequest.put(arrSplitEqual[0], arrSplitEqual[1]);
}
else
{
if(arrSplitEqual[0]!="")
{
//只有參數沒有值，不加入
mapRequest.put(arrSplitEqual[0], "");
}
}
}
return mapRequest;
}
}
測試類
package RequestPackage;
import java.util.Map;
public class TestCRequest {
/**用於測試CRequest類
* @param args
*/
public static void main(String[] args) {
// 請求url
String str = "index.jsp?Action=del&id=123&sort=";
//url頁面路徑
System.out.println(CRequest.UrlPage(str));
//url參數鍵值對
String strRequestKeyAndValues="";
Map<String, String> mapRequest = CRequest.URLRequest(str);
for(String strRequestKey: mapRequest.keySet()) {
String strRequestValue=mapRequest.get(strRequestKey);
strRequestKeyAndValues+="key:"+strRequestKey+",Value:"+strRequestValue+";";
}
System.out.println(strRequestKeyAndValues);
//獲取無效鍵時，輸出null
System.out.println(mapRequest.get("page"));
}
}
『捌』 java 獲取url 中的參數請問以下代碼中的 url地址該怎麼寫
String
url
=
request.getScheme()+"://";
//請求協議
http
或
https
url+=request.getHeader("host");
//
請求伺服器
url+=request.getRequestURI();
//
工程名
if(request.getQueryString()!=null)
//判斷請求參數是否為空
url+="?"+request.getQueryString();
//
參數
『玖』 java解析出url請求的路徑和參數鍵值對類
解析url,本想用正則表達式處理，但正則表達式速度較慢。用split處理一下就可以了。
packageRequestPackage;
importjava.util.HashMap;
importjava.util.Map;
publicclassCRequest{
/**
*解析出url請求的路徑，包括頁面
*@paramstrURLurl地址
*@returnurl路徑
*/
publicstaticStringUrlPage(StringstrURL)
{
StringstrPage=null;
String[]arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>0)
{
if(arrSplit.length>1)
{
if(arrSplit[0]!=null)
{
strPage=arrSplit[0];
}
}
}
returnstrPage;
}
/**
*去掉url中的路徑，留下請求參數部分
*@paramstrURLurl地址
*@returnurl請求參數部分
*/
(StringstrURL)
{
StringstrAllParam=null;
String[]arrSplit=null;
strURL=strURL.trim().toLowerCase();
arrSplit=strURL.split("[?]");
if(strURL.length()>1)
{
if(arrSplit.length>1)
{
if(arrSplit[1]!=null)
{
strAllParam=arrSplit[1];
}
}
}
returnstrAllParam;
}
/**
*解析出url參數中的鍵值對
*如"index.jsp?Action=del&id=123"，解析出Action:del,id:123存入map中
*@paramURLurl地址
*@returnurl請求參數部分
*/
publicstaticMap<String,String>URLRequest(StringURL)
{
Map<String,String>mapRequest=newHashMap<String,String>();
String[]arrSplit=null;
StringstrUrlParam=TruncateUrlPage(URL);
if(strUrlParam==null)
{
returnmapRequest;
}
//每個鍵值為一組www.2cto.com
arrSplit=strUrlParam.split("[&]");
for(StringstrSplit:arrSplit)
{
String[]arrSplitEqual=null;
arrSplitEqual=strSplit.split("[=]");
//解析出鍵值
if(arrSplitEqual.length>1)
{
//正確解析
mapRequest.put(arrSplitEqual[0],arrSplitEqual[1]);
}
else
{
if(arrSplitEqual[0]!="")
{
//只有參數沒有值，不加入
mapRequest.put(arrSplitEqual[0],"");
}
}
}
returnmapRequest;
}
}
測試類
packageRequestPackage;
importjava.util.Map;
publicclassTestCRequest{
/**用於測試CRequest類
*@paramargs
*/
publicstaticvoidmain(String[]args){
//請求url
Stringstr="index.jsp?Action=del&id=123&sort=";
//url頁面路徑
System.out.println(CRequest.UrlPage(str));
//url參數鍵值對
StringstrRequestKeyAndValues="";
Map<String,String>mapRequest=CRequest.URLRequest(str);
for(StringstrRequestKey:mapRequest.keySet()){
StringstrRequestValue=mapRequest.get(strRequestKey);
strRequestKeyAndValues+="key:"+strRequestKey+",Value:"+strRequestValue+";";
}
System.out.println(strRequestKeyAndValues);
//獲取無效鍵時，輸出null
System.out.println(mapRequest.get("page"));
}
}
測試代碼運行效果
index.jsp
key:id,Value:123;key:sort,Value:;key:action,Value:del;
null
『拾』 java URL 添加參數的幾種簡單方式
主要有三種方式，先給大家第一種managed-bean，必須 scope設置為request
<managed-bean>
<managed-bean-name>nameBean</managed-bean-name>
<managed-bean-class>demo.NameBean</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
<managed-property>
<property-name>userName</property-name>
<value>#param.name</value>
</managed-property>
...
....
</managed-bean>
第二種方式：缺點是無法往後台傳數據，當然你用javascript做一下動作也可以
<h:inputHidden id="userName" value="#{nameBean.userName}"/>
第三種方式，是直接在bean中獲得，我認為這種應該是最實用、保險的方式。
public static String getRequestParameter(String name) {
return (String)FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get(name);
}