Creating a Custom URL Connection – 创建自定义 URL 连接

最后修改: 2024年 2月 9日

中文/混合/英文(键盘快捷键：t)

1. Introduction

1.导言

In Java, the URLConnection class provides basic functionality for connecting to resources specified by a URL. However, in certain scenarios, developers may need a custom implementation to tailor the connection to specific requirements. In this tutorial, we’ll explore the process of creating a custom URL connection.

在 Java 中，URLConnection 类为连接到由 URL 指定的资源提供了基本功能。但是，在某些情况下，开发人员可能需要自定义实现，以便根据特定要求调整连接。在本教程中，我们将探讨创建自定义 URL 连接的过程。

2. Why Create a Custom URL Connection

2.为什么要创建自定义 URL 连接

Creating a custom URL connection becomes imperative due to various limitations associated with the default URLConnection class. In this section, we’ll discuss these limitations and outline scenarios where customization is necessary.

由于与默认 URLConnection 类相关的各种限制，创建自定义 URL 连接变得势在必行。在本节中，我们将讨论这些限制，并概述需要进行自定义的应用场景。

2.1. Addressing Protocol Limitations

2.1.寻址协议限制

The default URLConnection class provides a fundamental mechanism for connecting to resources via a URL. It was designed primarily for HTTP and HTTPS protocols. In cases where an application needs to interact with resources using custom protocols developed within an organization or for specific applications, a custom connection is imperative. For example, we might need to connect to a company’s internal network protocol or a custom database protocol.

默认的 URLConnection 类提供了通过 URL 连接资源的基本机制。它主要针对 HTTP 和 HTTPS 协议而设计。如果应用程序需要使用在组织内部开发的自定义协议或为特定应用程序开发的自定义协议与资源进行交互，则必须使用自定义连接。例如，我们可能需要连接到公司的内部网络协议或自定义数据库协议。

2.2. Limited Authentication Methods

2.2.有限身份验证方法

The default URL connection classes support common authentication methods, such as basic authentication and digest authentication, which are suitable for many web-based applications. However, in more complex scenarios, such as token-based authentication in modern applications, default URL connection classes might not seamlessly handle the intricacies of token-based authentication.

默认的 URL 连接类支持常见的身份验证方法，如基本身份验证和摘要身份验证，适合许多基于网络的应用程序。但是，在更复杂的情况下，如现代应用程序中基于令牌的身份验证，默认的 URL 连接类可能无法无缝处理基于令牌的身份验证的复杂性。

2.3. Handling Resource-Specific Requirements

2.3.处理特定资源需求

In some cases, the resources we interact with may have specific requirements. This could involve setting custom headers, adhering to unique authentication protocols, or managing specific encoding and decoding mechanisms. The default connection doesn’t provide the necessary control over the header configuration.

在某些情况下，与我们交互的资源可能有特定的要求。这可能涉及设置自定义标头、遵守独特的身份验证协议或管理特定的编码和解码机制。默认连接无法提供对标头配置的必要控制。

3. Use Case

3.使用案例

Let’s envision a scenario where our organization operates a legacy system utilizing a proprietary internal protocol for data exchange. Unlike the commonly used HTTP or HTTPS, the internal protocol was using myprotocol, and this is the sample URL:

让我们设想这样一个场景：我们的组织运行着一个利用专有内部协议进行数据交换的传统系统。与常用的 HTTP 或 HTTPS 不同，内部协议使用的是 myprotocol, 而这就是 URL 样本：

myprotocol://example.com/resource

This URL structure reflects the unique protocol myprotocol and points to a specific resource /resource hosted on the domain example.com. However, the challenge arises when our application, which uses the standard web protocols, needs to interact with this legacy system.

这种 URL 结构反映了独特的协议 myprotocol，并指向托管在域名 example.com 上的特定资源 /resource。然而，当我们使用标准网络协议的应用程序需要与这个遗留系统交互时，难题就出现了。

To overcome this incompatibility and establish communication between our application and the legacy system, we must implement a custom URL connection tailored to handle the proprietary protocol, myprotocol. This custom connection will act as a bridge, enabling seamless data exchange and integration between the two systems.

为了克服这种不兼容性并在我们的应用程序和原有系统之间建立通信，我们必须实现一个定制的 URL 连接，以处理专有协议 myprotocol。该自定义连接将充当桥梁，实现两个系统之间的无缝数据交换和集成。

4. Implementation

4.实施

In this section, we’ll delve into the code implementation of creating a custom URL connection.

在本节中，我们将深入探讨创建自定义 URL 连接的代码实现。

4.1. Create a CustomURLConnection

4.1.创建自定义URLConnection</em

To create a custom URL connection, we need to extend the java.net.URLConnection class and implement the necessary methods to tailor the connection to our specific requirements. This class will serve as the foundation of our custom connection:

要创建自定义 URL 连接，我们需要扩展 java.net.URLConnection 类并实现必要的方法，以便根据我们的特定需求定制连接。该类将作为我们自定义连接的基础：

public class CustomURLConnection extends URLConnection {
    private String simulatedData = "This is the simulated data from the resource.";
    private URL url;
    private boolean connected = false;
    private String headerValue = "SimulatedHeaderValue";
    // implementation details 
}

Next, let’s create a constructor for our class that takes a URL as a parameter. It calls the constructor of the superclass URLConnection with the provided URL:

接下来，让我们为我们的类创建一个构造函数，将 URL 作为参数。它使用提供的 URL 调用超类 URLConnection 的构造函数：

protected CustomURLConnection(URL url) {
    super(url);
    this.url = url;
}

Let’s implement the commonly used methods in our CustomURLConnection class. In the connect() method, we establish the physical connection to the resource. This might involve opening a network socket or performing any necessary setup:

让我们在 CustomURLConnection 类中实现常用方法。在 connect() 方法中，我们将建立与资源的物理连接。这可能涉及打开网络套接字或执行任何必要的设置：

@Override
public void connect() throws IOException {
    connected = true;
    System.out.println("Connection established to: " + url);
}

The getInputStream() method is called when input from the resource is required. In our implementation, we simulate the data by returning an input stream from a ByteArrayInputStream containing simulated data:

getInputStream() 方法在需要资源输入时被调用。在我们的实现中，我们通过从 ByteArrayInputStream 返回包含模拟数据的输入流来模拟数据：

@Override
public InputStream getInputStream() throws IOException {
    if (!connected) {
        connect();
    }
    return new ByteArrayInputStream(simulatedData.getBytes());
}

The getOutputStream() method is called when writing data to the resource. In our implementation, we return an output stream for writing to a ByteArrayOutputStream:

向资源写入数据时会调用 getOutputStream() 方法。在我们的实现中，我们返回一个输出流，用于写入 ByteArrayOutputStream 中：

@Override
public OutputStream getOutputStream() throws IOException {
    ByteArrayOutputStream simulatedOutput = new ByteArrayOutputStream();
    return simulatedOutput;
}

The getContentLength() method returns the content length of the resource. In our case, we return the length of the simulated data string:

getContentLength() 方法返回资源的内容长度。在本例中，我们返回的是模拟数据字符串的长度：

@Override
public int getContentLength() {
    return simulatedData.length();
}

The getHeaderField() method is used to retrieve the value of a specific header field from the response. In our implementation, we provide a simulated header value for the SimulatedHeader field:

getHeaderField() 方法用于从响应中获取特定标头字段的值。在我们的实现中，我们为 SimulatedHeader 字段提供了一个模拟头值：

@Override
public String getHeaderField(String name) {
    if ("SimulatedHeader".equalsIgnoreCase(name)) { 
        return headerValue;
    } else {
        return null; 
    } 
}

4.2. Create a URLStreamHandler

4.2.创建 URLStreamHandler

Next, we’ll create a class named CustomURLStreamHandler that extends URLStreamHandler. This class acts as a bridge between our custom URL and the actual connection process.

接下来，我们将创建一个扩展了 URLStreamHandler 的名为 CustomURLStreamHandler 的类。该类将充当自定义 URL 与实际连接过程之间的桥梁。

There are a few key methods we need to implement:

我们需要实施几个关键方法：

  • openConnection(): This method is responsible for creating and returning an instance of our custom URLConnection class. It acts as a factory for creating connections to the resource specified by the URL.
  • parseURL(): This method breaks down a given URL into its components such as protocol, host, and path. This is essential for the proper functioning of the URL.
  • setURL(): This method is used to set the URL for the stream handler. It is called during the process of constructing a URL object, and it sets the individual components of the URL.

Let’s create our CustomURLStreamHandler class:

让我们创建 CustomURLStreamHandler 类：

class CustomURLStreamHandler extends URLStreamHandler {
    @Override
    protected URLConnection openConnection(URL u) {
        return new CustomURLConnection(u);
    }

    @Override
    protected void parseURL(URL u, String spec, int start, int limit) {
        super.parseURL(u, spec, start, limit);
    }

    @Override
    protected void setURL(URL u, String protocol, String host, int port, String authority, 
      String userInfo, String path, String query, String ref) {
        super.setURL(u, protocol, host, port, authority, userInfo, path, query, ref);
    }
}

4.3. Register the URLStreamHandlerFactory

4.3.注册 URLStreamHandlerFactory

Next, we need to register a custom URLStreamHandlerFactory. This factory will be responsible for creating instances of our URLStreamHandler whenever Java encounters a URL with our custom protocol:

接下来，我们需要注册一个自定义的 URLStreamHandlerFactory. 该工厂将负责在 Java 遇到使用自定义协议的 URL 时创建 URLStreamHandler 的实例：

class CustomURLStreamHandlerFactory implements URLStreamHandlerFactory {
    @Override
    public URLStreamHandler createURLStreamHandler(String protocol) {
        if ("myprotocol".equals(protocol)) {
            return new CustomURLStreamHandler();
        }
        return null;
    }
}

5. Testing

5.测试

Now that we’ve implemented our custom URL connection, it’s crucial to run the program and validate its functionality.

既然我们已经实现了自定义 URL 连接，那么运行程序并验证其功能就至关重要了。

The first step is to register our custom URLStreamHandlerFactory by calling the setURLStreamHandlerFactory() method:

第一步是通过调用 setURLStreamHandlerFactory() 方法，注册我们的自定义 URLStreamHandlerFactory 方法：

URL.setURLStreamHandlerFactory(new CustomURLStreamHandlerFactory());

Now, let’s create a URL object using our custom protocol and open a connection to it:

现在，让我们使用自定义协议创建一个 URL 对象，并打开与它的连接：

URL url = new URL("myprotocol://example.com/resource");
CustomURLConnection customConnection = (CustomURLConnection) url.openConnection();

With the factory registered, Java will use our CustomURLStreamHandler whenever it encounters a URL with the myprotocol custom protocol. Before interacting with the resource, we need to explicitly establish the connection. Add the following line to invoke the connect() method:

注册工厂后，Java 将在遇到具有 myprotocol 自定义协议的 URL 时使用我们的 CustomURLStreamHandler 。在与资源交互之前，我们需要显式地建立连接。添加以下行以调用 connect() 方法：

customConnection.connect();

To verify that our custom connection can retrieve content from the resource, we’ll read the input stream. We’ll use a Scanner to convert the stream into a string:

为了验证自定义连接能否从资源中获取内容，我们将读取输入流。我们将使用 Scanner 将流转换为字符串：

InputStream inputStream = customConnection.getInputStream();
String content = new Scanner(inputStream).useDelimiter("\\A").next();
System.out.println(content);

Additionally, let’s check if our custom connection correctly reports the content length:

此外，让我们检查一下自定义连接是否能正确报告内容长度：

int contentLength = customConnection.getContentLength();
System.out.println("Content Length: " + contentLength);

Finally, let’s get the value of the custom header from the custom connection:

最后，让我们从自定义连接中获取自定义标头的值：

String headerValue = customConnection.getHeaderField("SimulatedHeader");
System.out.println("Header Value: " + headerValue);

Now, we can run the entire program and observe the output in the console:

现在，我们可以运行整个程序，并观察控制台中的输出：

Connection established to: myprotocol://example.com/resource
This is the simulated data from the resource.
Content Length: 45
Header Value: SimulatedHeaderValue

6. Conclusion

6.结论

In this article, we explored the process of creating a custom URL connection in Java to overcome the limitations associated with the default URLConnection class. We identified scenarios where customization becomes crucial, such as addressing protocol limitations, accommodating varied authentication methods, and handling resource-specific requirements.

在本文中，我们探讨了在 Java 中创建自定义 URL 连接的过程，以克服与默认 URLConnection 类相关的限制。我们确定了自定义变得至关重要的应用场景，例如解决协议限制、适应各种身份验证方法以及处理特定资源需求。

As always, the source code for the examples is available over on GitHub.

与往常一样，这些示例的源代码可在 GitHub 上获取。