प्रॉक्सी पैटर्न: Difference between revisions

From Vigyanwiki
No edit summary
 
Line 700: Line 700:
[[Category:Pages with script errors]]
[[Category:Pages with script errors]]
[[Category:Pages with syntax highlighting errors]]
[[Category:Pages with syntax highlighting errors]]
[[Category:Vigyan Ready]]
[[Category:Templates Vigyan Ready]]
[[Category:Webarchive template wayback links]]

Latest revision as of 11:04, 10 March 2023

कंप्यूटर प्रोग्रामिंग में, प्रॉक्सी स्वरूप एक सॉफ्टवेयर डिजाइन स्वरूप है। प्रॉक्सी, अपने सबसे सामान्य रूप में, एक ऐसा वर्ग है जो किसी अन्य चीज़ के इंटरफ़ेस के रूप में कार्य करता है। प्रॉक्सी किसी भी चीज़ से इंटरफ़ेस कर सकता है: एक नेटवर्क संपर्क, मेमोरी में बड़ी वस्तु, फ़ाइल, या कुछ अन्य संसाधन जो महंगा या प्रतिलिपि करना असंभव है। संक्षेप में, प्रॉक्सी आवरण या एजेंट वस्तु है जिसे क्लाइंट द्वारा पर्दे के पीछे वास्तविक सेवारत वस्तु तक पहुँचने के लिए बुलाया जा रहा है। प्रॉक्सी का उपयोग केवल वास्तविक वस्तु को अग्रेषित (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) हो सकता है, या अतिरिक्त तर्क प्रदान कर सकता है। प्रॉक्सी में, अतिरिक्त कार्यक्षमता प्रदान की जा सकती है, उदाहरण के लिए कैशिंग जब वास्तविक वस्तु पर संचालन संसाधन गहन होते हैं, या वास्तविक वस्तु पर संचालन से पहले पूर्व नियम की जाँच की जाती है। क्लाइंट के लिए, प्रॉक्सी ऑब्जेक्ट का उपयोग वास्तविक ऑब्जेक्ट का उपयोग करने के समान होता है, क्योंकि दोनों ही इंटरफ़ेस को प्रयुक्त करते हैं।

अवलोकन

प्रॉक्सी 

[1]

डिजाइन स्वरूप तेईस प्रसिद्ध में से एक है डिजाइन स्वरूप्स यह वर्णन करता है कि लचीले और पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर को डिज़ाइन करने के लिए आवर्ती डिज़ाइन समस्याओं को कैसे हल किया जाए, अर्थात ऐसी वस्तुएँ जिन्हें प्रयुक्त करना, बदलना, परीक्षण करना और पुन: उपयोग करना आसान हो।

प्रॉक्सी डिज़ाइन स्वरूप किन समस्याओं को हल कर सकता है? [2]

  • किसी वस्तु की पहुंच को नियंत्रित किया जाना चाहिए।
  • किसी वस्तु तक पहुँचने पर अतिरिक्त कार्यक्षमता प्रदान की जानी चाहिए।

संवेदनशील वस्तुओं तक पहुँचते समय, उदाहरण के लिए, यह जाँचना संभव होना चाहिए कि ग्राहकों के पास आवश्यक पहुँच अधिकार हैं।

प्रॉक्सी डिज़ाइन स्वरूप किस समाधान का वर्णन करता है?

अलग परिभाषित करें Proxy उस पर आपत्ति करें

  • किसी (Subject) और अन्य वस्तु के विकल्प के रूप में इस्तेमाल किया जा सकता है
  • इस विषय तक पहुंच को नियंत्रित करने के लिए अतिरिक्त कार्यक्षमता प्रयुक्त करता है।

यह एक के माध्यम से काम करना संभव बनाता है Proxy किसी विषय तक पहुँचने पर अतिरिक्त कार्यक्षमता करने के लिए ऑब्जेक्ट। उदाहरण के लिए, किसी संवेदनशील वस्तु तक पहुँचने वाले ग्राहकों के पहुँच अधिकारों की जाँच करने के लिए।

किसी विषय के स्थानापन्न के रूप में कार्य करने के लिए, प्रॉक्सी को प्रयुक्त करना चाहिए Subject इंटरफेस। ग्राहक यह नहीं बता सकते कि वे किसी विषय या उसके प्रॉक्सी के साथ काम करते हैं या नहीं।

नीचे यूएमएल क्लास और सीक्वेंस डायग्राम भी देखें।

संरचना

यूएमएल वर्ग और अनुक्रम आरेख

प्रॉक्सी डिजाइन स्वरूप के लिए नमूना यूएमएल वर्ग और अनुक्रम आरेख। [3]

उपरोक्त एकीकृत मॉडलिंग भाषा वर्ग आरेख में, 

Proxy वर्ग प्रयुक्त करता है Subject इंटरफ़ेस ताकि यह इसके विकल्प के रूप में कार्य कर सके Subject वस्तुओं। यह संदर्भ रखता है (realSubject)

प्रतिस्थापित वस्तु के लिए (RealSubject) ताकि वह इसे अनुरोधों को अग्रेषित कर सके (realSubject.operation()).

अनुक्रम आरेख रन-टाइम इंटरैक्शन दिखाता है: Client वस्तु के माध्यम से काम करता है Proxy उस पर आपत्ति करें एक तक पहुंच को नियंत्रित करता है RealSubject वस्तु। इस उदाहरण में, Proxy को अनुरोध अग्रेषित करता है RealSubject, जो अनुरोध करता है।

वर्ग आरेख

एकीकृत मॉडलिंग भाषा में प्रॉक्सी
लेपस3 में प्रॉक्सी (लीजेंड)

संभावित उपयोग परिदृश्य

रिमोट प्रॉक्सी

वितरित वस्तु संचार में, एक स्थानीय वस्तु दूरस्थ वस्तु का प्रतिनिधित्व करती है (वह जो अलग पता स्थान से संबंधित है)। स्थानीय वस्तु दूरस्थ वस्तु के लिए प्रॉक्सी है, और स्थानीय वस्तु पर विधि मंगलाचरण के परिणामस्वरूप दूरस्थ वस्तु पर दूरस्थ विधि आह्वान होता है। उदाहरण एक स्वचालित टेलर मशीन कार्यान्वयन होगा, जहां एटीएम बैंक जानकारी के लिए प्रॉक्सी ऑब्जेक्ट रख सकता है जो रिमोट सर्वर में उपस्थित है।

वर्चुअल प्रॉक्सी

Further information: लेजी लोडिंग

एक जटिल या भारी वस्तु के स्थान पर, कुछ मामलों में कंकाल का प्रतिनिधित्व फायदेमंद हो सकता है। जब एक अंतर्निहित छवि आकार में बड़ी होती है, तो इसे वर्चुअल प्रॉक्सी ऑब्जेक्ट का उपयोग करके प्रदर्शित किया जा सकता है, वास्तविक वस्तु को मांग पर लोड किया जा सकता है।

सुरक्षा प्रॉक्सी

एक्सेस अधिकारों के आधार पर संसाधन तक पहुंच को नियंत्रित करने के लिए सुरक्षा प्रॉक्सी का उपयोग किया जा सकता है।

उदाहरण

The Wikibook Computer Science Design Patterns has a page on the topic of: Proxy implementations in various languages

सी #

interface ICar
{
    void DriveCar() ;
}

// Real Object
public class Car : ICar
{
    public void DriveCar()
    {
        Console.WriteLine("Car has been driven!");
    }
}

// Proxy Object
public class ProxyCar : ICar
{
    private Driver driver;
    private ICar realCar;

    public ProxyCar(Driver driver)
    {
        this.driver = driver;
        this.realCar = new Car();
    }

    public void DriveCar()
    {
        if (driver.Age < 16)
            Console.WriteLine("Sorry, the driver is too young to drive.");
        else
            this.realCar.DriveCar();
     }
}

public class Driver
{
    public int Age { get; set; }

    public Driver(int age)
    {
        this.Age = age;
    }
}

// How to use above Proxy class?
private void btnProxy_Click(object sender, EventArgs e)
{
    ICar car = new ProxyCar(new Driver(15));
    car.DriveCar();

    car = new ProxyCar(new Driver(25));
    car.DriveCar();
}

उत्पादन 

क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।
कार चलाई गई है!

टिप्पणियाँ:

  • एक प्रॉक्सी क्लाइंट को वास्तविक वस्तु के बारे में जानकारी छुपा सकता है।
  • एक प्रॉक्सी ऑन डिमांड लोडिंग जैसे अनुकूलन का प्रदर्शन कर सकता है।
  • एक प्रॉक्सी अतिरिक्त हाउसकीपिंग का काम कर सकता है जैसे ऑडिट कार्य।
  • प्रॉक्सी डिज़ाइन स्वरूप को सरोगेट डिज़ाइन स्वरूप के रूप में भी जाना जाता है।

सी ++

#include <iostream>
#include <memory>

class ICar {
 public:
  virtual ~ICar() { std::cout << "ICar destructor!" << std::endl; }

  virtual void DriveCar() = 0;
};

class Car : public ICar {
 public:
  void DriveCar() override { std::cout << "Car has been driven!" << std::endl; }
};

class ProxyCar : public ICar {
 public:
  ProxyCar(int driver_age) : driver_age_(driver_age) {}

  void DriveCar() override {
    if (driver_age_ > 16) {
      real_car_->DriveCar();
    } else {
      std::cout << "Sorry, the driver is too young to drive." << std::endl;
    }
  }

 private:
  std::unique_ptr<ICar> real_car_ = std::make_unique<Car>();
  int driver_age_;
};

int main() {
  std::unique_ptr<ICar> car = std::make_unique<ProxyCar>(16);
  car->DriveCar();

  car = std::make_unique<ProxyCar>(25);
  car->DriveCar();
}

क्रिस्टल

abstract class AbstractCar
  abstract def drive
end

class Car < AbstractCar
  def drive
    puts "Car has been driven!"
  end
end

class Driver
  getter age : Int32

  def initialize(@age)
  end
end

class ProxyCar < AbstractCar
  private getter driver : Driver
  private getter real_car : AbstractCar

  def initialize(@driver)
    @real_car = Car.new
  end

  def drive
    if driver.age <= 16
      puts "Sorry, the driver is too young to drive."
    else
      @real_car.drive
    end
  end
end

# Program
driver = Driver.new(16)
car = ProxyCar.new(driver)
car.drive

driver = Driver.new(25)
car = ProxyCar.new(driver)
car.drive

उत्पादन 

क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।
कार चलाई गई है!

डेल्फी/ऑब्जेक्ट पास्कल

// Proxy Design pattern
unit DesignPattern.Proxy;

interface

type
    // Car Interface
    ICar = interface
      procedure DriveCar;
    end;

    // TCar class, implementing ICar
    TCar = Class(TInterfacedObject, ICar)
      class function New: ICar;
      procedure DriveCar;
    End;

    // Driver Interface
    IDriver = interface
      function Age: Integer;
    end;

    // TDriver Class, implementing IDriver
    TDriver = Class(TInterfacedObject, IDriver)
    private
      FAge: Integer;
    public
      constructor Create(Age: Integer); Overload;
      class function New(Age: Integer): IDriver;
      function Age: Integer;
    End;

    // Proxy Object
    TProxyCar = Class(TInterfacedObject, ICar)
    private
      FDriver: IDriver;
      FRealCar: ICar;
    public
      constructor Create(Driver: IDriver); Overload;
      class function New(Driver: IDriver): ICar;
      procedure DriveCar;
    End;

implementation

{ TCar Implementation }

class function TCar.New: ICar;
begin
     Result := Create;
end;

procedure TCar.DriveCar;
begin
     WriteLn('Car has been driven!');
end;

{ TDriver Implementation }

constructor TDriver.Create(Age: Integer);
begin
     inherited Create;
     FAge := Age;
end;

class function TDriver.New(Age: Integer): IDriver;
begin
     Result := Create(Age);
end;

function TDriver.Age: Integer;
begin
     Result := FAge;
end;

{ TProxyCar Implementation }

constructor TProxyCar.Create(Driver: IDriver);
begin
     inherited Create;
     Self.FDriver  := Driver;
     Self.FRealCar := TCar.Create AS ICar;
end;

class function TProxyCar.New(Driver: IDriver): ICar;
begin
     Result := Create(Driver);
end;

procedure TProxyCar.DriveCar;
begin
     if (FDriver.Age <= 16)
        then WriteLn('Sorry, the driver is too young to drive.')
        else FRealCar.DriveCar();
end;

end.

उपयोग

program Project1;
{$APPTYPE Console}
uses
    DesignPattern.Proxy in 'DesignPattern.Proxy.pas';
begin
     TProxyCar.New(TDriver.New(16)).DriveCar;
     TProxyCar.New(TDriver.New(25)).DriveCar;
end.

उत्पादन 

क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।
कार चलाई गई है!

जावा

निम्न जावा (प्रोग्रामिंग भाषा) उदाहरण वर्चुअल प्रॉक्सी स्वरूप दिखाता है। ProxyImage e> वर्ग का उपयोग दूरस्थ विधि तक पहुँचने के लिए किया जाता है।

उदाहरण पहले एक इंटरफ़ेस बनाता है जिसके विरुद्ध स्वरूप कक्षाएं बनाता है। इस इंटरफ़ेस में छवि प्रदर्शित करने के लिए केवल एक विधि है, जिसे कहा जाता है displayImage(), जिसे इसे प्रयुक्त करने वाले सभी वर्गों द्वारा कोडित किया जाना है।

प्रॉक्सी वर्ग ProxyImage वास्तविक छवि वर्ग की तुलना में किसी अन्य प्रणाली पर चल रहा है और वास्तविक छवि का प्रतिनिधित्व कर सकता है RealImage वहाँ। छवि जानकारी डिस्क से एक्सेस की जाती है। प्रॉक्सी स्वरूप का उपयोग करते हुए, का कोड ProxyImage मेमोरी-सेविंग तरीके से अन्य प्रणाली से इसे एक्सेस करते हुए, छवि के कई लोडिंग से बचा जाता है। इस उदाहरण में प्रदर्शित लेजी लोडिंग प्रॉक्सी स्वरूप का हिस्सा नहीं है, किंतु प्रॉक्सी के उपयोग से संभव हुआ लाभ है।

interface Image {
    public void displayImage();
}

// On System A
class RealImage implements Image {
    private final String filename;

    /**
     * Constructor
     * @param filename
     */
    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    /**
     * Loads the image from the disk
     */
    private void loadImageFromDisk() {
        System.out.println("Loading   " + filename);
    }

    /**
     * Displays the image
     */
    public void displayImage() {
        System.out.println("Displaying " + filename);
    }
}

// On System B
class ProxyImage implements Image {
    private final String filename;
    private RealImage image;
    
    /**
     * Constructor
     * @param filename
     */
    public ProxyImage(String filename) {
        this.filename = filename;
    }

    /**
     * Displays the image
     */
    public void displayImage() {
        if (image == null) {
           image = new RealImage(filename);
        }
        image.displayImage();
    }
}

class ProxyExample {
   /**
    * Test method
    */
   public static void main(final String[] arguments) {
        Image image1 = new ProxyImage("HiRes_10MB_Photo1");
        Image image2 = new ProxyImage("HiRes_10MB_Photo2");

        image1.displayImage(); // loading necessary
        image1.displayImage(); // loading unnecessary
        image2.displayImage(); // loading necessary
        image2.displayImage(); // loading unnecessary
        image1.displayImage(); // loading unnecessary
    }
}


उत्पादन

Loading   HiRes_10MB_Photo1
Displaying HiRes_10MB_Photo1
Displaying HiRes_10MB_Photo1
Loading   HiRes_10MB_Photo2
Displaying HiRes_10MB_Photo2
Displaying HiRes_10MB_Photo2
Displaying HiRes_10MB_Photo1

जावास्क्रिप्ट

// Driver class
class Driver {
  constructor (age) {
    this.age = age
  }
}

// Car class
class Car {
  drive () {
    console.log('Car has been driven!')
  }
}

// Proxy car class
class ProxyCar {
  constructor (driver) {
    this.car = new Car()
    this.driver = driver
  }

  drive () {
    if (this.driver.age <= 16) {
      console.log('Sorry, the driver is too young to drive.')
    } else {
      this.car.drive()
    }
  }
}

// Run program
const driver = new Driver(16)
const car = new ProxyCar(driver)
car.drive()

const driver2 = new Driver(25)
const car2 = new ProxyCar(driver2)
car2.drive()


उत्पादन 

क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।
कार चलाई गई है!

अधिक उन्नत प्रॉक्सी में शामिल हैं Proxy ऑब्जेक्ट, जो गुणों तक पहुँचने जैसे मूलभूत कार्यों को रोक और फिर से परिभाषित कर सकता है। इस मामले में हैंडलर फ़ंक्शंस को कभी-कभी ट्रैप कहा जाता है।[4]


पीएचपी

<?php 

interface Image
{
    public function displayImage();
}

// On System A
class RealImage implements Image
{
    private string $filename = null;

    public function __construct(string $filename)
    {
        $this->filename = $filename;
        $this->loadImageFromDisk();
    }

    /**
     * Loads the image from the disk
     */
    private function loadImageFromDisk()
    {
        echo "Loading {$this->filename}" . \PHP_EOL;
    }

    /**
     * Displays the image
     */
    public function displayImage()
    {
    	echo "Displaying {$this->filename}" . \PHP_EOL;
    }
}

// On System B
class ProxyImage implements Image
{
    private ?Image $image = null;
    private string $filename = null;

    public function __construct(string $filename)
    {
        $this->filename = $filename;
    }

    /**
     * Displays the image
     */
    public function displayImage()
    {
        if ($this->image === null) {
           $this->image = new RealImage($this->filename);
        }
        $this->image->displayImage();
    }
}


$image1 = new ProxyImage("HiRes_10MB_Photo1");
$image2 = new ProxyImage("HiRes_10MB_Photo2");

$image1->displayImage(); // Loading necessary
$image1->displayImage(); // Loading unnecessary
$image2->displayImage(); // Loading necessary
$image2->displayImage(); // Loading unnecessary
$image1->displayImage(); // Loading unnecessary


उत्पादन

Loading HiRes_10MB_Photo1 
Displaying HiRes_10MB_Photo1 
Displaying HiRes_10MB_Photo1 
Loading HiRes_10MB_Photo2 
Displaying HiRes_10MB_Photo2 
Displaying HiRes_10MB_Photo2 
Displaying HiRes_10MB_Photo1

पायथन

"""
Proxy pattern example.
"""
from abc import ABCMeta, abstractmethod


NOT_IMPLEMENTED = "You should implement this."


class AbstractCar:
    __metaclass__ = ABCMeta

    @abstractmethod
    def drive(self):
        raise NotImplementedError(NOT_IMPLEMENTED)


class Car(AbstractCar):
    def drive(self) -> None:
        print("Car has been driven!")


class Driver:
    def __init__(self, age: int) -> None:
        self.age = age


class ProxyCar(AbstractCar):
    def __init__(self, driver) -> None:
        self.car = Car()
        self.driver = driver

    def drive(self) -> None:
        if self.driver.age <= 16:
            print("Sorry, the driver is too young to drive.")
        else:
            self.car.drive()


driver = Driver(16)
car = ProxyCar(driver)
car.drive()

driver = Driver(25)
car = ProxyCar(driver)
car.drive()

उत्पादन 

क्षमा करें, ड्राइवर ड्राइव करने के लिए बहुत छोटा है।
कार चलाई गई है!

जंग

trait ICar {
    fn drive(&self);
}

struct Car {}

impl ICar for Car {
    fn drive(&self) {
        println!("Car has been driven!");
    }
}

impl Car {
    fn new() -> Car {
        Car {}
    }
}

struct ProxyCar<'a> {
    real_car: &'a ICar,
    driver_age: i32,
}

impl<'a> ICar for ProxyCar<'a> {
    fn drive(&self) {
        if self.driver_age > 16 {
            self.real_car.drive();
        } else {
            println!("Sorry, the driver is too young to drive.")
        }
    }
}

impl<'a> ProxyCar<'a> {
    fn new(driver_age: i32, other_car: &'a ICar) -> ProxyCar {
        ProxyCar {
            real_car: other_car,
            driver_age: driver_age,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_underage() {
        let car = Car::new();
        let proxy_car = ProxyCar::new(16, &car);
        proxy_car.drive();
    }

    #[test]
    fn test_can_drive() {
        let car = Car::new();
        let proxy_car = ProxyCar::new(17, &car);
        proxy_car.drive();
    }
}

उत्पादन 

क्षमा करें, आपके ड्राइव करने के लिए कार बहुत छोटी है।
कार चलाई गई है!

यह भी देखें

संदर्भ

  1. ↑ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 207ff. ISBN 0-201-63361-2.{{cite book}}: CS1 maint: multiple names: authors list (link)
  2. ↑ "The Proxy design pattern - Problem, Solution, and Applicability". w3sDesign.com. Retrieved 2017-08-12.
  3. ↑ "The Proxy design pattern - Structure and Collaboration". w3sDesign.com. Retrieved 2017-08-12.
  4. ↑ "Proxy - JavaScript | MDN". developer.mozilla.org. Retrieved 21 January 2022.


बाहरी संबंध

Wikimedia Commons has media related to [[commons:Category:प्रॉक्सी पैटर्न|प्रॉक्सी पैटर्न]].
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=प्रॉक्सी_पैटर्न&oldid=102917’