{"id":106793,"date":"2020-09-17T10:00:00","date_gmt":"2020-09-17T07:00:00","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=106793"},"modified":"2020-09-16T15:04:29","modified_gmt":"2020-09-16T12:04:29","slug":"implementing-the-proxy-pattern-in-java","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2020\/09\/implementing-the-proxy-pattern-in-java.html","title":{"rendered":"Implementing the Proxy Pattern in Java"},"content":{"rendered":"

The Proxy Pattern<\/h2>\n

Proxy is a common software design pattern. Wikipedia does a good job describing it like this:<\/p>\n

\n

[..] In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. [..]<\/p>\n

(Wikipedia<\/a>)<\/cite><\/p><\/blockquote>\n

UML class diagram:<\/p>\n

\n
\"\"<\/figure>\n<\/div>\n

A client requires a Subject (typically an interface). This subject is implemented by a real implementation (here: RealSubject<\/em>). A proxy implements the same interface and delegates operations to the real subject while adding its own functionality.<\/p>\n

In the next sections we will see how this pattern can be implemented in Java.<\/p>\n

Creating a simple proxy<\/h2>\n

We start with an interface UserProvider (the Subject<\/em> in the above diagram):<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n<\/td>\n
\n
\n
public<\/code> interface<\/code> UserProvider {<\/code><\/div>\n
    <\/code>User getUser(<\/code>int<\/code> id);<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

This interface is implemented by UserProviderImpl (the real implementation<\/em>):<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> UserProviderImpl <\/code>implements<\/code> UserProvider {<\/code><\/div>\n
    <\/code>@Override<\/code><\/div>\n
    <\/code>public<\/code> User getUser(<\/code>int<\/code> id) {<\/code><\/div>\n
        <\/code>return<\/code> ...<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

UserProvider is used by UsefulService (the client<\/em>):<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> UsefulService {<\/code><\/div>\n
    <\/code>private<\/code> final<\/code> UserProvider userProvider;<\/code><\/div>\n
 <\/div>\n
    <\/code>public<\/code> UsefulService(UserProvider userProvider) {<\/code><\/div>\n
        <\/code>this<\/code>.userProvider = userProvider;<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>\/\/ useful methods<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

To initialize a UsefulService instance we just have to pass a UserProvider object to the constructor:<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
UserProvider userProvider = <\/code>new<\/code> DatabaseUserProvider();<\/code><\/div>\n
UsefulService service = <\/code>new<\/code> UsefulService(userProvider);<\/code><\/div>\n
 <\/div>\n
\/\/ use service<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Now let’s add a Proxy object for UserProvider that does some simple logging:

<\/div> <\/div><\/p>\n
\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> LoggingUserProviderProxy <\/code>implements<\/code> UserProvider {<\/code><\/div>\n
    <\/code>private<\/code> final<\/code> UserProvider userProvider;<\/code><\/div>\n
 <\/div>\n
    <\/code>public<\/code> LoggingUserProviderProxy(UserProvider userProvider) {<\/code><\/div>\n
        <\/code>this<\/code>.userProvider = userProvider;<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
 <\/div>\n
    <\/code>@Override<\/code><\/div>\n
    <\/code>public<\/code> User getUser(<\/code>int<\/code> id) {<\/code><\/div>\n
        <\/code>System.out.println(<\/code>\"Retrieving user with id \"<\/code> + id);<\/code><\/div>\n
        <\/code>return<\/code> userProvider.getUser(id);<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

We want to create a proxy for UserProvider, so our proxy needs to implement UserProvider. Within the constructor we accept the real UserProvider implementation. In the getUser(..) method we first write a message to standard out before we delegate the method call to the real implementation.<\/p>\n

To use our Proxy we have to update our initialization code:<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
UserProvider userProvider = <\/code>new<\/code> UserProviderImpl();<\/code><\/div>\n
LoggingUserProviderProxy loggingProxy = <\/code>new<\/code> LoggingUserProviderProxy(userProvider);<\/code><\/div>\n
UsefulService usefulService = <\/code>new<\/code> UsefulService(loggingProxy);<\/code><\/div>\n
 <\/div>\n
\/\/ use service<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

Now, whenever UsefulService uses the getUser() method we will see a console message before a User object is returned from UserProviderImpl. With the Proxy pattern we were able to add logging without modifying the client (UsefulService) and the real implementation (UserProviderImpl).<\/p>\n

The problem with manual proxy creation<\/h2>\n

The previous solution has a major downside: Our Proxy implementation is bound to the UserProvider interfaces and therefore hard to reuse.<\/p>\n

Proxy logic is often quite generic. Typical use-cases for proxies include caching, access to remote objects or lazy loading.<\/p>\n

However, a proxy needs to implement a specific interface (and its methods). This contradicts with re-usability.<\/p>\n

Solution: JDK Dynamic Proxies<\/h2>\n

The JDK provides a standard solution to this problem, called Dynamic Proxies<\/a>. Dynamic Proxies let us create a implementation for a specific interface at runtime. Method calls on this generated proxy are delegated to an InvocationHandler.<\/p>\n

With Dynamic Proxies the proxy creation looks like this:<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n<\/td>\n
\n
\n
UserProvider userProvider = <\/code>new<\/code> DatabaseUserProvider();<\/code><\/div>\n
UserProvider proxy = (UserProvider) Proxy.newProxyInstance(<\/code><\/div>\n
        <\/code>UserProvider.<\/code>class<\/code>.getClassLoader(),<\/code><\/div>\n
        <\/code>new<\/code> Class[]{ UserProvider.<\/code>class<\/code> },<\/code><\/div>\n
        <\/code>new<\/code> LoggingInvocationHandler(userProvider)<\/code><\/div>\n
);<\/code><\/div>\n
UsefulService usefulService = <\/code>new<\/code> UsefulService(proxy);<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

With Proxy.newProxyInstance(..) we create a new proxy object. This method takes three arguments:<\/p>\n