Free Data Structures and Algorithms Course









Subscribe below and get all best seller courses for free !!!










OR



Subscribe to all free courses

How to implement Dynamic Proxy Design Pattern in Java ?.


Lets look at the what Dynamic Proxy Design Pattern does for us :




Program to demonstrate how to implement Dynamic Proxy Design Pattern in Java.


Click here to download complete source code 


Step 1: Creation of Interface

package com.hubberspot.designpatterns.proxy.example;

// Create a interface Developer having
// few getters and setters. See below ...

public interface Developer {

 String getName(); 
 String getSalary();
 String getRole();
 int getRating();


 void setName(String name); 
 void setSalary(String salary);
 void setRole(String role); 
 void setRating(int rating);
}




Step 2 : Creation of Implementation class

package com.hubberspot.designpatterns.proxy.example;

public class DeveloperImpl implements Developer {

 // Few properties and respective 
 // getters and setters in the 
 // interface 
 String name;
 String salary;
 int rating;
 String role;


 @Override
 public String getName() {
  return name;
 }

 @Override
 public String getSalary() {
  return salary;
 }

 @Override
 public String getRole() {
  return role;
 }

 @Override
 public int getRating() {
  return rating;
 }

 @Override
 public void setName(String name) {
  this.name = name;    
 }

 @Override
 public void setSalary(String salary) {
  this.salary = salary;
 }

 @Override
 public void setRole(String role) {
  this.role = role;
 }

 @Override
 public void setRating(int rating) {
  this.rating = rating;
 }

}



Step 3 : Creation of Dynamic proxie as Developer Invocation Handler

package com.hubberspot.designpatterns.proxy.example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

// Make a proxie as how methods on Developer calls as per the
// developer.
public class DeveloperHandling  implements InvocationHandler {

 // having Developer as a instance variable
 Developer employee;

 // Constructor of class setting the value of the
 // Developer instance variable
 public DeveloperHandling(Developer employee) {
  this.employee = employee;
 }

 // InvocationHandler interface has a method by name
 // invoke which returns back an Object. It works on 
 // the principle of reflection. Each time a call is 
 // made by Developer on its setter and getter this
 // method will be called first.
 // This method takes in three arguments : 
 // 1. Dynamically created proxy object 
 // 2. Method and information regarding the method which 
 // needs to be called. 
 // 3. Plus what arguments called method takes to fulfil
 // the calling process.
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws IllegalAccessException {

  try {

   // Method class has a method by getName() , which returns
   // back the method name which is called by the Developer.

   if(method.getName().startsWith("get")) {

    // Method class has a method by name invoke().
    // This method invokes employee methods and passing 
    // the aruments to it, based on the if condition.
    return method.invoke(employee, args);

   }

   // In order to set restriction on developer to 
   // not able to change state of role, salary and rating
   // if condition on fulfillment throws IllegalAccessException
   // because a developer has no right to set his salary,
   // role and rate himself. It is duty of his manager to 
   // which he reports
   else if (method.getName().equals("setRole")) {
    throw new IllegalAccessException();
   }
   else if (method.getName().equals("setSalary")) {
    throw new IllegalAccessException();
   }
   else if (method.getName().equals("setRating")) {
    throw new IllegalAccessException();
   }

  } 
  catch(InvocationTargetException e) {
   e.printStackTrace();
  }


  return null;
 }

}




Step 4 : Creation of Dynamic proxie as Managers Invocation Handler

package com.hubberspot.designpatterns.proxy.example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

// same explanation as given in DeveloperHandling.java class
// above
public class ManagersHandling implements InvocationHandler {

 Developer employee; 

 public ManagersHandling(Developer employee) {
  this.employee = employee;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws IllegalAccessException {

  try { 

   if(method.getName().startsWith("get")) {

    return method.invoke(employee, args);

   }
   else if(method.getName().startsWith("setName")) {

    throw new IllegalAccessException();

   }
   else if(method.getName().startsWith("set")) {

    return method.invoke(employee, args);

   }

  }
  catch (InvocationTargetException e) {
   e.printStackTrace();
  }


  return null;
 }

}



Step 5: Test class for creating Dynamic Proxies and running the code.

package com.hubberspot.designpatterns.proxy.example;

import java.lang.reflect.Proxy;
import java.util.HashMap;

public class HRMTest {

 // Create a HashMap to store employee object as a 
 // name value pair
 HashMap developer = new HashMap();

 public HRMTest() {
  // Constructor creates a new Developer by 
  // giving it a few properties.
  Developer dinesh = new DeveloperImpl();
  dinesh.setName("Dinesh Varyani");
  dinesh.setSalary("25000");
  dinesh.setRating(7);
  dinesh.setRole("Senior Developer");
  developer.put("Dinesh", dinesh);

 }

 public static void main(String[] args) {

  // main method after creating HRMTest object 
  // calls test() method.
  HRMTest hrmTest = new HRMTest();
  hrmTest.test();

 }

 public void test() {

  // Initially if Proxy Design Pattern hadn't been implemented Developer
  // and Manager can all change state of Developer/employee properties.
  System.out.println("---------------------------------------------------");
  System.out.println("Let's test Developer perspective .....\n");

  // Lets look at developer perspective what he has restriction
  // on him after implementing Proxy Design pattern.
  Developer dinesh = (Developer)developer.get("Dinesh");
  Developer developerProxy = getDeveloperProxy(dinesh);

  System.out.println("Name of the developer : " + developerProxy.getName());

  // He cannot set his rating, salary and role. An exception will be
  // thrown which will print following message in sysouts
  try{
   developerProxy.setRating(10);
  }
  catch(Exception e) {
   System.out.println("Developer cant provide rating to itself");
  }

  try{
   developerProxy.setSalary("100000");
  }
  catch(Exception e) {
   System.out.println("Developer increase or set salary to itself");
  }

  try{
   developerProxy.setRole("Manager");
  }
  catch(Exception e) {
   System.out.println("Developer cannot change its role in company\n");
  }

  System.out.println("---------------------------------------------------");

  System.out.println("Let's test Managers perspective .....\n");

  // Lets look at the Managers perspective now as what it does to developer
  // object 
  dinesh = (Developer)developer.get("Dinesh");

  Developer managerProxy = getManagerProxy(dinesh);

  System.out.println("Name of the developer : " + managerProxy.getName());

  System.out.println("Set salary of the employee : "); 
  managerProxy.setSalary("15000");

  System.out.println("Salary of the developer : " + managerProxy.getSalary());

  // He cannot change the name of the developer. Rest he can change i.e
  // salary, role and rating.
  try{
   managerProxy.setName("Mangesh Virani");
  }
  catch(Exception e) {
   System.out.println("Manager cant change or set name of developer");
  }

  System.out.println("---------------------------------------------------");


 }


 // In order to create Dynamic Proxy we have to apply following steps
 // in java 
 // This method takes in a Developer object (real) and returns
 // back the proxy for it. It returns a Developer which acts as
 // proxy.
 public Developer getDeveloperProxy(Developer employee) {

  // To create a Dynamic Proxy we have to call
  // newProxyInstance() static method of class Proxy. 
  // It takes three arguments : 
  // 1. Class Loader for our real object.
  // 2. Set of interfaces proxy needs to implement.
  // 3. A new object of our DeveloperHandling invocation
  // handler. It takes in the real object and returns
  // us back with proxy object. 

  return (Developer) Proxy.newProxyInstance(
    employee.getClass().getClassLoader(), 
    employee.getClass().getInterfaces(), 
    new DeveloperHandling(employee));

 }

 public Developer getManagerProxy(Developer employee) {
  // Same as above. Instead of Developer now it returns 
  // an proxy on Managers Handling mechanism.
  return (Developer) Proxy.newProxyInstance(
    employee.getClass().getClassLoader(), 
    employee.getClass().getInterfaces(), 
    new ManagersHandling(employee));

 }

}



Click here to download complete source code

Output of the program :



 
© 2021 Learn Java by Examples Template by Hubberspot