Design patterns
बिल्डर पैटर्न

.NET Framework Android ASP.NET asp.net-mvc C# Language C++ Java Language JavaScript PHP Python Language
खोज…


टिप्पणियों

एक जटिल ऑब्जेक्ट के निर्माण को उसके प्रतिनिधित्व से अलग करता है ताकि एक ही निर्माण प्रक्रिया अलग-अलग प्रतिनिधित्व बना सके।

  • प्रतिनिधित्व से तर्क को अलग करें।
  • डेटा के विभिन्न सेट के साथ काम करने के लिए तर्क का पुन: उपयोग करें।

बिल्डर पैटर्न / सी # / धाराप्रवाह इंटरप्रेट

public class Email
{
    public string To { get; set; }
    public string From { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }
}

public class EmailBuilder
{
    private readonly Email _email;

    public EmailBuilder()
    {
        _email = new Email();
    }

    public EmailBuilder To(string address)
    {
        _email.To = address;
        return this;
    }

    public EmailBuilder From(string address)
    {
        _email.From = address;
        return this;
    }

    public EmailBuilder Subject(string title)
    {
        _email.Subject = title;
        return this;
    }

    public EmailBuilder Body(string content)
    {
        _email.Body = content;
        return this;
    }

    public Email Build()
    {
        return _email;
    }
}

उपयोग उदाहरण: 

var emailBuilder = new EmailBuilder();
var email = emailBuilder
    .To("[email protected]")
    .From("[email protected]")
    .Subject("Email subject")
    .Body("Email content")
    .Build();

बिल्डर पैटर्न / जावा कार्यान्वयन

बिल्डर पैटर्न आपको आसानी से पढ़ने के तरीके में कई वैकल्पिक चर के साथ एक वर्ग का एक उदाहरण बनाने की अनुमति देता है।

निम्नलिखित कोड पर विचार करें: 

public class Computer {

    public GraphicsCard graphicsCard;
    public Monitor[] monitors;
    public Processor processor;
    public Memory[] ram;
    //more class variables here...

    Computer(GraphicsCard g, Monitor[] m, Processer p, Memory ram) {
        //code omitted for brevity...
    }

    //class methods omitted...

}

यह सभी अच्छी तरह से और अच्छा है यदि सभी पैरामीटर आवश्यक हैं। क्या होगा यदि बहुत अधिक चर हैं और / या उनमें से कुछ वैकल्पिक हैं? आप आवश्यक और वैकल्पिक मापदंडों के प्रत्येक संभावित संयोजन के साथ बड़ी संख्या में निर्माणकर्ता नहीं बनाना चाहते हैं क्योंकि इसे बनाए रखना और डेवलपर्स के लिए समझना मुश्किल हो जाता है। आप मापदंडों की एक लंबी सूची भी नहीं रखना चाह सकते हैं, जिसमें कई को उपयोगकर्ता द्वारा शून्य के रूप में दर्ज करने की आवश्यकता हो सकती है।

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

बिल्डर में build() नामक एक विधि भी शामिल है, जो उस वस्तु को लौटाता है जो इसमें है और वस्तु का निर्माण करते समय विधि कॉल की श्रृंखला के अंत में बुलाया जाना चाहिए।

पिछले उदाहरण से, यह कोड कंप्यूटर वर्ग के लिए बिल्डर पैटर्न का उपयोग करता है। 

public class Computer {

    private GraphicsCard graphicsCard;
    private Monitor[] monitors;
    private Processor processor;
    private Memory[] ram;
    //more class variables here...

    private Computer(Builder builder) {
        this.graphicsCard = builder.graphicsCard;
        this.monitors = builder.monitors;
        this.processor = builder.processor;
        this.ram = builder.ram;
    }

    public GraphicsCard getGraphicsCard() {
        return this.graphicsCard;
    }

    public Monitor[] getMonitors() {
        return this.monitors;
    }

    public Processor getProcessor() {
        return this.processor;
    }

    public Memory[] getRam() {
        return this.ram;
    }

    public static class Builder {
        private GraphicsCard graphicsCard;
        private Monitor[] monitors;
        private Processor processor;
        private Memory[] ram;

        public Builder(Processor p){
            this.processor = p;
        }

        public Builder graphicsCard(GraphicsCard g) {
            this.graphicsCard = g;
            return this;
        }

        public Builder monitors(Monitor[] mg) {
            this.monitors = mg;
            return this;
        }

        public Builder ram(Memory[] ram) {
            this.ram = ram;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

इस वर्ग का उपयोग कैसे किया जाएगा, इसका एक उदाहरण: 

public class ComputerExample {

    public static void main(String[] args) {
        Computer headlessComputer = new Computer.Builder(new Processor("Intel-i3"))
                .graphicsCard(new GraphicsCard("GTX-960"))
                .build();

        Computer gamingPC = new Computer.Builder(new Processor("Intel-i7-quadcode"))
                .graphicsCard(new GraphicsCard("DX11"))
                .monitors(new Monitor[] = {new Monitor("acer-s7"), new Monitor("acer-s7")})
                .ram(new Memory[] = {new Memory("2GB"), new Memory("2GB"), new Memory("2GB"), new Memory("2GB")})
                .build();
    }

}

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

संरचना के साथ जावा में बिल्डर पैटर्न

आशय:

एक जटिल वस्तु के निर्माण को उसके प्रतिनिधित्व से अलग करें ताकि एक ही निर्माण प्रक्रिया अलग-अलग निरूपण बना सके

बिल्डर पैटर्न तब उपयोगी होता है जब आपके पास कुछ अनिवार्य गुण होते हैं और एक वस्तु के निर्माण के लिए कई वैकल्पिक गुण होते हैं। ऑब्जेक्ट को विभिन्न अनिवार्य और वैकल्पिक विशेषताओं के साथ बनाने के लिए, आपको ऑब्जेक्ट बनाने के लिए जटिल कंस्ट्रक्टर प्रदान करना पड़ता है। ब्रैस्ट पैटर्न एक जटिल ऑब्जेक्ट के निर्माण के लिए सरल चरण-दर-चरण प्रक्रिया प्रदान करता है।

वास्तविक जीवन का उपयोग मामला:

फेसबुक के अलग-अलग उपयोगकर्ताओं में अलग-अलग विशेषताएँ होती हैं, जिनमें उपयोगकर्ता नाम और अनिवार्य विशेषताएँ जैसे UserBasicInfo और ContactInfo जैसी अनिवार्य विशेषताएँ होती हैं। कुछ उपयोगकर्ता बस बुनियादी जानकारी प्रदान करते हैं। कुछ उपयोगकर्ता संपर्क जानकारी सहित विस्तृत जानकारी प्रदान करते हैं। बिल्डर पैटर्न की अनुपस्थिति में, आपको सभी अनिवार्य और वैकल्पिक मापदंडों के साथ एक कंस्ट्रक्टर प्रदान करना होगा। लेकिन बिल्डर पैटर्न जटिल ऑब्जेक्ट के निर्माण के लिए सरल चरण-दर-चरण प्रक्रिया प्रदान करके निर्माण प्रक्रिया को सरल बनाता है।

सुझाव:

  1. एक स्थिर नेस्टेड बिल्डर वर्ग प्रदान करें।
  2. ऑब्जेक्ट की अनिवार्य विशेषताओं के लिए कंस्ट्रक्टर प्रदान करें।
  3. ऑब्जेक्ट की वैकल्पिक विशेषताओं के लिए सेटर और गेट्टर तरीके प्रदान करें।
  4. वैकल्पिक विशेषताएँ सेट करने के बाद उसी बिल्डर ऑब्जेक्ट को लौटाएँ।
  5. बिल्ड () विधि प्रदान करें, जो जटिल वस्तु देता है

सांकेतिक टुकड़ा: 

import java.util.*;

class UserBasicInfo{
    String nickName;
    String birthDate;
    String gender;
    
    public UserBasicInfo(String name,String date,String gender){
        this.nickName = name;
        this.birthDate = date;
        this.gender = gender;        
    }
    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("Name:DOB:Gender:").append(nickName).append(":").append(birthDate).append(":").
        append(gender);
        return sb.toString();
    }
}

class ContactInfo{
    String eMail;
    String mobileHome;
    String mobileWork;
    
    public ContactInfo(String mail, String homeNo, String mobileOff){
        this.eMail = mail;
        this.mobileHome = homeNo;
        this.mobileWork = mobileOff;
    }    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("email:mobile(H):mobile(W):").append(eMail).append(":").append(mobileHome).append(":").append(mobileWork);
        return sb.toString();
    }
}
class FaceBookUser {
    String userName;
    UserBasicInfo userInfo;
    ContactInfo contactInfo;
    
    public FaceBookUser(String uName){
        this.userName = uName;
    }    
    public void setUserBasicInfo(UserBasicInfo info){
        this.userInfo = info;
    }
    public void setContactInfo(ContactInfo info){
        this.contactInfo = info;
    }    
    public String getUserName(){
        return userName;
    }
    public UserBasicInfo getUserBasicInfo(){
        return userInfo;
    }
    public ContactInfo getContactInfo(){
        return contactInfo;
    }
    
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("|User|").append(userName).append("|UserInfo|").append(userInfo).append("|ContactInfo|").append(contactInfo);
        return sb.toString();
    }
    
    static class FaceBookUserBuilder{
        FaceBookUser user;
        public FaceBookUserBuilder(String userName){
            this.user = new FaceBookUser(userName);
        }
        public FaceBookUserBuilder setUserBasicInfo(UserBasicInfo info){
            user.setUserBasicInfo(info);
            return this;
        }
        public FaceBookUserBuilder setContactInfo(ContactInfo info){
            user.setContactInfo(info);
            return this;
        }
        public FaceBookUser build(){
            return user;
        }
    }
}
public class BuilderPattern{
    public static void main(String args[]){
        FaceBookUser fbUser1 = new FaceBookUser.FaceBookUserBuilder("Ravindra").build(); // Mandatory parameters
        UserBasicInfo info = new UserBasicInfo("sunrise","25-May-1975","M");
        
        // Build User name + Optional Basic Info 
        FaceBookUser fbUser2 = new FaceBookUser.FaceBookUserBuilder("Ravindra").
                                                setUserBasicInfo(info).build();
        
        // Build User name + Optional Basic Info + Optional Contact Info
        ContactInfo cInfo = new ContactInfo("[email protected]","1111111111","2222222222");
        FaceBookUser fbUser3 = new FaceBookUser.FaceBookUserBuilder("Ravindra").
                                                setUserBasicInfo(info).
                                                setContactInfo(cInfo).build();
        
        System.out.println("Facebook user 1:"+fbUser1);
        System.out.println("Facebook user 2:"+fbUser2);
        System.out.println("Facebook user 3:"+fbUser3);
    }
}

उत्पादन: 

Facebook user 1:|User|Ravindra|UserInfo|null|ContactInfo|null
Facebook user 2:|User|Ravindra|UserInfo|Name:DOB:Gender:sunrise:25-May-1975:M|ContactInfo|null
Facebook user 3:|User|Ravindra|UserInfo|Name:DOB:Gender:sunrise:25-May-1975:M|ContactInfo|email:mobile(H):mobile(W):[email protected]:1111111111:2222222222

स्पष्टीकरण:

  1. FaceBookUser संरचना का उपयोग करते हुए नीचे विशेषताओं के साथ एक जटिल वस्तु है: 

    String userName;
UserBasicInfo userInfo;
ContactInfo contactInfo;

  2. FaceBookUserBuilder एक स्थिर बिल्डर वर्ग है, जिसमें FaceBookUser शामिल है और बनाता है।

  3. userName FaceBookUser निर्माण के लिए केवल अनिवार्य पैरामीटर है

  4. FaceBookUserBuilder बनाता FaceBookUser : वैकल्पिक पैरामीटर की स्थापना करके UserBasicInfo और ContactInfo

  5. यह उदाहरण बिल्डर से निर्मित अलग-अलग विशेषताओं के साथ तीन अलग-अलग फेस बुक यूजर्स को दिखाता है।

    1. fbUser1 को केवल UserName विशेषता के साथ FaceBookUser के रूप में बनाया गया था
    2. fbUser2 को UserName और UserBasicInfo के साथ FaceBookUser के रूप में बनाया गया था
    3. fbUser3 को UserName, UserBasicInfo और ContactInfo के साथ FaceBookUser के रूप में बनाया गया था

उपरोक्त उदाहरण में, बिल्डर वर्ग में फेसबुकेसर की सभी विशेषताओं की नकल करने के बजाय रचना का उपयोग किया गया है।

रचनात्मक पैटर्न में, हम पहले FactoryMethod तरह सरल पैटर्न के साथ शुरू करेंगे और AbstractFactory और Builder जैसे अधिक लचीले और जटिल पैटर्न की ओर बढ़ेंगे।

जावा / लोम्बोक

import lombok.Builder;

@Builder
public class Email {

    private String to;
    private String from;
    private String subject;
    private String body;

}

उपयोग उदाहरण: 

Email.builder().to("[email protected]")
        .from("[email protected]")
        .subject("Email subject")
        .body("Email content")
        .build();

जावा 8 लैम्ब्डा एक्सप्रेशन के साथ उन्नत बिल्डर पैटर्न

public class Person {
private final String salutation;
private final String firstName;
private final String middleName;
private final String lastName;
private final String suffix;
private final Address address;
private final boolean isFemale;
private final boolean isEmployed;
private final boolean isHomewOwner;

public Person(String salutation, String firstName, String middleName, String lastName, String suffix, Address address, boolean isFemale, boolean isEmployed, boolean isHomewOwner) {
    this.salutation = salutation;
    this.firstName = firstName;
    this.middleName = middleName;
    this.lastName = lastName;
    this.suffix = suffix;
    this.address = address;
    this.isFemale = isFemale;
    this.isEmployed = isEmployed;
    this.isHomewOwner = isHomewOwner;
 }
}

पुराना तरीका 

public class PersonBuilder {
private String salutation;
private String firstName;
private String middleName;
private String lastName;
private String suffix;
private Address address;
private boolean isFemale;
private boolean isEmployed;
private boolean isHomewOwner;

public PersonBuilder withSalutation(String salutation) {
    this.salutation = salutation;
    return this;
}

public PersonBuilder withFirstName(String firstName) {
    this.firstName = firstName;
    return this;
}

public PersonBuilder withMiddleName(String middleName) {
    this.middleName = middleName;
    return this;
}

public PersonBuilder withLastName(String lastName) {
    this.lastName = lastName;
    return this;
}

public PersonBuilder withSuffix(String suffix) {
    this.suffix = suffix;
    return this;
}

public PersonBuilder withAddress(Address address) {
    this.address = address;
    return this;
}

public PersonBuilder withIsFemale(boolean isFemale) {
    this.isFemale = isFemale;
    return this;
}

public PersonBuilder withIsEmployed(boolean isEmployed) {
    this.isEmployed = isEmployed;
    return this;
}

public PersonBuilder withIsHomewOwner(boolean isHomewOwner) {
    this.isHomewOwner = isHomewOwner;
    return this;
}

public Person createPerson() {
    return new Person(salutation, firstName, middleName, lastName, suffix, address, isFemale, isEmployed, isHomewOwner);
}

उन्नत तरीका: 

public class PersonBuilder {
public String salutation;
public String firstName;
public String middleName;
public String lastName;
public String suffix;
public Address address;
public boolean isFemale;
public boolean isEmployed;
public boolean isHomewOwner;

public PersonBuilder with(
        Consumer<PersonBuilder> builderFunction) {
    builderFunction.accept(this);
    return this;
}


public Person createPerson() {
    return new Person(salutation, firstName, middleName,
            lastName, suffix, address, isFemale,
            isEmployed, isHomewOwner);
}

}

उपयोग: 

Person person = new PersonBuilder()
    .with($ -> {
        $.salutation = "Mr.";
        $.firstName = "John";
        $.lastName = "Doe";
        $.isFemale = false;
        $.isHomewOwner = true;
        $.address =
            new PersonBuilder.AddressBuilder()
                .with($_address -> {
                    $_address.city = "Pune";
                    $_address.state = "MH";
                    $_address.pin = "411001";
                }).createAddress();
    })
    .createPerson();

देखें: https://medium.com/beingprofessional/think-functional-advanced-builder-pattern-using-lambda-284714b85ed5#.d9sryx3g9



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow