dubbo URL 源码
dubbo URL 代码
文件路径：/dubbo-common/src/main/java/org/apache/dubbo/common/URL.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.dubbo.common;
import org.apache.dubbo.common.config.Configuration;
import org.apache.dubbo.common.config.InmemoryConfiguration;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.constants.RemotingConstants;
import org.apache.dubbo.common.convert.ConverterUtil;
import org.apache.dubbo.common.url.component.PathURLAddress;
import org.apache.dubbo.common.url.component.ServiceConfigURL;
import org.apache.dubbo.common.url.component.URLAddress;
import org.apache.dubbo.common.url.component.URLParam;
import org.apache.dubbo.common.url.component.URLPlainParam;
import org.apache.dubbo.common.utils.ArrayUtils;
import org.apache.dubbo.common.utils.CollectionUtils;
import org.apache.dubbo.common.utils.LRUCache;
import org.apache.dubbo.common.utils.NetUtils;
import org.apache.dubbo.common.utils.StringUtils;
import org.apache.dubbo.rpc.model.ApplicationModel;
import org.apache.dubbo.rpc.model.FrameworkModel;
import org.apache.dubbo.rpc.model.ModuleModel;
import org.apache.dubbo.rpc.model.ScopeModel;
import org.apache.dubbo.rpc.model.ScopeModelUtil;
import org.apache.dubbo.rpc.model.ServiceModel;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;
import static org.apache.dubbo.common.BaseServiceMetadata.COLON_SEPARATOR;
import static org.apache.dubbo.common.constants.CommonConstants.ANYHOST_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.ANYHOST_VALUE;
import static org.apache.dubbo.common.constants.CommonConstants.APPLICATION_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.COMMA_SPLIT_PATTERN;
import static org.apache.dubbo.common.constants.CommonConstants.CONSUMER;
import static org.apache.dubbo.common.constants.CommonConstants.GROUP_CHAR_SEPARATOR;
import static org.apache.dubbo.common.constants.CommonConstants.GROUP_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.HOST_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.INTERFACE_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.LOCALHOST_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.PASSWORD_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.PATH_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.PORT_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.PROTOCOL_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.REMOTE_APPLICATION_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.SIDE_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.USERNAME_KEY;
import static org.apache.dubbo.common.constants.CommonConstants.VERSION_KEY;
import static org.apache.dubbo.common.constants.RegistryConstants.CATEGORY_KEY;
import static org.apache.dubbo.common.utils.StringUtils.isBlank;
/**
* URL - Uniform Resource Locator (Immutable, ThreadSafe)
* <p>
* url example:
* <ul>
* <li>http://www.facebook.com/friends?param1=value1&param2=value2
* <li>http://username:password@10.20.130.230:8080/list?version=1.0.0
* <li>ftp://username:password@192.168.1.7:21/1/read.txt
* <li>registry://192.168.1.7:9090/org.apache.dubbo.service1?param1=value1&param2=value2
* </ul>
* <p>
* Some strange example below:
* <ul>
* <li>192.168.1.3:20880<br>
* for this case, url protocol = null, url host = 192.168.1.3, port = 20880, url path = null
* <li>file:///home/user1/router.js?type=script<br>
* for this case, url protocol = file, url host = null, url path = home/user1/router.js
* <li>file://home/user1/router.js?type=script<br>
* for this case, url protocol = file, url host = home, url path = user1/router.js
* <li>file:///D:/1/router.js?type=script<br>
* for this case, url protocol = file, url host = null, url path = D:/1/router.js
* <li>file:/D:/1/router.js?type=script<br>
* same as above file:///D:/1/router.js?type=script
* <li>/home/user1/router.js?type=script <br>
* for this case, url protocol = null, url host = null, url path = home/user1/router.js
* <li>home/user1/router.js?type=script <br>
* for this case, url protocol = null, url host = home, url path = user1/router.js
* </ul>
*
* @see java.net.URL
* @see java.net.URI
*/
public /*final**/
class URL implements Serializable {
private static final long serialVersionUID = -1985165475234910535L;
private static Map<String, URL> cachedURLs = new LRUCache<>();
private final URLAddress urlAddress;
private final URLParam urlParam;
// ==== cache ====
private volatile transient Map<String, Number> numbers;
private volatile transient Map<String, Map<String, Number>> methodNumbers;
private volatile transient Map<String, URL> urls;
private transient String serviceKey;
private transient String protocolServiceKey;
protected volatile Map<String, Object> attributes;
protected URL() {
this.urlAddress = null;
this.urlParam = URLParam.parse(new HashMap<>());
this.attributes = null;
}
public URL(URLAddress urlAddress, URLParam urlParam) {
this(urlAddress, urlParam, null);
}
public URL(URLAddress urlAddress, URLParam urlParam, Map<String, Object> attributes) {
this.urlAddress = urlAddress;
this.urlParam = null == urlParam ? URLParam.parse(new HashMap<>()) : urlParam;
if (attributes != null && !attributes.isEmpty()) {
this.attributes = attributes;
} else {
this.attributes = null;
}
}
public URL(String protocol, String host, int port) {
this(protocol, null, null, host, port, null, (Map<String, String>) null);
}
public URL(String protocol, String host, int port, String[] pairs) { // varargs ... conflict with the following path argument, use array instead.
this(protocol, null, null, host, port, null, CollectionUtils.toStringMap(pairs));
}
public URL(String protocol, String host, int port, Map<String, String> parameters) {
this(protocol, null, null, host, port, null, parameters);
}
public URL(String protocol, String host, int port, String path) {
this(protocol, null, null, host, port, path, (Map<String, String>) null);
}
public URL(String protocol, String host, int port, String path, String... pairs) {
this(protocol, null, null, host, port, path, CollectionUtils.toStringMap(pairs));
}
public URL(String protocol, String host, int port, String path, Map<String, String> parameters) {
this(protocol, null, null, host, port, path, parameters);
}
public URL(String protocol, String username, String password, String host, int port, String path) {
this(protocol, username, password, host, port, path, (Map<String, String>) null);
}
public URL(String protocol, String username, String password, String host, int port, String path, String... pairs) {
this(protocol, username, password, host, port, path, CollectionUtils.toStringMap(pairs));
}
public URL(String protocol,
String username,
String password,
String host,
int port,
String path,
Map<String, String> parameters) {
if (StringUtils.isEmpty(username)
&& StringUtils.isNotEmpty(password)) {
throw new IllegalArgumentException("Invalid url, password without username!");
}
this.urlAddress = new PathURLAddress(protocol, username, password, path, host, port);
this.urlParam = URLParam.parse(parameters);
this.attributes = null;
}
protected URL(String protocol,
String username,
String password,
String host,
int port,
String path,
Map<String, String> parameters,
boolean modifiable) {
if (StringUtils.isEmpty(username)
&& StringUtils.isNotEmpty(password)) {
throw new IllegalArgumentException("Invalid url, password without username!");
}
this.urlAddress = new PathURLAddress(protocol, username, password, path, host, port);
this.urlParam = URLParam.parse(parameters);
this.attributes = null;
}
public static URL cacheableValueOf(String url) {
URL cachedURL = cachedURLs.get(url);
if (cachedURL != null) {
return cachedURL;
}
cachedURL = valueOf(url, false);
cachedURLs.put(url, cachedURL);
return cachedURL;
}
/**
* parse decoded url string, formatted dubbo://host:port/path?param=value, into strutted URL.
*
* @param url, decoded url string
* @return
*/
public static URL valueOf(String url) {
return valueOf(url, false);
}
public static URL valueOf(String url, ScopeModel scopeModel) {
return valueOf(url).setScopeModel(scopeModel);
}
/**
* parse normal or encoded url string into strutted URL:
* - dubbo://host:port/path?param=value
* - URL.encode("dubbo://host:port/path?param=value")
*
* @param url, url string
* @param encoded, encoded or decoded
* @return
*/
public static URL valueOf(String url, boolean encoded) {
if (encoded) {
return URLStrParser.parseEncodedStr(url);
}
return URLStrParser.parseDecodedStr(url);
}
public static URL valueOf(String url, String... reserveParams) {
URL result = valueOf(url);
if (reserveParams == null || reserveParams.length == 0) {
return result;
}
Map<String, String> newMap = new HashMap<>(reserveParams.length);
Map<String, String> oldMap = result.getParameters();
for (String reserveParam : reserveParams) {
String tmp = oldMap.get(reserveParam);
if (StringUtils.isNotEmpty(tmp)) {
newMap.put(reserveParam, tmp);
}
}
return result.clearParameters().addParameters(newMap);
}
public static URL valueOf(URL url, String[] reserveParams, String[] reserveParamPrefixes) {
Map<String, String> newMap = new HashMap<>();
Map<String, String> oldMap = url.getParameters();
if (reserveParamPrefixes != null && reserveParamPrefixes.length != 0) {
for (Map.Entry<String, String> entry : oldMap.entrySet()) {
for (String reserveParamPrefix : reserveParamPrefixes) {
if (entry.getKey().startsWith(reserveParamPrefix) && StringUtils.isNotEmpty(entry.getValue())) {
newMap.put(entry.getKey(), entry.getValue());
}
}
}
}
if (reserveParams != null) {
for (String reserveParam : reserveParams) {
String tmp = oldMap.get(reserveParam);
if (StringUtils.isNotEmpty(tmp)) {
newMap.put(reserveParam, tmp);
}
}
}
return newMap.isEmpty() ? new ServiceConfigURL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath(), (Map<String, String>) null, url.getAttributes())
: new ServiceConfigURL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath(), newMap, url.getAttributes());
}
public static String encode(String value) {
if (StringUtils.isEmpty(value)) {
return "";
}
try {
return URLEncoder.encode(value, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
public static String decode(String value) {
if (StringUtils.isEmpty(value)) {
return "";
}
try {
return URLDecoder.decode(value, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
static String appendDefaultPort(String address, int defaultPort) {
if (address != null && address.length() > 0 && defaultPort > 0) {
int i = address.indexOf(':');
if (i < 0) {
return address + ":" + defaultPort;
} else if (Integer.parseInt(address.substring(i + 1)) == 0) {
return address.substring(0, i + 1) + defaultPort;
}
}
return address;
}
public URLAddress getUrlAddress() {
return urlAddress;
}
public URLParam getUrlParam() {
return urlParam;
}
public String getProtocol() {
return urlAddress == null ? null : urlAddress.getProtocol();
}
public URL setProtocol(String protocol) {
URLAddress newURLAddress = urlAddress.setProtocol(protocol);
return returnURL(newURLAddress);
}
public String getUsername() {
return urlAddress == null ? null : urlAddress.getUsername();
}
public URL setUsername(String username) {
URLAddress newURLAddress = urlAddress.setUsername(username);
return returnURL(newURLAddress);
}
public String getPassword() {
return urlAddress == null ? null : urlAddress.getPassword();
}
public URL setPassword(String password) {
URLAddress newURLAddress = urlAddress.setPassword(password);
return returnURL(newURLAddress);
}
/**
* refer to https://datatracker.ietf.org/doc/html/rfc3986
*
* @return authority
*/
public String getAuthority() {
StringBuilder ret = new StringBuilder();
ret.append(getUserInformation());
if (StringUtils.isNotEmpty(getHost())) {
if (StringUtils.isNotEmpty(getUsername()) || StringUtils.isNotEmpty(getPassword())) {
ret.append('@');
}
ret.append(getHost());
if (getPort() != 0) {
ret.append(':');
ret.append(getPort());
}
}
return ret.length() == 0 ? null : ret.toString();
}
/**
* refer to https://datatracker.ietf.org/doc/html/rfc3986
*
* @return user information
*/
public String getUserInformation() {
StringBuilder ret = new StringBuilder();
if (StringUtils.isEmpty(getUsername()) && StringUtils.isEmpty(getPassword())) {
return ret.toString();
}
if (StringUtils.isNotEmpty(getUsername())) {
ret.append(getUsername());
}
ret.append(':');
if (StringUtils.isNotEmpty(getPassword())) {
ret.append(getPassword());
}
return ret.length() == 0 ? null : ret.toString();
}
public String getHost() {
return urlAddress == null ? null : urlAddress.getHost();
}
public URL setHost(String host) {
URLAddress newURLAddress = urlAddress.setHost(host);
return returnURL(newURLAddress);
}
public int getPort() {
return urlAddress == null ? 0 : urlAddress.getPort();
}
public URL setPort(int port) {
URLAddress newURLAddress = urlAddress.setPort(port);
return returnURL(newURLAddress);
}
public int getPort(int defaultPort) {
int port = getPort();
return port <= 0 ? defaultPort : port;
}
public String getAddress() {
return urlAddress.getAddress();
}
public URL setAddress(String address) {
int i = address.lastIndexOf(':');
String host;
int port = this.getPort();
if (i >= 0) {
host = address.substring(0, i);
port = Integer.parseInt(address.substring(i + 1));
} else {
host = address;
}
URLAddress newURLAddress = urlAddress.setAddress(host, port);
return returnURL(newURLAddress);
}
public String getIp() {
return urlAddress.getIp();
}
public String getBackupAddress() {
return getBackupAddress(0);
}
public String getBackupAddress(int defaultPort) {
StringBuilder address = new StringBuilder(appendDefaultPort(getAddress(), defaultPort));
String[] backups = getParameter(RemotingConstants.BACKUP_KEY, new String[0]);
if (ArrayUtils.isNotEmpty(backups)) {
for (String backup : backups) {
address.append(',');
address.append(appendDefaultPort(backup, defaultPort));
}
}
return address.toString();
}
public List<URL> getBackupUrls() {
List<URL> urls = new ArrayList<>();
urls.add(this);
String[] backups = getParameter(RemotingConstants.BACKUP_KEY, new String[0]);
if (backups != null && backups.length > 0) {
for (String backup : backups) {
urls.add(this.setAddress(backup));
}
}
return urls;
}
public String getPath() {
return urlAddress == null ? null : urlAddress.getPath();
}
public URL setPath(String path) {
URLAddress newURLAddress = urlAddress.setPath(path);
return returnURL(newURLAddress);
}
public String getAbsolutePath() {
String path = getPath();
if (path != null && !path.startsWith("/")) {
return "/" + path;
}
return path;
}
public Map<String, String> getParameters() {
return urlParam.getParameters();
}
public Map<String, String> getAllParameters() {
return this.getParameters();
}
/**
* Get the parameters to be selected(filtered)
*
* @param nameToSelect the {@link Predicate} to select the parameter name
* @return non-null {@link Map}
* @since 2.7.8
*/
public Map<String, String> getParameters(Predicate<String> nameToSelect) {
Map<String, String> selectedParameters = new LinkedHashMap<>();
for (Map.Entry<String, String> entry : getParameters().entrySet()) {
String name = entry.getKey();
if (nameToSelect.test(name)) {
selectedParameters.put(name, entry.getValue());
}
}
return Collections.unmodifiableMap(selectedParameters);
}
public String getParameterAndDecoded(String key) {
return getParameterAndDecoded(key, null);
}
public String getParameterAndDecoded(String key, String defaultValue) {
return decode(getParameter(key, defaultValue));
}
public String getParameter(String key) {
return urlParam.getParameter(key);
}
public String getParameter(String key, String defaultValue) {
String value = getParameter(key);
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public String[] getParameter(String key, String[] defaultValue) {
String value = getParameter(key);
return StringUtils.isEmpty(value) ? defaultValue : COMMA_SPLIT_PATTERN.split(value);
}
public List<String> getParameter(String key, List<String> defaultValue) {
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
String[] strArray = COMMA_SPLIT_PATTERN.split(value);
return Arrays.asList(strArray);
}
/**
* Get parameter
*
* @param key the key of parameter
* @param valueType the type of parameter value
* @param <T> the type of parameter value
* @return get the parameter if present, or <code>null</code>
* @since 2.7.8
*/
public <T> T getParameter(String key, Class<T> valueType) {
return getParameter(key, valueType, null);
}
/**
* Get parameter
*
* @param key the key of parameter
* @param valueType the type of parameter value
* @param defaultValue the default value if parameter is absent
* @param <T> the type of parameter value
* @return get the parameter if present, or <code>defaultValue</code> will be used.
* @since 2.7.8
*/
public <T> T getParameter(String key, Class<T> valueType, T defaultValue) {
String value = getParameter(key);
T result = null;
if (!isBlank(value)) {
result = getOrDefaultFrameworkModel().getBeanFactory().getBean(ConverterUtil.class).convertIfPossible(value, valueType);
}
if (result == null) {
result = defaultValue;
}
return result;
}
public URL setScopeModel(ScopeModel scopeModel) {
return putAttribute(CommonConstants.SCOPE_MODEL, scopeModel);
}
public ScopeModel getScopeModel() {
return (ScopeModel) getAttribute(CommonConstants.SCOPE_MODEL);
}
public FrameworkModel getOrDefaultFrameworkModel() {
return ScopeModelUtil.getFrameworkModel(getScopeModel());
}
public ApplicationModel getOrDefaultApplicationModel() {
return ScopeModelUtil.getApplicationModel(getScopeModel());
}
public ApplicationModel getApplicationModel() {
return ScopeModelUtil.getOrNullApplicationModel(getScopeModel());
}
public ModuleModel getOrDefaultModuleModel() {
return ScopeModelUtil.getModuleModel(getScopeModel());
}
public URL setServiceModel(ServiceModel serviceModel) {
return putAttribute(CommonConstants.SERVICE_MODEL, serviceModel);
}
public ServiceModel getServiceModel() {
return (ServiceModel) getAttribute(CommonConstants.SERVICE_MODEL);
}
protected Map<String, Number> getNumbers() {
// concurrent initialization is tolerant
if (numbers == null) {
numbers = new ConcurrentHashMap<>();
}
return numbers;
}
protected Map<String, Map<String, Number>> getMethodNumbers() {
if (methodNumbers == null) { // concurrent initialization is tolerant
methodNumbers = new ConcurrentHashMap<>();
}
return methodNumbers;
}
private Map<String, URL> getUrls() {
// concurrent initialization is tolerant
if (urls == null) {
urls = new ConcurrentHashMap<>();
}
return urls;
}
public URL getUrlParameter(String key) {
URL u = getUrls().get(key);
if (u != null) {
return u;
}
String value = getParameterAndDecoded(key);
if (StringUtils.isEmpty(value)) {
return null;
}
u = URL.valueOf(value);
getUrls().put(key, u);
return u;
}
public double getParameter(String key, double defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.doubleValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
double d = Double.parseDouble(value);
getNumbers().put(key, d);
return d;
}
public float getParameter(String key, float defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.floatValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
float f = Float.parseFloat(value);
getNumbers().put(key, f);
return f;
}
public long getParameter(String key, long defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.longValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
long l = Long.parseLong(value);
getNumbers().put(key, l);
return l;
}
public int getParameter(String key, int defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.intValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
int i = Integer.parseInt(value);
getNumbers().put(key, i);
return i;
}
public short getParameter(String key, short defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.shortValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
short s = Short.parseShort(value);
getNumbers().put(key, s);
return s;
}
public byte getParameter(String key, byte defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.byteValue();
}
String value = getParameter(key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
byte b = Byte.parseByte(value);
getNumbers().put(key, b);
return b;
}
public float getPositiveParameter(String key, float defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
float value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public double getPositiveParameter(String key, double defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
double value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public long getPositiveParameter(String key, long defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
long value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public int getPositiveParameter(String key, int defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
int value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public short getPositiveParameter(String key, short defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
short value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public byte getPositiveParameter(String key, byte defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
byte value = getParameter(key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public char getParameter(String key, char defaultValue) {
String value = getParameter(key);
return StringUtils.isEmpty(value) ? defaultValue : value.charAt(0);
}
public boolean getParameter(String key, boolean defaultValue) {
String value = getParameter(key);
return StringUtils.isEmpty(value) ? defaultValue : Boolean.parseBoolean(value);
}
public boolean hasParameter(String key) {
String value = getParameter(key);
return value != null && value.length() > 0;
}
public String getMethodParameterAndDecoded(String method, String key) {
return URL.decode(getMethodParameter(method, key));
}
public String getMethodParameterAndDecoded(String method, String key, String defaultValue) {
return URL.decode(getMethodParameter(method, key, defaultValue));
}
public String getMethodParameter(String method, String key) {
return urlParam.getMethodParameter(method, key);
}
public String getMethodParameterStrict(String method, String key) {
return urlParam.getMethodParameterStrict(method, key);
}
public String getMethodParameter(String method, String key, String defaultValue) {
String value = getMethodParameter(method, key);
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public double getMethodParameter(String method, String key, double defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.doubleValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
double d = Double.parseDouble(value);
updateCachedNumber(method, key, d);
return d;
}
public float getMethodParameter(String method, String key, float defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.floatValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
float f = Float.parseFloat(value);
updateCachedNumber(method, key, f);
return f;
}
public long getMethodParameter(String method, String key, long defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.longValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
long l = Long.parseLong(value);
updateCachedNumber(method, key, l);
return l;
}
public int getMethodParameter(String method, String key, int defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.intValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
int i = Integer.parseInt(value);
updateCachedNumber(method, key, i);
return i;
}
public short getMethodParameter(String method, String key, short defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.shortValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
short s = Short.parseShort(value);
updateCachedNumber(method, key, s);
return s;
}
public byte getMethodParameter(String method, String key, byte defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.byteValue();
}
String value = getMethodParameter(method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
byte b = Byte.parseByte(value);
updateCachedNumber(method, key, b);
return b;
}
private Number getCachedNumber(String method, String key) {
Map<String, Number> keyNumber = getMethodNumbers().get(method);
if (keyNumber != null) {
return keyNumber.get(key);
}
return null;
}
private void updateCachedNumber(String method, String key, Number n) {
Map<String, Number> keyNumber = getMethodNumbers().computeIfAbsent(method, m -> new HashMap<>());
keyNumber.put(key, n);
}
public double getMethodPositiveParameter(String method, String key, double defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
double value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public float getMethodPositiveParameter(String method, String key, float defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
float value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public long getMethodPositiveParameter(String method, String key, long defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
long value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public int getMethodPositiveParameter(String method, String key, int defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
int value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public short getMethodPositiveParameter(String method, String key, short defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
short value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public byte getMethodPositiveParameter(String method, String key, byte defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
byte value = getMethodParameter(method, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public char getMethodParameter(String method, String key, char defaultValue) {
String value = getMethodParameter(method, key);
return StringUtils.isEmpty(value) ? defaultValue : value.charAt(0);
}
public boolean getMethodParameter(String method, String key, boolean defaultValue) {
String value = getMethodParameter(method, key);
return StringUtils.isEmpty(value) ? defaultValue : Boolean.parseBoolean(value);
}
public boolean hasMethodParameter(String method, String key) {
if (method == null) {
String suffix = "." + key;
for (String fullKey : getParameters().keySet()) {
if (fullKey.endsWith(suffix)) {
return true;
}
}
return false;
}
if (key == null) {
String prefix = method + ".";
for (String fullKey : getParameters().keySet()) {
if (fullKey.startsWith(prefix)) {
return true;
}
}
return false;
}
String value = getMethodParameterStrict(method, key);
return StringUtils.isNotEmpty(value);
}
public String getAnyMethodParameter(String key) {
return urlParam.getAnyMethodParameter(key);
}
public boolean hasMethodParameter(String method) {
return urlParam.hasMethodParameter(method);
}
public boolean isLocalHost() {
return NetUtils.isLocalHost(getHost()) || getParameter(LOCALHOST_KEY, false);
}
public boolean isAnyHost() {
return ANYHOST_VALUE.equals(getHost()) || getParameter(ANYHOST_KEY, false);
}
public URL addParameterAndEncoded(String key, String value) {
if (StringUtils.isEmpty(value)) {
return this;
}
return addParameter(key, encode(value));
}
public URL addParameter(String key, boolean value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, char value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, byte value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, short value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, int value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, long value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, float value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, double value) {
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, Enum<?> value) {
if (value == null) {
return this;
}
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, Number value) {
if (value == null) {
return this;
}
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, CharSequence value) {
if (value == null || value.length() == 0) {
return this;
}
return addParameter(key, String.valueOf(value));
}
public URL addParameter(String key, String value) {
URLParam newParam = urlParam.addParameter(key, value);
return returnURL(newParam);
}
public URL addParameterIfAbsent(String key, String value) {
URLParam newParam = urlParam.addParameterIfAbsent(key, value);
return returnURL(newParam);
}
/**
* Add parameters to a new url.
*
* @param parameters parameters in key-value pairs
* @return A new URL
*/
public URL addParameters(Map<String, String> parameters) {
URLParam newParam = urlParam.addParameters(parameters);
return returnURL(newParam);
}
public URL addParametersIfAbsent(Map<String, String> parameters) {
URLParam newURLParam = urlParam.addParametersIfAbsent(parameters);
return returnURL(newURLParam);
}
public URL addParameters(String... pairs) {
if (pairs == null || pairs.length == 0) {
return this;
}
if (pairs.length % 2 != 0) {
throw new IllegalArgumentException("Map pairs can not be odd number.");
}
Map<String, String> map = new HashMap<>();
int len = pairs.length / 2;
for (int i = 0; i < len; i++) {
map.put(pairs[2 * i], pairs[2 * i + 1]);
}
return addParameters(map);
}
public URL addParameterString(String query) {
if (StringUtils.isEmpty(query)) {
return this;
}
return addParameters(StringUtils.parseQueryString(query));
}
public URL removeParameter(String key) {
if (StringUtils.isEmpty(key)) {
return this;
}
return removeParameters(key);
}
public URL removeParameters(Collection<String> keys) {
if (CollectionUtils.isEmpty(keys)) {
return this;
}
return removeParameters(keys.toArray(new String[0]));
}
public URL removeParameters(String... keys) {
URLParam newURLParam = urlParam.removeParameters(keys);
return returnURL(newURLParam);
}
public URL clearParameters() {
URLParam newURLParam = urlParam.clearParameters();
return returnURL(newURLParam);
}
public String getRawParameter(String key) {
if (PROTOCOL_KEY.equals(key)) {
return urlAddress.getProtocol();
}
if (USERNAME_KEY.equals(key)) {
return urlAddress.getUsername();
}
if (PASSWORD_KEY.equals(key)) {
return urlAddress.getPassword();
}
if (HOST_KEY.equals(key)) {
return urlAddress.getHost();
}
if (PORT_KEY.equals(key)) {
return String.valueOf(urlAddress.getPort());
}
if (PATH_KEY.equals(key)) {
return urlAddress.getPath();
}
return urlParam.getParameter(key);
}
public Map<String, String> toMap() {
Map<String, String> map = new HashMap<>(getParameters());
if (getProtocol() != null) {
map.put(PROTOCOL_KEY, getProtocol());
}
if (getUsername() != null) {
map.put(USERNAME_KEY, getUsername());
}
if (getPassword() != null) {
map.put(PASSWORD_KEY, getPassword());
}
if (getHost() != null) {
map.put(HOST_KEY, getHost());
}
if (getPort() > 0) {
map.put(PORT_KEY, String.valueOf(getPort()));
}
if (getPath() != null) {
map.put(PATH_KEY, getPath());
}
return map;
}
@Override
public String toString() {
return buildString(false, true); // no show username and password
}
public String toString(String... parameters) {
return buildString(false, true, parameters); // no show username and password
}
public String toIdentityString() {
return buildString(true, false); // only return identity message, see the method "equals" and "hashCode"
}
public String toIdentityString(String... parameters) {
return buildString(true, false, parameters); // only return identity message, see the method "equals" and "hashCode"
}
public String toFullString() {
return buildString(true, true);
}
public String toFullString(String... parameters) {
return buildString(true, true, parameters);
}
public String toParameterString() {
return toParameterString(new String[0]);
}
public String toParameterString(String... parameters) {
StringBuilder buf = new StringBuilder();
buildParameters(buf, false, parameters);
return buf.toString();
}
protected void buildParameters(StringBuilder buf, boolean concat, String[] parameters) {
if (CollectionUtils.isNotEmptyMap(getParameters())) {
List<String> includes = (ArrayUtils.isEmpty(parameters) ? null : Arrays.asList(parameters));
boolean first = true;
for (Map.Entry<String, String> entry : new TreeMap<>(getParameters()).entrySet()) {
if (StringUtils.isNotEmpty(entry.getKey())
&& (includes == null || includes.contains(entry.getKey()))) {
if (first) {
if (concat) {
buf.append('?');
}
first = false;
} else {
buf.append('&');
}
buf.append(entry.getKey());
buf.append('=');
buf.append(entry.getValue() == null ? "" : entry.getValue().trim());
}
}
}
}
private String buildString(boolean appendUser, boolean appendParameter, String... parameters) {
return buildString(appendUser, appendParameter, false, false, parameters);
}
private String buildString(boolean appendUser, boolean appendParameter, boolean useIP, boolean useService, String... parameters) {
StringBuilder buf = new StringBuilder();
if (StringUtils.isNotEmpty(getProtocol())) {
buf.append(getProtocol());
buf.append("://");
}
if (appendUser && StringUtils.isNotEmpty(getUsername())) {
buf.append(getUsername());
if (StringUtils.isNotEmpty(getPassword())) {
buf.append(':');
buf.append(getPassword());
}
buf.append('@');
}
String host;
if (useIP) {
host = urlAddress.getIp();
} else {
host = getHost();
}
if (StringUtils.isNotEmpty(host)) {
buf.append(host);
if (getPort() > 0) {
buf.append(':');
buf.append(getPort());
}
}
String path;
if (useService) {
path = getServiceKey();
} else {
path = getPath();
}
if (StringUtils.isNotEmpty(path)) {
buf.append('/');
buf.append(path);
}
if (appendParameter) {
buildParameters(buf, true, parameters);
}
return buf.toString();
}
public java.net.URL toJavaURL() {
try {
return new java.net.URL(toString());
} catch (MalformedURLException e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
public InetSocketAddress toInetSocketAddress() {
return new InetSocketAddress(getHost(), getPort());
}
/**
* The format is "{interface}:[version]:[group]"
*
* @return
*/
public String getColonSeparatedKey() {
StringBuilder serviceNameBuilder = new StringBuilder();
serviceNameBuilder.append(this.getServiceInterface());
append(serviceNameBuilder, VERSION_KEY, false);
append(serviceNameBuilder, GROUP_KEY, false);
return serviceNameBuilder.toString();
}
private void append(StringBuilder target, String parameterName, boolean first) {
String parameterValue = this.getParameter(parameterName);
if (!isBlank(parameterValue)) {
if (!first) {
target.append(':');
}
target.append(parameterValue);
} else {
target.append(':');
}
}
/**
* The format of return value is '{group}/{interfaceName}:{version}'
*
* @return
*/
public String getServiceKey() {
if (serviceKey != null) {
return serviceKey;
}
String inf = getServiceInterface();
if (inf == null) {
return null;
}
serviceKey = buildKey(inf, getGroup(), getVersion());
return serviceKey;
}
/**
* Format : interface:version
*
* @return
*/
public String getDisplayServiceKey() {
if (StringUtils.isEmpty(getVersion())) {
return getServiceInterface();
}
return getServiceInterface() +
COLON_SEPARATOR + getVersion();
}
/**
* The format of return value is '{group}/{path/interfaceName}:{version}'
*
* @return
*/
public String getPathKey() {
String inf = StringUtils.isNotEmpty(getPath()) ? getPath() : getServiceInterface();
if (inf == null) {
return null;
}
return buildKey(inf, getGroup(), getVersion());
}
public static String buildKey(String path, String group, String version) {
return BaseServiceMetadata.buildServiceKey(path, group, version);
}
public String getProtocolServiceKey() {
if (protocolServiceKey != null) {
return protocolServiceKey;
}
this.protocolServiceKey = getServiceKey();
/*
Special treatment for urls begins with 'consumer://', that is, a consumer subscription url instance with no protocol specified.
If protocol is specified on the consumer side, then this method will return as normal.
*/
if (!CONSUMER.equals(getProtocol())) {
this.protocolServiceKey += (GROUP_CHAR_SEPARATOR + getProtocol());
}
return protocolServiceKey;
}
public String toServiceStringWithoutResolving() {
return buildString(true, false, false, true);
}
public String toServiceString() {
return buildString(true, false, true, true);
}
@Deprecated
public String getServiceName() {
return getServiceInterface();
}
public String getServiceInterface() {
return getParameter(INTERFACE_KEY, getPath());
}
public URL setServiceInterface(String service) {
return addParameter(INTERFACE_KEY, service);
}
/**
* @see #getParameter(String, int)
* @deprecated Replace to <code>getParameter(String, int)</code>
*/
@Deprecated
public int getIntParameter(String key) {
return getParameter(key, 0);
}
/**
* @see #getParameter(String, int)
* @deprecated Replace to <code>getParameter(String, int)</code>
*/
@Deprecated
public int getIntParameter(String key, int defaultValue) {
return getParameter(key, defaultValue);
}
/**
* @see #getPositiveParameter(String, int)
* @deprecated Replace to <code>getPositiveParameter(String, int)</code>
*/
@Deprecated
public int getPositiveIntParameter(String key, int defaultValue) {
return getPositiveParameter(key, defaultValue);
}
/**
* @see #getParameter(String, boolean)
* @deprecated Replace to <code>getParameter(String, boolean)</code>
*/
@Deprecated
public boolean getBooleanParameter(String key) {
return getParameter(key, false);
}
/**
* @see #getParameter(String, boolean)
* @deprecated Replace to <code>getParameter(String, boolean)</code>
*/
@Deprecated
public boolean getBooleanParameter(String key, boolean defaultValue) {
return getParameter(key, defaultValue);
}
/**
* @see #getMethodParameter(String, String, int)
* @deprecated Replace to <code>getMethodParameter(String, String, int)</code>
*/
@Deprecated
public int getMethodIntParameter(String method, String key) {
return getMethodParameter(method, key, 0);
}
/**
* @see #getMethodParameter(String, String, int)
* @deprecated Replace to <code>getMethodParameter(String, String, int)</code>
*/
@Deprecated
public int getMethodIntParameter(String method, String key, int defaultValue) {
return getMethodParameter(method, key, defaultValue);
}
/**
* @see #getMethodPositiveParameter(String, String, int)
* @deprecated Replace to <code>getMethodPositiveParameter(String, String, int)</code>
*/
@Deprecated
public int getMethodPositiveIntParameter(String method, String key, int defaultValue) {
return getMethodPositiveParameter(method, key, defaultValue);
}
/**
* @see #getMethodParameter(String, String, boolean)
* @deprecated Replace to <code>getMethodParameter(String, String, boolean)</code>
*/
@Deprecated
public boolean getMethodBooleanParameter(String method, String key) {
return getMethodParameter(method, key, false);
}
/**
* @see #getMethodParameter(String, String, boolean)
* @deprecated Replace to <code>getMethodParameter(String, String, boolean)</code>
*/
@Deprecated
public boolean getMethodBooleanParameter(String method, String key, boolean defaultValue) {
return getMethodParameter(method, key, defaultValue);
}
public Configuration toConfiguration() {
InmemoryConfiguration configuration = new InmemoryConfiguration();
configuration.addProperties(getParameters());
return configuration;
}
private volatile int hashCodeCache = -1;
@Override
public int hashCode() {
if (hashCodeCache == -1) {
hashCodeCache = Objects.hash(urlAddress, urlParam);
}
return hashCodeCache;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof URL)) {
return false;
}
URL other = (URL) obj;
return Objects.equals(this.getUrlAddress(), other.getUrlAddress()) && Objects.equals(this.getUrlParam(), other.getUrlParam());
}
public static void putMethodParameter(String method, String key, String value, Map<String, Map<String, String>> methodParameters) {
Map<String, String> subParameter = methodParameters.computeIfAbsent(method, k -> new HashMap<>());
subParameter.put(key, value);
}
protected <T extends URL> T newURL(URLAddress urlAddress, URLParam urlParam) {
return (T) new ServiceConfigURL(urlAddress, urlParam, attributes);
}
/* methods introduced for CompositeURL, CompositeURL must override to make the implementations meaningful */
public String getApplication(String defaultValue) {
String value = getApplication();
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public String getApplication() {
return getParameter(APPLICATION_KEY);
}
public String getRemoteApplication() {
return getParameter(REMOTE_APPLICATION_KEY);
}
public String getGroup() {
return getParameter(GROUP_KEY);
}
public String getGroup(String defaultValue) {
String value = getGroup();
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public String getVersion() {
return getParameter(VERSION_KEY);
}
public String getVersion(String defaultValue) {
String value = getVersion();
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public String getConcatenatedParameter(String key) {
return getParameter(key);
}
public String getCategory(String defaultValue) {
String value = getCategory();
if (StringUtils.isEmpty(value)) {
value = defaultValue;
}
return value;
}
public String[] getCategory(String[] defaultValue) {
String value = getCategory();
return StringUtils.isEmpty(value) ? defaultValue : COMMA_SPLIT_PATTERN.split(value);
}
public String getCategory() {
return getParameter(CATEGORY_KEY);
}
public String getSide(String defaultValue) {
String value = getSide();
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public String getSide() {
return getParameter(SIDE_KEY);
}
/* Service Config URL, START*/
public Map<String, Object> getAttributes() {
return attributes == null ? Collections.emptyMap() : attributes;
}
public URL addAttributes(Map<String, Object> attributes) {
if (attributes != null) {
attributes.putAll(attributes);
}
return this;
}
public Object getAttribute(String key) {
return attributes == null ? null : attributes.get(key);
}
public Object getAttribute(String key, Object defaultValue) {
Object val = attributes == null ? null : attributes.get(key);
return val != null ? val : defaultValue;
}
public URL putAttribute(String key, Object obj) {
if (attributes == null) {
this.attributes = new HashMap<>();
}
attributes.put(key, obj);
return this;
}
public URL removeAttribute(String key) {
if (attributes != null) {
attributes.remove(key);
}
return this;
}
public boolean hasAttribute(String key) {
return attributes != null && attributes.containsKey(key);
}
/* Service Config URL, END*/
private URL returnURL(URLAddress newURLAddress) {
if (urlAddress == newURLAddress) {
return this;
}
return newURL(newURLAddress, urlParam);
}
private URL returnURL(URLParam newURLParam) {
if (urlParam == newURLParam) {
return this;
}
return newURL(urlAddress, newURLParam);
}
/* add service scope operations, see InstanceAddressURL */
public Map<String, String> getServiceParameters(String service) {
return getParameters();
}
public String getServiceParameter(String service, String key) {
return getParameter(key);
}
public String getServiceParameter(String service, String key, String defaultValue) {
String value = getServiceParameter(service, key);
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public int getServiceParameter(String service, String key, int defaultValue) {
return getParameter(key, defaultValue);
}
public double getServiceParameter(String service, String key, double defaultValue) {
Number n = getServiceNumbers(service).get(key);
if (n != null) {
return n.doubleValue();
}
String value = getServiceParameter(service, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
double d = Double.parseDouble(value);
getNumbers().put(key, d);
return d;
}
public float getServiceParameter(String service, String key, float defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.floatValue();
}
String value = getServiceParameter(service, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
float f = Float.parseFloat(value);
getNumbers().put(key, f);
return f;
}
public long getServiceParameter(String service, String key, long defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.longValue();
}
String value = getServiceParameter(service, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
long l = Long.parseLong(value);
getNumbers().put(key, l);
return l;
}
public short getServiceParameter(String service, String key, short defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.shortValue();
}
String value = getServiceParameter(service, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
short s = Short.parseShort(value);
getNumbers().put(key, s);
return s;
}
public byte getServiceParameter(String service, String key, byte defaultValue) {
Number n = getNumbers().get(key);
if (n != null) {
return n.byteValue();
}
String value = getServiceParameter(service, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
byte b = Byte.parseByte(value);
getNumbers().put(key, b);
return b;
}
public char getServiceParameter(String service, String key, char defaultValue) {
String value = getServiceParameter(service, key);
return StringUtils.isEmpty(value) ? defaultValue : value.charAt(0);
}
public boolean getServiceParameter(String service, String key, boolean defaultValue) {
String value = getServiceParameter(service, key);
return StringUtils.isEmpty(value) ? defaultValue : Boolean.parseBoolean(value);
}
public boolean hasServiceParameter(String service, String key) {
String value = getServiceParameter(service, key);
return value != null && value.length() > 0;
}
public float getPositiveServiceParameter(String service, String key, float defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
float value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public double getPositiveServiceParameter(String service, String key, double defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
double value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public long getPositiveServiceParameter(String service, String key, long defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
long value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public int getPositiveServiceParameter(String service, String key, int defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
int value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public short getPositiveServiceParameter(String service, String key, short defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
short value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public byte getPositiveServiceParameter(String service, String key, byte defaultValue) {
if (defaultValue <= 0) {
throw new IllegalArgumentException("defaultValue <= 0");
}
byte value = getServiceParameter(service, key, defaultValue);
return value <= 0 ? defaultValue : value;
}
public String getServiceMethodParameterAndDecoded(String service, String method, String key) {
return URL.decode(getServiceMethodParameter(service, method, key));
}
public String getServiceMethodParameterAndDecoded(String service, String method, String key, String defaultValue) {
return URL.decode(getServiceMethodParameter(service, method, key, defaultValue));
}
public String getServiceMethodParameterStrict(String service, String method, String key) {
return getMethodParameterStrict(method, key);
}
public String getServiceMethodParameter(String service, String method, String key) {
return getMethodParameter(method, key);
}
public String getServiceMethodParameter(String service, String method, String key, String defaultValue) {
String value = getServiceMethodParameter(service, method, key);
return StringUtils.isEmpty(value) ? defaultValue : value;
}
public double getServiceMethodParameter(String service, String method, String key, double defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.doubleValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
double d = Double.parseDouble(value);
updateCachedNumber(method, key, d);
return d;
}
public float getServiceMethodParameter(String service, String method, String key, float defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.floatValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
float f = Float.parseFloat(value);
updateCachedNumber(method, key, f);
return f;
}
public long getServiceMethodParameter(String service, String method, String key, long defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.longValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
long l = Long.parseLong(value);
updateCachedNumber(method, key, l);
return l;
}
public int getServiceMethodParameter(String service, String method, String key, int defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.intValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
int i = Integer.parseInt(value);
updateCachedNumber(method, key, i);
return i;
}
public short getMethodParameter(String service, String method, String key, short defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.shortValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
short s = Short.parseShort(value);
updateCachedNumber(method, key, s);
return s;
}
public byte getServiceMethodParameter(String service, String method, String key, byte defaultValue) {
Number n = getCachedNumber(method, key);
if (n != null) {
return n.byteValue();
}
String value = getServiceMethodParameter(service, method, key);
if (StringUtils.isEmpty(value)) {
return defaultValue;
}
byte b = Byte.parseByte(value);
updateCachedNumber(method, key, b);
return b;
}
public boolean hasServiceMethodParameter(String service, String method, String key) {
return hasMethodParameter(method, key);
}
public boolean hasServiceMethodParameter(String service, String method) {
return hasMethodParameter(method);
}
protected Map<String, Number> getServiceNumbers(String service) {
return getNumbers();
}
protected Map<String, Map<String, Number>> getServiceMethodNumbers(String service) {
return getMethodNumbers();
}
public URL toSerializableURL() {
return returnURL(URLPlainParam.toURLPlainParam(urlParam));
}
}
相关信息
相关文章
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
8、 golang
-
9、 openharmony
-
10、 Vue中input框自动聚焦