Design Patterns Serie — Structural Chapter: Proxy Pattern

Design patterns: efficient solutions for common software development challenges. These pre-built solutions prevent "reinventing the wheel," offering answers to frequently recurring problems. However, they aren't one-size-fits-all; developers must adapt patterns to specific project needs.

Design patterns are categorized into three groups: Creational, Structural, and Behavioral, each with distinct characteristics. This article focuses on a popular structural pattern: the Proxy Pattern.

Understanding the Proxy Pattern

To grasp the Proxy pattern, consider this scenario: accessing user data requires first obtaining a JWT (JSON Web Token) via a separate service.

The Problem

Without the Proxy pattern, each user data request necessitates a JWT request, leading to performance bottlenecks, especially if the JWT service is slow or the token's expiration time isn't managed efficiently. This inefficient approach is illustrated below:

This repeated JWT fetching slows down data retrieval.

The solution lies in the Proxy pattern.

The Solution

The Proxy pattern introduces an intermediary layer—the Proxy—between the client and the real object (the JWT service). This intermediary manages access, adding functionality like caching or security checks.

This improves efficiency by caching the JWT, reducing calls to the JWT service. The improved architecture using the proxy pattern looks like this:

A class diagram illustrates the implementation:

The class diagram shows:

• Subject (JWTService): A common interface implemented by both the Proxy and the real JWT service. It defines the requestJWT() method.
• Real Subject (JWTServiceImpl): Implements JWTService and provides the actual JWT generation functionality.
• Proxy (JWTServiceProxy): Controls access to JWTServiceImpl. It adds caching and validation logic.

Implementing the Proxy Pattern for JWT Generation

A complete code example is available at Proxy Pattern Repo. Below are key components:

The JWT Object

A JWT class (using Java 16 records) stores JWT data (token, expiration time, creation time) and includes a validateJWT() method for checking validity.

<code class="language-java">public record JWT(String token, long expirationTime, long creationTime) {
    public boolean validateJWT(){
        long currentTimeInSeconds = System.currentTimeMillis() / 1000;
        return currentTimeInSeconds < creationTime + expirationTime;
    }
}</code>

The Subject (Interface)

The JWTService interface declares the requestJWT() method.

<code class="language-java">public interface JWTService {
    JWT requestJWT();
}</code>

The Real Subject

JWTServiceImpl implements JWTService, generating a mock JWT.

<code class="language-java">public class JWTServiceImpl implements JWTService {
    @Override
    public JWT requestJWT() {
        return new JWT(generateToken(), 5, System.currentTimeMillis() / 1000);
    }

    // ... generateToken() method (simplified for this example) ...
}</code>

The Proxy

JWTServiceProxy caches and validates the JWT.

<code class="language-java">public class JWTServiceProxy implements JWTService {
    private final JWTService jwtService;
    private JWT jwt;

    public JWTServiceProxy() {
        this.jwtService = new JWTServiceImpl();
    }

    @Override
    public JWT requestJWT() {
        if (jwt == null || !jwt.validateJWT()) {
            jwt = jwtService.requestJWT();
        }
        return jwt;
    }
}</code>

Testing the Proxy Pattern

A simple test demonstrates the Proxy's caching behavior:

<code class="language-java">// ... (Main class with logging and Thread.sleep(5000) to simulate token expiration) ...</code>

The output shows that only one JWT is generated initially, and a new one is generated only after the first one expires, demonstrating the proxy's caching and validation functionality.

Conclusion

The Proxy pattern enhances software efficiency and security. By carefully considering system architecture and potential bottlenecks, developers can leverage this pattern to create more robust and maintainable applications. Remember to adapt the pattern to your specific needs. Happy coding! ❤️

The above is the detailed content of Design Patterns Serie — Structural Chapter: Proxy Pattern. For more information, please follow other related articles on the PHP Chinese website!