Examples with ForestURL com.dtflys.forest.http.ForestURL used on opensource projects

Example 1 with ForestURL

use of com.dtflys.forest.http.ForestURL in project forest by dromara.

the class ForestMethod method makeRequest.

/**
 * 创建请求
 * @param args 调用本对象对应方法时传入的参数数组
 * @return Forest请求对象，{@link ForestRequest}类实例
 */
private ForestRequest makeRequest(Object[] args) {
    MetaRequest baseMetaRequest = interfaceProxyHandler.getBaseMetaRequest();
    ForestURL baseURL = null;
    ForestQueryMap queries = new ForestQueryMap();
    if (baseUrlTemplate != null) {
        baseURL = baseUrlTemplate.render(args, queries);
    }
    if (urlTemplate == null) {
        throw new ForestRuntimeException("request URL is empty");
    }
    ForestURL renderedURL = urlTemplate.render(args, queries);
    ForestRequestType type = type(args);
    String baseContentEncoding = null;
    if (baseEncodeTemplate != null) {
        baseContentEncoding = baseEncodeTemplate.render(args);
    }
    String contentEncoding = null;
    if (encodeTemplate != null) {
        contentEncoding = encodeTemplate.render(args);
    }
    String baseContentType = null;
    if (baseContentTypeTemplate != null) {
        baseContentType = baseContentTypeTemplate.render(args);
    }
    String baseUserAgent = null;
    if (baseUserAgentTemplate != null) {
        baseUserAgent = baseUserAgentTemplate.render(args);
    }
    String charset = null;
    String renderedCharset = charsetTemplate.render(args);
    if (StringUtils.isNotBlank(renderedCharset)) {
        charset = renderedCharset;
    } else if (baseCharsetTemplate != null) {
        charset = baseCharsetTemplate.render(args);
    } else if (StringUtils.isNotBlank(configuration.getCharset())) {
        charset = configuration.getCharset();
    }
    String responseEncoding = null;
    if (responseEncodingTemplate != null) {
        responseEncoding = responseEncodingTemplate.render(args);
    }
    String sslProtocol = null;
    String renderedSslProtocol = sslProtocolTemplate.render(args);
    if (StringUtils.isNotBlank(renderedSslProtocol)) {
        sslProtocol = renderedSslProtocol;
    } else if (baseSslProtocolTemplate != null) {
        sslProtocol = baseSslProtocolTemplate.render(args);
    } else {
        sslProtocol = configuration.getSslProtocol();
    }
    String renderedContentType = null;
    if (contentTypeTemplate != null) {
        renderedContentType = contentTypeTemplate.render(args).trim();
    }
    String renderedUserAgent = null;
    if (userAgentTemplate != null) {
        renderedUserAgent = userAgentTemplate.render(args).trim();
    }
    List<RequestNameValue> nameValueList = new ArrayList<>();
    String[] headerArray = baseMetaRequest.getHeaders();
    MappingTemplate[] baseHeaders = null;
    if (headerArray != null && headerArray.length > 0) {
        baseHeaders = new MappingTemplate[headerArray.length];
        for (int j = 0; j < baseHeaders.length; j++) {
            MappingTemplate header = new MappingTemplate(BaseRequest.class, "headers", this, headerArray[j], this, configuration.getProperties(), forestParameters);
            baseHeaders[j] = header;
        }
    }
    AddressSource addressSource = configuration.getBaseAddressSource();
    ForestAddress address = configuration.getBaseAddress();
    if (address == null) {
        // 默认根地址
        address = DEFAULT_ADDRESS;
    }
    ForestURL addressURL = null;
    if (baseURL != null) {
        renderedURL.setBaseURL(baseURL);
    }
    try {
        addressURL = new ForestURL(new URL("http://localhost"));
        addressURL.setBaseAddress(address);
        renderedURL = renderedURL.mergeURLWith(addressURL);
    } catch (MalformedURLException e) {
        throw new ForestRuntimeException(e);
    }
    boolean autoRedirection = configuration.isAutoRedirection();
    String bodyTypeName = "text";
    if (bodyTypeTemplate != null) {
        bodyTypeName = bodyTypeTemplate.render(args);
    }
    ForestDataType bodyType = ForestDataType.findByName(bodyTypeName);
    // createExecutor and initialize http instance
    ForestRequest<T> request = new ForestRequest(configuration, this, args);
    request.url(renderedURL).type(type).bodyType(bodyType).addAllQuery(queries).charset(charset).autoRedirects(autoRedirection).setSslProtocol(sslProtocol).setLogConfiguration(logConfiguration).setAsync(async);
    if (addressSource != null) {
        address = addressSource.getAddress(request);
        request.address(address);
    }
    if (StringUtils.isNotEmpty(responseEncoding)) {
        request.setResponseEncode(responseEncoding);
    }
    if (StringUtils.isNotEmpty(renderedContentType)) {
        request.setContentType(renderedContentType);
    }
    if (StringUtils.isNotEmpty(contentEncoding)) {
        request.setContentEncoding(contentEncoding);
    }
    if (StringUtils.isNotEmpty(renderedUserAgent)) {
        request.setUserAgent(renderedUserAgent);
    }
    for (int i = 0; i < namedParameters.size(); i++) {
        MappingParameter parameter = namedParameters.get(i);
        if (parameter.isObjectProperties()) {
            int target = parameter.isUnknownTarget() ? type.getDefaultParamTarget() : parameter.getTarget();
            Object obj = args[parameter.getIndex()];
            if (obj == null && StringUtils.isNotEmpty(parameter.getDefaultValue())) {
                obj = parameter.getConvertedDefaultValue(configuration.getJsonConverter());
            }
            if (parameter.isJsonParam()) {
                String json = "";
                if (obj != null) {
                    ForestJsonConverter jsonConverter = configuration.getJsonConverter();
                    obj = parameter.getFilterChain().doFilter(configuration, obj);
                    json = jsonConverter.encodeToString(obj);
                }
                if (MappingParameter.isHeader(target)) {
                    request.addHeader(new RequestNameValue(parameter.getJsonParamName(), json, target).setDefaultValue(parameter.getDefaultValue()));
                } else {
                    nameValueList.add(new RequestNameValue(parameter.getJsonParamName(), json, target, parameter.getPartContentType()).setDefaultValue(parameter.getDefaultValue()));
                }
            } else if (!parameter.getFilterChain().isEmpty()) {
                obj = parameter.getFilterChain().doFilter(configuration, obj);
                if (obj == null && StringUtils.isNotEmpty(parameter.getDefaultValue())) {
                    obj = parameter.getDefaultValue();
                }
                if (obj != null) {
                    if (MappingParameter.isHeader(target)) {
                        request.addHeader(new RequestNameValue(null, obj, target));
                    } else if (MappingParameter.isQuery(target)) {
                        request.addQuery(obj.toString(), (Object) null, parameter.isUrlEncode(), parameter.getCharset());
                    } else if (MappingParameter.isBody(target)) {
                        ForestRequestBody body = RequestBodyBuilder.type(obj.getClass()).build(obj, parameter.getDefaultValue());
                        request.addBody(body);
                    } else {
                        nameValueList.add(new RequestNameValue(obj.toString(), target, parameter.getPartContentType()).setDefaultValue(parameter.getDefaultValue()));
                    }
                }
            } else if (obj instanceof CharSequence) {
                if (MappingParameter.isQuery(target)) {
                    request.addQuery(ForestQueryParameter.createSimpleQueryParameter(obj).setDefaultValue(parameter.getDefaultValue()));
                } else if (MappingParameter.isBody(target)) {
                    request.addBody(new StringRequestBody(obj.toString()).setDefaultValue(parameter.getDefaultValue()));
                }
            } else if (obj instanceof Map) {
                Map map = (Map) obj;
                if (MappingParameter.isQuery(target)) {
                    request.addQuery(map, parameter.isUrlEncode(), parameter.getCharset());
                } else if (MappingParameter.isBody(target)) {
                    request.addBody(map, parameter.getPartContentType());
                } else if (MappingParameter.isHeader(target)) {
                    request.addHeader(map);
                }
            } else if (obj instanceof Iterable || (obj != null && (obj.getClass().isArray() || ReflectUtils.isPrimaryType(obj.getClass())))) {
                if (MappingParameter.isQuery(target)) {
                    if (parameter.isJsonParam()) {
                        request.addQuery(parameter.getName(), obj, parameter.isUrlEncode(), parameter.getCharset());
                    } else {
                        if (obj instanceof Iterable) {
                            for (Object subItem : (Iterable) obj) {
                                if (subItem instanceof ForestQueryParameter) {
                                    request.addQuery((ForestQueryParameter) subItem);
                                } else {
                                    request.addQuery(ForestQueryParameter.createSimpleQueryParameter(subItem));
                                }
                            }
                        } else if (obj.getClass().isArray()) {
                            if (obj instanceof ForestQueryParameter[]) {
                                request.addQuery((ForestQueryParameter[]) obj);
                            }
                        }
                    }
                } else if (MappingParameter.isBody(target)) {
                    ForestRequestBody body = RequestBodyBuilder.type(obj.getClass()).build(obj, parameter.getDefaultValue());
                    request.addBody(body);
                }
            } else if (MappingParameter.isBody(target)) {
                ForestRequestBody body = RequestBodyBuilder.type(obj.getClass()).build(obj, parameter.getDefaultValue());
                request.addBody(body);
            } else {
                try {
                    List<RequestNameValue> list = getNameValueListFromObjectWithJSON(parameter, configuration, obj, type);
                    for (RequestNameValue nameValue : list) {
                        if (nameValue.isInHeader()) {
                            request.addHeader(nameValue);
                        } else {
                            nameValueList.add(nameValue);
                        }
                    }
                } catch (Throwable th) {
                    throw new ForestRuntimeException(th);
                }
            }
        } else if (parameter.getIndex() != null) {
            int target = parameter.isUnknownTarget() ? type.getDefaultParamTarget() : parameter.getTarget();
            RequestNameValue nameValue = new RequestNameValue(parameter.getName(), target, parameter.getPartContentType()).setDefaultValue(parameter.getDefaultValue());
            Object obj = args[parameter.getIndex()];
            if (obj == null && StringUtils.isNotEmpty(nameValue.getDefaultValue())) {
                obj = parameter.getConvertedDefaultValue(configuration.getJsonConverter());
            }
            if (obj != null) {
                if (MappingParameter.isQuery(target) && obj.getClass().isArray() && !(obj instanceof byte[]) && !(obj instanceof Byte[])) {
                    int len = Array.getLength(obj);
                    for (int idx = 0; idx < len; idx++) {
                        Object arrayItem = Array.get(obj, idx);
                        ForestQueryParameter queryParameter = new ForestQueryParameter(parameter.getName(), arrayItem, parameter.isUrlEncode(), parameter.getCharset());
                        request.addQuery(queryParameter);
                    }
                } else {
                    nameValue.setValue(obj);
                    if (MappingParameter.isHeader(target)) {
                        request.addHeader(nameValue);
                    } else if (MappingParameter.isQuery(target)) {
                        if (!parameter.isJsonParam() && obj instanceof Iterable) {
                            int index = 0;
                            MappingTemplate template = makeTemplate(parameter);
                            VariableScope parentScope = template.getVariableScope();
                            for (Object subItem : (Iterable) obj) {
                                SubVariableScope scope = new SubVariableScope(parentScope);
                                scope.addVariableValue("_it", subItem);
                                scope.addVariableValue("_index", index++);
                                template.setVariableScope(scope);
                                String name = template.render(args);
                                request.addQuery(name, subItem, parameter.isUrlEncode(), parameter.getCharset());
                            }
                        } else if (parameter.isJsonParam()) {
                            request.addJSONQuery(parameter.getName(), obj);
                        } else {
                            request.addQuery(parameter.getName(), obj, parameter.isUrlEncode(), parameter.getCharset());
                        }
                    } else {
                        MappingTemplate template = makeTemplate(parameter);
                        if (obj instanceof Iterable && template.hasIterateVariable()) {
                            int index = 0;
                            VariableScope parentScope = template.getVariableScope();
                            for (Object subItem : (Iterable) obj) {
                                SubVariableScope scope = new SubVariableScope(parentScope);
                                template.setVariableScope(scope);
                                scope.addVariableValue("_it", subItem);
                                scope.addVariableValue("_index", index++);
                                String name = template.render(args);
                                nameValueList.add(new RequestNameValue(name, subItem, target, parameter.getPartContentType()).setDefaultValue(parameter.getDefaultValue()));
                            }
                        } else {
                            nameValueList.add(nameValue);
                        }
                    }
                }
            }
        }
    }
    if (request.getContentType() == null) {
        if (StringUtils.isNotEmpty(baseContentType)) {
            request.setContentType(baseContentType);
        }
    }
    if (request.getContentEncoding() == null) {
        if (StringUtils.isNotEmpty(baseContentEncoding)) {
            request.setContentEncoding(baseContentEncoding);
        }
    }
    if (request.getUserAgent() == null) {
        if (StringUtils.isNotEmpty(baseUserAgent)) {
            request.setUserAgent(baseUserAgent);
        }
    }
    List<ForestMultipart> multiparts = new ArrayList<>(multipartFactories.size());
    String contentType = request.getContentType();
    if (!multipartFactories.isEmpty()) {
        if (StringUtils.isBlank(contentType)) {
            String boundary = StringUtils.generateBoundary();
            request.setContentType(ContentType.MULTIPART_FORM_DATA + "; boundary=" + boundary);
        } else if (ContentType.MULTIPART_FORM_DATA.equalsIgnoreCase(contentType) && request.getBoundary() == null) {
            request.setBoundary(StringUtils.generateBoundary());
        }
    }
    for (int i = 0; i < multipartFactories.size(); i++) {
        ForestMultipartFactory factory = multipartFactories.get(i);
        MappingTemplate nameTemplate = factory.getNameTemplate();
        MappingTemplate fileNameTemplate = factory.getFileNameTemplate();
        int index = factory.getIndex();
        Object data = args[index];
        factory.addMultipart(nameTemplate, fileNameTemplate, data, multiparts, args);
    }
    request.setMultiparts(multiparts);
    // setup ssl keystore
    if (sslKeyStoreId != null) {
        SSLKeyStore sslKeyStore = null;
        String keyStoreId = sslKeyStoreId.render(args);
        if (StringUtils.isNotEmpty(keyStoreId)) {
            sslKeyStore = configuration.getKeyStore(keyStoreId);
            request.setKeyStore(sslKeyStore);
        }
    }
    if (encoder != null) {
        request.setEncoder(encoder);
    }
    if (decoder != null) {
        request.setDecoder(decoder);
    }
    if (progressStep >= 0) {
        request.setProgressStep(progressStep);
    }
    if (configuration.getDefaultParameters() != null) {
        request.addNameValue(configuration.getDefaultParameters());
    }
    if (baseHeaders != null && baseHeaders.length > 0) {
        for (MappingTemplate baseHeader : baseHeaders) {
            String headerText = baseHeader.render(args);
            String[] headerNameValue = headerText.split(":", 2);
            if (headerNameValue.length > 1) {
                String name = headerNameValue[0].trim();
                if (request.getHeader(name) == null) {
                    request.addHeader(name, headerNameValue[1].trim());
                }
            }
        }
    }
    if (configuration.getDefaultHeaders() != null) {
        request.addHeaders(configuration.getDefaultHeaders());
    }
    List<RequestNameValue> dataNameValueList = new ArrayList<>();
    renderedContentType = request.getContentType();
    if (renderedContentType == null || renderedContentType.equalsIgnoreCase(ContentType.APPLICATION_X_WWW_FORM_URLENCODED)) {
        for (int i = 0; i < dataTemplateArray.length; i++) {
            MappingTemplate dataTemplate = dataTemplateArray[i];
            String data = dataTemplate.render(args);
            String[] paramArray = data.split("&");
            for (int j = 0; j < paramArray.length; j++) {
                String dataParam = paramArray[j];
                String[] dataNameValue = dataParam.split("=", 2);
                if (dataNameValue.length > 0) {
                    String name = dataNameValue[0].trim();
                    RequestNameValue nameValue = new RequestNameValue(name, type.getDefaultParamTarget());
                    if (dataNameValue.length == 2) {
                        nameValue.setValue(dataNameValue[1].trim());
                    }
                    nameValueList.add(nameValue);
                    dataNameValueList.add(nameValue);
                }
            }
        }
    } else {
        for (int i = 0; i < dataTemplateArray.length; i++) {
            MappingTemplate dataTemplate = dataTemplateArray[i];
            String data = dataTemplate.render(args);
            request.addBody(data);
        }
    }
    request.addNameValue(nameValueList);
    for (int i = 0; i < headerTemplateArray.length; i++) {
        MappingTemplate headerTemplate = headerTemplateArray[i];
        String header = headerTemplate.render(args);
        String[] headNameValue = header.split(":", 2);
        if (headNameValue.length > 0) {
            String name = headNameValue[0].trim();
            RequestNameValue nameValue = new RequestNameValue(name, TARGET_HEADER);
            if (headNameValue.length == 2) {
                nameValue.setValue(headNameValue[1].trim());
            }
            request.addHeader(nameValue);
        }
    }
    if (timeout != null) {
        request.setTimeout(timeout);
    } else if (baseTimeout != null) {
        request.setTimeout(baseTimeout);
    } else if (configuration.getTimeout() != null) {
        request.setTimeout(configuration.getTimeout());
    }
    if (connectTimeout != null) {
        request.setConnectTimeout(connectTimeout);
    } else if (baseConnectTimeout != null) {
        request.setConnectTimeout(baseConnectTimeout);
    } else if (configuration.getConnectTimeout() != null) {
        request.setConnectTimeout(configuration.getConnectTimeout());
    }
    if (readTimeout != null) {
        request.setReadTimeout(readTimeout);
    } else if (baseReadTimeout != null) {
        request.setReadTimeout(baseReadTimeout);
    } else if (configuration.getReadTimeout() != null) {
        request.setReadTimeout(configuration.getReadTimeout());
    }
    if (retryCount != null) {
        request.setMaxRetryCount(retryCount);
    } else if (baseRetryCount != null) {
        request.setMaxRetryCount(baseRetryCount);
    } else if (configuration.getMaxRetryCount() != null) {
        request.setMaxRetryCount(configuration.getMaxRetryCount());
    }
    if (maxRetryInterval >= 0) {
        request.setMaxRetryInterval(maxRetryInterval);
    } else if (baseMaxRetryInterval != null) {
        request.setMaxRetryInterval(baseMaxRetryInterval);
    } else if (configuration.getMaxRetryInterval() >= 0) {
        request.setMaxRetryInterval(configuration.getMaxRetryInterval());
    }
    Class globalRetryerClass = configuration.getRetryer();
    if (retryerClass != null && ForestRetryer.class.isAssignableFrom(retryerClass)) {
        request.setRetryer(retryerClass);
    } else if (baseRetryerClass != null && ForestRetryer.class.isAssignableFrom(baseRetryerClass)) {
        request.setRetryer(baseRetryerClass);
    } else if (globalRetryerClass != null && ForestRetryer.class.isAssignableFrom(globalRetryerClass)) {
        request.setRetryer(globalRetryerClass);
    }
    if (onSuccessParameter != null) {
        OnSuccess<?> onSuccessCallback = (OnSuccess<?>) args[onSuccessParameter.getIndex()];
        request.setOnSuccess(onSuccessCallback);
    }
    if (onErrorParameter != null) {
        OnError onErrorCallback = (OnError) args[onErrorParameter.getIndex()];
        request.setOnError(onErrorCallback);
    }
    if (onRedirectionParameter != null) {
        OnRedirection onRedirectionCallback = (OnRedirection) args[onRedirectionParameter.getIndex()];
        request.setOnRedirection(onRedirectionCallback);
    }
    if (onProgressParameter != null) {
        OnProgress onProgressCallback = (OnProgress) args[onProgressParameter.getIndex()];
        request.setOnProgress(onProgressCallback);
    }
    if (onSaveCookieParameter != null) {
        OnSaveCookie onSaveCookieCallback = (OnSaveCookie) args[onSaveCookieParameter.getIndex()];
        request.setOnSaveCookie(onSaveCookieCallback);
    }
    if (onLoadCookieParameter != null) {
        OnLoadCookie onLoadCookieCallback = (OnLoadCookie) args[onLoadCookieParameter.getIndex()];
        request.setOnLoadCookie(onLoadCookieCallback);
    }
    String dataType = dataTypeTemplate.render(args);
    if (StringUtils.isEmpty(dataType)) {
        request.setDataType(ForestDataType.TEXT);
    } else {
        dataType = dataType.toUpperCase();
        ForestDataType forestDataType = ForestDataType.findByName(dataType);
        request.setDataType(forestDataType);
    }
    if (interceptorAttributesList != null && interceptorAttributesList.size() > 0) {
        for (InterceptorAttributes attributes : interceptorAttributesList) {
            InterceptorAttributes newAttrs = attributes.clone();
            request.addInterceptorAttributes(newAttrs.getInterceptorClass(), newAttrs);
            request.getInterceptorAttributes(newAttrs.getInterceptorClass()).render(args);
        }
    }
    if (globalInterceptorList != null && globalInterceptorList.size() > 0) {
        for (Interceptor item : globalInterceptorList) {
            request.addInterceptor(item);
        }
    }
    if (baseInterceptorList != null && baseInterceptorList.size() > 0) {
        for (Interceptor item : baseInterceptorList) {
            request.addInterceptor(item);
        }
    }
    if (interceptorList != null && interceptorList.size() > 0) {
        for (Interceptor item : interceptorList) {
            request.addInterceptor(item);
        }
    }
    return request;
}

Example 2 with ForestURL

use of com.dtflys.forest.http.ForestURL in project forest by dromara.

the class MappingURLTemplate method render.

public ForestURL render(Object[] args, ForestQueryMap queries) {
    String schema = null;
    String userInfo = null;
    String host = null;
    Integer port = null;
    String path = null;
    StringBuilder urlBuilder = new StringBuilder();
    boolean renderedQuery = false;
    boolean nextIsPort = false;
    boolean renderedPath = false;
    try {
        ForestJsonConverter jsonConverter = variableScope.getConfiguration().getJsonConverter();
        int len = exprList.size();
        StringBuilder builder = new StringBuilder();
        ForestQueryParameter lastQuery = null;
        for (int i = 0; i < len; i++) {
            MappingExpr expr = exprList.get(i);
            String exprVal = renderExpression(jsonConverter, expr, args);
            if (exprVal != null) {
                builder.append(exprVal);
            }
            if (renderedQuery) {
                // 已渲染到查询参数
                if (lastQuery != null && (expr instanceof MappingUrlEncodedExpr)) {
                    // 在查询参数的位置进行变量引用
                    Object lastQueryValue = lastQuery.getValue();
                    String queryVal = lastQueryValue == null ? exprVal : lastQueryValue + exprVal;
                    lastQuery.setValue(queryVal);
                } else {
                    // 非变量引用
                    String[] subQueries = exprVal.split("&");
                    int subQueryLen = subQueries.length;
                    int k = 1;
                    if (exprVal.charAt(0) != '&') {
                        // 非连接符 & 开头
                        String lastQueryPartVal = subQueries[0];
                        if (lastQuery != null) {
                            // 可能要接着上一个查询参数
                            Object lastQueryValue = lastQuery.getValue();
                            String queryVal = lastQueryValue == null ? lastQueryPartVal : lastQueryValue + lastQueryPartVal;
                            lastQuery.setValue(queryVal);
                        } else {
                            // 可能是第一个查询参数
                            String[] keyValue = lastQueryPartVal.split("=", 2);
                            if (keyValue.length == 1) {
                                lastQuery = new ForestQueryParameter(lastQueryPartVal);
                            } else {
                                lastQuery = new ForestQueryParameter(keyValue[0], keyValue[1]);
                            }
                            queries.addQuery(lastQuery);
                        }
                    }
                    // 解析查询参数
                    for (; k < subQueryLen; k++) {
                        String queryItem = subQueries[k];
                        String[] keyValue = queryItem.split("=", 2);
                        if (keyValue.length == 1) {
                            lastQuery = new ForestQueryParameter(queryItem);
                        } else {
                            lastQuery = new ForestQueryParameter(keyValue[0]);
                            String queryVal = keyValue[1];
                            if (StringUtils.isNotBlank(queryVal)) {
                                lastQuery.setValue(queryVal);
                            }
                        }
                        queries.addQuery(lastQuery);
                    }
                }
            } else {
                // 查询参数前面部分
                int queryIndex = exprVal.indexOf('?');
                renderedQuery = queryIndex >= 0;
                String baseUrl = exprVal;
                if (renderedQuery) {
                    baseUrl = exprVal.substring(0, queryIndex);
                    urlBuilder.append(baseUrl);
                } else {
                    urlBuilder.append(baseUrl);
                }
                char[] baseUrlChars = baseUrl.toCharArray();
                int baseLen = baseUrlChars.length;
                char ch;
                StringBuilder subBuilder = new StringBuilder();
                for (int pathCharIndex = 0; pathCharIndex < baseLen; pathCharIndex++) {
                    ch = baseUrlChars[pathCharIndex];
                    if (ch == ':') {
                        if (schema == null && pathCharIndex + 1 < baseLen && baseUrlChars[pathCharIndex + 1] == '/') {
                            // 解析协议部分
                            schema = subBuilder.toString();
                            subBuilder = new StringBuilder();
                            pathCharIndex++;
                            ch = baseUrlChars[pathCharIndex];
                            if (ch != '/') {
                                throw new ForestRuntimeException("URI '" + super.render(args) + "' is invalid.");
                            }
                            pathCharIndex++;
                            if (pathCharIndex + 1 < baseLen && baseUrlChars[pathCharIndex + 1] == '/') {
                                do {
                                    pathCharIndex++;
                                } while (pathCharIndex + 1 < baseLen && baseUrlChars[pathCharIndex + 1] == '/');
                            }
                            continue;
                        }
                        if (schema != null && host == null) {
                            // 解析地址部分
                            boolean hasNext = pathCharIndex + 1 < baseLen;
                            if (!hasNext || (hasNext && Character.isDigit(baseUrlChars[pathCharIndex + 1]))) {
                                host = subBuilder.toString();
                                subBuilder = new StringBuilder();
                                nextIsPort = true;
                                continue;
                            } else if (hasNext && !Character.isDigit(baseUrlChars[pathCharIndex + 1])) {
                                if (userInfo == null) {
                                    userInfo = subBuilder.toString() + ':';
                                } else {
                                    userInfo += subBuilder.toString() + ':';
                                }
                                subBuilder = new StringBuilder();
                                continue;
                            }
                        } else if (host != null && port == null && !renderedPath) {
                            nextIsPort = true;
                        } else {
                            subBuilder.append(ch);
                        }
                    } else if (ch == '@') {
                        // 解析用户名密码
                        if (userInfo == null) {
                            if (host != null) {
                                StringBuilder userInfoBuilder = new StringBuilder(host);
                                if (StringUtils.isNotEmpty(path)) {
                                    userInfoBuilder.append(path);
                                    path = "";
                                }
                                if (subBuilder.length() > 0) {
                                    if (!renderedPath) {
                                        userInfoBuilder.append(':');
                                    }
                                    userInfoBuilder.append(subBuilder);
                                    subBuilder = new StringBuilder();
                                }
                                userInfo = userInfoBuilder.toString();
                                host = null;
                            } else {
                                userInfo = "";
                            }
                            if (port != null) {
                                userInfo += port;
                                port = null;
                            }
                        } else {
                            userInfo += subBuilder.toString();
                            subBuilder = new StringBuilder();
                        }
                        renderedPath = false;
                        continue;
                    } else if (ch == '/' || pathCharIndex + 1 == baseLen) {
                        if (ch != '/') {
                            subBuilder.append(ch);
                        }
                        if (!renderedPath && nextIsPort && port == null) {
                            // 解析端口号
                            port = Integer.parseInt(subBuilder.toString());
                            subBuilder = new StringBuilder();
                            nextIsPort = false;
                            if (ch == '/') {
                                pathCharIndex--;
                                renderedPath = true;
                            }
                            continue;
                        } else if (schema != null && host == null) {
                            // 解析地址部分
                            host = subBuilder.toString();
                            subBuilder = new StringBuilder();
                            if (ch == '/') {
                                pathCharIndex--;
                                renderedPath = true;
                            }
                            continue;
                        } else {
                            if (ch == '/') {
                                subBuilder.append(ch);
                                renderedPath = true;
                            }
                            if (pathCharIndex + 1 == baseLen) {
                                if (path == null) {
                                    path = subBuilder.toString();
                                } else {
                                    path += subBuilder.toString();
                                }
                            }
                        }
                    } else {
                        subBuilder.append(ch);
                    }
                }
                if (renderedQuery) {
                    if (queryIndex + 1 < exprVal.length()) {
                        String queryStr = exprVal.substring(queryIndex + 1);
                        String[] queryItems = queryStr.split("&");
                        if (queryItems.length > 0) {
                            for (String queryItem : queryItems) {
                                String[] keyValue = queryItem.split("=", 2);
                                lastQuery = new ForestQueryParameter(keyValue[0]);
                                queries.addQuery(lastQuery);
                                if (keyValue.length > 1 && StringUtils.isNotBlank(keyValue[1])) {
                                    lastQuery.setValue(keyValue[1]);
                                }
                            }
                        }
                    }
                }
            }
        }
        return new ForestURL(schema, userInfo, host, port, path);
    } catch (ForestVariableUndefinedException ex) {
        throw new ForestVariableUndefinedException(annotationType, attributeName, forestMethod, ex.getVariableName(), template);
    }
}

Example 3 with ForestURL

use of com.dtflys.forest.http.ForestURL in project forest by dromara.

the class TestGenericForestClient method testRequest_url.

@Test
public void testRequest_url() throws MalformedURLException {
    ForestRequest<?> request = Forest.request();
    assertThat(request).isNotNull();
    assertThat(request.scheme()).isEqualTo("http");
    assertThat(request.host()).isEqualTo("localhost");
    assertThat(request.path()).isEqualTo("/");
    request.url("http://127.0.0.1:8080/test");
    assertThat(request.urlString()).isEqualTo("http://127.0.0.1:8080/test");
    request.url("/abc");
    assertThat(request.urlString()).isEqualTo("http://127.0.0.1:8080/abc");
    request.url("http://forest.dtflyx.com/111");
    assertThat(request.urlString()).isEqualTo("http://forest.dtflyx.com/111");
    request.path("/222");
    assertThat(request.urlString()).isEqualTo("http://forest.dtflyx.com/222");
    request.url(new ForestURL(new URL("http://localhost:8080/333")));
    assertThat(request.urlString()).isEqualTo("http://localhost:8080/333");
    request.address(new ForestAddress("192.168.0.1", 8881));
    assertThat(request.urlString()).isEqualTo("http://192.168.0.1:8881/333");
    request.address("192.168.0.2", 8882);
    assertThat(request.urlString()).isEqualTo("http://192.168.0.2:8882/333");
}

Example 4 with ForestURL

use of com.dtflys.forest.http.ForestURL in project forest by dromara.

the class URLTest method testForestURL.

@Test
public void testForestURL() throws MalformedURLException {
    ForestURL url = new ForestURL(new URL("http://localhost:8080/xxx/yyy"));
    assertThat(url.getScheme()).isEqualTo("http");
    assertThat(url.isSSL()).isFalse();
    assertThat(url.getHost()).isEqualTo("localhost");
    assertThat(url.getPort()).isEqualTo(8080);
    assertThat(url.getAuthority()).isEqualTo("localhost:8080");
    assertThat(url.getPath()).isEqualTo("/xxx/yyy");
    assertThat(url.toString()).isEqualTo("http://localhost:8080/xxx/yyy");
    assertThat(url.setScheme("https").getScheme()).isEqualTo("https");
    assertThat(url.isSSL()).isTrue();
    assertThat(url.setHost("127.0.0.1").getHost()).isEqualTo("127.0.0.1");
    assertThat(url.setPort(8888).getPort()).isEqualTo(8888);
    assertThat(url.setUserInfo("username:pwd").getUserInfo()).isEqualTo("username:pwd");
    assertThat(url.setPath("zzz").getPath()).isEqualTo("/zzz");
    assertThat(url.toString()).isEqualTo("https://username:pwd@127.0.0.1:8888/zzz");
}