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);
}