What is the ISubject and Operation() of the code in proxy design pattern?

Question

I want to know base using the code below what is the: 1. ISubject and Operation() 2. realSubject: RealSubject and 3. Operation() realSubject.Operation() on the UML diagram of Proxy design pattern

link

//Payment.java
import java.math.*; import java.rmi.*;
public interface Payment extends Remote{
public void purchase(PaymentVO payInfo, BigDecimal price)
    throws PaymentException, RemoteException; }`

//PaymentProxy.java
import java.net.*;
import java.math.*;
import java.rmi.*;
      public class PaymentProxy implements PaymentService{
      private Payment implementation;
      private String serviceMachine = "localhost";
      private String serviceName = "paymentService";
      public PaymentProxy() throws ServiceUnavailableException{
          lookupRemoteService();
          }
private void lookupRemoteService() throws ServiceUnavailableException{
    try{
        String url = "//" + serviceMachine + "/" + serviceName;
        Object lookup = Naming.lookup(url);
            if (lookup instanceof Payment){
            implementation = (Payment)lookup;
    }
            else{
            throw new ServiceUnavailableException("Cannot locate remote service");
    }
    }
   catch (RemoteException exc){
   throw new ServiceUnavailableException("Error during remote service lookup", exc);
    }
    catch (NotBoundException exc){
    throw new ServiceUnavailableException("Remote service is not registered with naming server",     exc);
    }
    catch (MalformedURLException exc){
    throw new ServiceUnavailableException("Malformed URL for naming lookup", exc);
    }
    }
      public void setServiceMachine(String machineName){
       serviceMachine = machineName;
    }
      public void setServiceName(String svcName){
       serviceName = svcName;
      }
       public void purchase(PaymentVO pay, BigDecimal price) throws PaymentException,     ServiceUnavailableException{
     try{
    if (implementation != null){
      implementation.purchase(pay, price);
     }
   }
   catch (RemoteException exc){
   try{
      lookupRemoteService();
       implementation.purchase(pay, price);
   }
    catch (RemoteException exc2){
     throw new PaymentException("Cannot process payment: remote communication problems with payment service", exc2);
     }
   }
  }
  }`

 //PaymentImpl.java
 import java.math.*;
 import java.net.*;
 import java.rmi.*;
 import java.rmi.server.*;
       public class PaymentImpl implements Payment{
       private static final String PAYMENT_SERVICE_NAME = "paymentService";

     public PaymentImpl() throws RemoteException, MalformedURLException{
UnicastRemoteObject.exportObject(this);
Naming.rebind(PAYMENT_SERVICE_NAME, this);
}
public void purchase(PaymentVO payInfo, BigDecimal price)
  throws PaymentException{
}
}`

Answer 1

The PaymentProxy should implement Payment instead of PaymentService :

public class PaymentProxy implements Payment {

In this case:

• Payment is ISubject ;
• PaymentImpl is RealSubject (so implementation in PaymentProxy is the realSubject field);
• the overriden purchase() method corresponds to Operation() in RealSubject .

---

A more robust explanation:

The Payment interface is implemented by both classes. Additionally, each of them overrides the purchase() method. But the PaymentProxy is a wrapper , since it aggregates PaymentImpl and adds null checking in the overriden method:

  public void purchase(PaymentVO pay, BigDecimal price) throws PaymentException,       ServiceUnavailableException, RemoteException{
      if (implementation != null){
         implementation.purchase(pay, price);
      }
   }