సాధారణ ఫ్యాక్టరీ నమూనా: వస్తువుల సృష్టిలో టైప్ భద్రతను సాధించడం

ఫ్యాక్టరీ నమూనా అనేది ఒక సృష్టిపరమైన డిజైన్ నమూనా, ఇది వాటి కాంక్రీట్ తరగతులను పేర్కొనకుండానే వస్తువులను సృష్టించడానికి ఒక ఇంటర్‌ఫేస్‌ను అందిస్తుంది. ఇది వస్తువుల సృష్టి ప్రక్రియ నుండి క్లయింట్ కోడ్‌ను వేరు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, దీని వలన కోడ్ మరింత సౌకర్యవంతంగా మరియు నిర్వహించదగినదిగా మారుతుంది. అయితే, సాంప్రదాయ ఫ్యాక్టరీ నమూనా కొన్నిసార్లు టైప్ భద్రతను కలిగి ఉండదు, ఇది రన్‌టైమ్ లోపాలకు దారి తీస్తుంది. సాధారణ ఫ్యాక్టరీ నమూనా టైప్-సురక్షిత వస్తువుల సృష్టిని నిర్ధారించడానికి సాధారణీకరణాలను ఉపయోగించడం ద్వారా ఈ పరిమితిని పరిష్కరిస్తుంది.

సాధారణ ఫ్యాక్టరీ నమూనా అంటే ఏమిటి?

సాధారణ ఫ్యాక్టరీ నమూనా అనేది ప్రామాణిక ఫ్యాక్టరీ నమూనా యొక్క పొడిగింపు, ఇది కంపైల్ సమయంలో టైప్ భద్రతను అమలు చేయడానికి సాధారణీకరణాలను ఉపయోగిస్తుంది. ఫ్యాక్టరీ ద్వారా సృష్టించబడిన వస్తువులు ఆశించిన రకానికి అనుగుణంగా ఉన్నాయని ఇది నిర్ధారిస్తుంది, ఇది రన్‌టైమ్ సమయంలో ఊహించని లోపాలను నివారిస్తుంది. C#, Java మరియు TypeScript వంటి సాధారణీకరణలకు మద్దతు ఇచ్చే భాషలలో ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.

సాధారణ ఫ్యాక్టరీ నమూనాను ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు

• టైప్ భద్రత: సృష్టించబడిన వస్తువులు సరైన రకానికి చెందినవని నిర్ధారిస్తుంది, ఇది రన్‌టైమ్ లోపాల ప్రమాదాన్ని తగ్గిస్తుంది.
• కోడ్ నిర్వహణ: క్లయింట్ కోడ్ నుండి వస్తువుల సృష్టిని వేరు చేస్తుంది, ఇది క్లయింట్‌ను ప్రభావితం చేయకుండా ఫ్యాక్టరీని మార్చడం లేదా విస్తరించడం సులభం చేస్తుంది.
• సౌలభ్యం: ఒకే ఇంటర్‌ఫేస్ లేదా అబ్‌స్ట్రాక్ట్ క్లాస్ యొక్క విభిన్న అమలుల మధ్య సులభంగా మారడానికి మిమ్మల్ని అనుమతిస్తుంది.
• తగ్గించిన బాయిలర్‌ప్లేట్: ఫ్యాక్టరీలో పొందుపరచడం ద్వారా వస్తువుల సృష్టి తర్కాన్ని సరళీకృతం చేయవచ్చు.
• మెరుగైన పరీక్షించదగినది: ఫ్యాక్టరీని సులభంగా మాక్ చేయడానికి లేదా స్టబ్ చేయడానికి మిమ్మల్ని అనుమతించడం ద్వారా యూనిట్ పరీక్షను సులభతరం చేస్తుంది.

సాధారణ ఫ్యాక్టరీ నమూనాను అమలు చేయడం

సాధారణ ఫ్యాక్టరీ నమూనా యొక్క అమలులో సాధారణంగా సృష్టించవలసిన వస్తువుల కోసం ఒక ఇంటర్‌ఫేస్ లేదా అబ్‌స్ట్రాక్ట్ క్లాస్‌ను నిర్వచించడం, ఆపై టైప్ భద్రతను నిర్ధారించడానికి సాధారణీకరణాలను ఉపయోగించే ఫ్యాక్టరీ క్లాస్‌ను సృష్టించడం ఉంటుంది. ఇక్కడ C#, Java మరియు TypeScript లలో ఉదాహరణలు ఉన్నాయి.

C# లో ఉదాహరణ

కాన్ఫిగరేషన్ సెట్టింగ్‌ల ఆధారంగా మీరు వివిధ రకాల లాగర్‌లను సృష్టించాల్సిన అవసరం ఉన్న దృశ్యాన్ని పరిగణించండి.

// లాగర్‌ల కోసం ఒక ఇంటర్‌ఫేస్‌ను నిర్వచించండి
public interface ILogger
{
    void Log(string message);
}

// లాగర్‌ల యొక్క కాంక్రీట్ అమలులు
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Console: {message}");
    }
}

public class FileLogger : ILogger
{
    private readonly string _filePath;

    public FileLogger(string filePath)
    {
        _filePath = filePath;
    }

    public void Log(string message)
    {
        File.AppendAllText(_filePath, $"{DateTime.Now}: {message}\n");
    }
}

// సాధారణ ఫ్యాక్టరీ ఇంటర్‌ఫేస్
public interface ILoggerFactory
{
    T CreateLogger() where T : ILogger;
}

// కాంక్రీట్ ఫ్యాక్టరీ అమలు
public class LoggerFactory : ILoggerFactory
{
    public T CreateLogger() where T : ILogger
    {
        if (typeof(T) == typeof(ConsoleLogger))
        {
            return (T)(ILogger)new ConsoleLogger();
        }
        else if (typeof(T) == typeof(FileLogger))
        {
            // ఆదర్శవంతంగా, కాన్ఫిగరేషన్ నుండి ఫైల్ మార్గాన్ని చదవండి
            return (T)(ILogger)new FileLogger("log.txt");
        }
        else
        {
            throw new ArgumentException($"Unsupported logger type: {typeof(T).Name}");
        }
    }
}

// వినియోగం
public class MyApplication
{
    private readonly ILogger _logger;

    public MyApplication(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger();
    }

    public void DoSomething()
    {
        _logger.Log("Doing something...");
    }
}

ఈ C# ఉదాహరణలో, ILoggerFactory ఇంటర్‌ఫేస్ మరియు LoggerFactory క్లాస్ CreateLogger పద్ధతి సరైన రకం యొక్క వస్తువును అందిస్తుందని నిర్ధారించడానికి సాధారణీకరణాలను ఉపయోగిస్తాయి. where T : ILogger పరిమితి ILogger ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతులను మాత్రమే ఫ్యాక్టరీ ద్వారా సృష్టించవచ్చని నిర్ధారిస్తుంది.

జావాలో ఉదాహరణ

వివిధ రకాల ఆకారాలను సృష్టించడానికి సాధారణ ఫ్యాక్టరీ నమూనా యొక్క జావా అమలు ఇక్కడ ఉంది.

// ఆకారాల కోసం ఒక ఇంటర్‌ఫేస్‌ను నిర్వచించండి
interface Shape {
    void draw();
}

// ఆకారాల కాంక్రీట్ అమలులు
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

// సాధారణ ఫ్యాక్టరీ ఇంటర్‌ఫేస్
interface ShapeFactory {
     T createShape(Class shapeType);
}

// కాంక్రీట్ ఫ్యాక్టరీ అమలు
class DefaultShapeFactory implements ShapeFactory {
    @Override
    public  T createShape(Class shapeType) {
        try {
            return shapeType.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new IllegalArgumentException("Cannot create shape of type: " + shapeType.getName(), e);
        }
    }
}

// వినియోగం
public class Main {
    public static void main(String[] args) {
        ShapeFactory factory = new DefaultShapeFactory();
        Circle circle = factory.createShape(Circle.class);
        circle.draw();
        Square square = factory.createShape(Square.class);
        square.draw();
    }
}

ఈ జావా ఉదాహరణలో, ShapeFactory ఇంటర్‌ఫేస్ మరియు DefaultShapeFactory క్లాస్ క్లయింట్ సృష్టించవలసిన Shape యొక్క ఖచ్చితమైన రకాన్ని పేర్కొనడానికి సాధారణీకరణాలను ఉపయోగిస్తాయి. Class మరియు ప్రతిబింబం ఉపయోగించడం ఫ్యాక్టరీలోనే ప్రతి తరగతి గురించి స్పష్టంగా తెలుసుకోవలసిన అవసరం లేకుండా విభిన్న ఆకారాల రకాలను ఇన్‌స్టాన్స్‌యేట్ చేయడానికి సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది.

టైప్‌స్క్రిప్ట్‌లో ఉదాహరణ

వివిధ రకాల నోటిఫికేషన్‌లను సృష్టించడానికి టైప్‌స్క్రిప్ట్ అమలు ఇక్కడ ఉంది.

// నోటిఫికేషన్‌ల కోసం ఒక ఇంటర్‌ఫేస్‌ను నిర్వచించండి
interface INotification {
    send(message: string): void;
}

// నోటిఫికేషన్‌ల యొక్క కాంక్రీట్ అమలులు
class EmailNotification implements INotification {
    private readonly emailAddress: string;

    constructor(emailAddress: string) {
        this.emailAddress = emailAddress;
    }

    send(message: string): void {
        console.log(`Sending email to ${this.emailAddress}: ${message}`);
    }
}

class SMSNotification implements INotification {
    private readonly phoneNumber: string;

    constructor(phoneNumber: string) {
        this.phoneNumber = phoneNumber;
    }

    send(message: string): void {
        console.log(`Sending SMS to ${this.phoneNumber}: ${message}`);
    }
}

// సాధారణ ఫ్యాక్టరీ ఇంటర్‌ఫేస్
interface INotificationFactory {
    createNotification(): T;
}

// కాంక్రీట్ ఫ్యాక్టరీ అమలు
class NotificationFactory implements INotificationFactory {
    createNotification(): T {
        if (typeof T === typeof EmailNotification) {
            return new EmailNotification("test@example.com") as T;
        } else if (typeof T === typeof SMSNotification) {
            return new SMSNotification("+15551234567") as T;
        } else {
            throw new Error(`Unsupported notification type: ${typeof T}`);
        }
    }
}

// వినియోగం
const factory = new NotificationFactory();
const emailNotification = factory.createNotification();
emailNotification.send("Hello from email!");

const smsNotification = factory.createNotification();