Comment la pratique, SOLIDE principe de la programmation orientée objet design?

Tout d'abord, le solide n'est pas UN principe, il représente 5 principes différents:

• SRP (Principe de Responsabilité Unique): votre classe doit avoir qu'un seul bien défini responsabilité;
• OCP (Ouvert-Fermé le Principe): votre classe doit être ouvert pour l'extension, mais fermées pour la modification;
• LSP (Liskov du Principe de Substitution): celui-ci vous guide pour décider si ou de ne pas utiliser une relation d'héritage entre la classe A et B. L'héritage est adapté chaque fois que tous les objets d'une classe dérivée B peuvent être remplacés par des objets de leur classe parent A sans aucune perte de fonctionnalité;
• FAI (Interface Ségrégation Principe): aucun client ne devrait être obligés de recourir à des méthodes qui ne l'utilisez pas;
• DIP (Injection de Dépendances/Inversion): les états que le niveau élevé des modules ne doit pas dépendre de faible niveau de modules.

Ces principes sont des guides, mais cela ne signifie pas que vous avez à les utiliser strictement à chaque fois.

À partir de votre description, je peux voir votre principale difficulté est de penser OO. Vous êtes toujours penser à comment faire les choses et c'est un de procédure mentalité. Mais en programmation orientée objet, il est plus important de choisir qui va faire ces choses.

De la pensée à propos de DI, à l'aide de votre exemple, nous allons voir votre scénario:

public class AttendanceService {
    //other stuff...

    public boolean scanEmployeeId() {
        //The scanning is made by an barcode reader on employee's name tag
    }
}

Quel est le problème ici?

Bien, tout d'abord, ce code viole PRS:
Que faire si le processus d'authentification des changements? Si la société a décidé que les balises de nom sont d'insécurité et d'installer un système de reconnaissance biométrique de? Eh bien, il y a ici une raison pour votre classe, mais la classe ne fait pas seulement de l'authentification, il fait d'autres choses, donc, il y aura une autre des raisons pour qu'il change. PRS que vos classes devraient avoir juste UNE raison de changer.

Elle porte également atteinte à OCP:
Que faire si il y a une autre méthode d'authentification disponible, et je veux être en mesure de servir comme je le souhaite? Je ne peux pas. Pour modifier la méthode auth, j'ai modifier la classe.

Il viole FAI:
Pourquoi un ServiceAttendance objet a une méthode pour l'employé d'authentification si il doit juste fournir un service de présence?

---

Nous allons l'améliorer un peu:

public class BarCodeAuth {
    public boolean authenticate() {
        //Authenticates...
    }
}

public class AttendanceService {
    private BarCodeAuth auth;
    public AttendanceClass() {
        this.auth = new BarCodeAuth();
    }

    public void doOperation() {
        if(this.auth.authenticate()) {
           //do stuff..
        }
    }
}

Maintenant, c'est un peu mieux. Nous avons résolu les problèmes avec PRS et FAI, mais si vous pensez mieux, c'viole OCP et maintenant viole DIP. Le problème est que AttendanceService est étroitement couplé avec BarCodeAuth. Je ne peux toujours pas changer la méthode auth sans toucher AttendanceService.

Maintenant, nous allons appliquer OCP et DIP ensemble:

public interface AuthMethod {
    public boolean authenticate();
}

public class BarCodeAuth implements AuthMethod {
    public boolean authenticate() {
        //Authenticates...
    }
}

public class BiometricAuth implements AuthMethod {
    public boolean authenticate() {
        //Authenticates...
    }
}

public class FooBarAuth implements AuthMethod {
    public boolean authenticate() {
        //Authenticates...
    }
}

public class AttendanceClass {
    private AuthMethod auth;
    public AttendanceClass(AuthMethod auth) {
        this.auth = auth;
    }

    public void doOperation() {
        if(this.auth.authenticate()) {
           //do stuff..
        }
    }
}

Maintenant je peux le faire:

new AttendanceClass(new BarCordeAuth());
new AttendanceClass(new BiometricAuth());

À modifier le comportement, je n'ai pas besoin de toucher à la classe. Si une autre méthode auth s'affiche, j'ai juste besoin de le mettre en œuvre, le respect de l'interface et est prêt à l'emploi (rappelez-vous OCP?). Cela est dû à moi d'être à l'aide de DIP sur ServiceAttendance. Bien qu'il a besoin d'une méthode d'authentification, il n'est pas de sa responsabilité d'en créer un. En effet, pour cet objet, il n'est pas question de la méthode d'authentification, il suffit de savoir si l'appelant (utilisateur) est ou n'est pas autorisé à faire ce qu'il essaie de faire.

Ce est tout au sujet de DIP est: vos composants doivent dépendre des abstractions, pas implémentations.

OriginalL'auteur Henrique Barcelos

Tout d'abord, pensez à différentes parties de la fréquentation du système.
De l'interface utilisateur, finger print scanner, dépôt de bases de données, processus de connexion et de flux de travail.
Pour la conception de ce système, nous pouvons commencer à concevoir des pièces dans l'isolement et de les connecter en tant que système.

Une conception grossière pourrait être autour des parties suivantes du système:

• Scanner d'empreintes digitales et l'Auditeur
• La Fréquentation Du Service
• Employé Référentiel
• Connexion Référentiel
• Interface Utilisateur
• Présence De Flux De Travail De Contrôleur De
• D'Empreintes Digitales Signature

Dans le code suivant de la liste de certains aspects des principes de conception sera visible déjà:

• SRP - Une entité est responsable pour un emploi
• LoD - Loi de Déméter - Seulement parler à vos amis proches. Vous remarquerez Contrôleur ne savez rien à propos de dépôts.
• DbC (Design by contract) - Travail à l'aide d'interfaces
• Utiliser l'injection de dépendance et Cio - constructeur d'injection et de la méthode des injections
• FAI (Interface Ségrégation Principe) - les Interfaces sont maigres
• OCP - Remplacer les méthodes d'interface dans les classes dérivées ou de passer les différents la mise en œuvre injecté interfaces peuvent étendre le comportement sans la nécessité de modifier la classe.

Basé sur ce bien pensé, le système pourrait fonctionner comme ceci:

[Vous pouvez continuer à l'améliorer et ajouter manquant de logique, je suis en fournissant un moyen très rapide de conception contour avec une brève mise en œuvre.]

Exemple De Code

interface IAttedanceController
{
    run();
}

interface IFingerprintHandler
{
    void processFingerprint(IFingerprintSignature fingerprintSignature);
}

interface IFingerprintScanner
{
    void run(IFingerprintHandler fingerprintHandler);
}

interface IAttendanceService
{
    void startService();
    void stopService();
    bool attempEmployeeLogin(IFingerprintSignature fingerprintSignature);
    string getFailureMessage();
}

interface ILoginRepository
{
    bool loginEmployee(IEmployee employee, DateTime timestamp);
    void open();
    void close();
}

interface IEmployeeRepository
{
    IEmployee findEmployee(IFingerprintSignature fingerprintSignature);
    void open();
    void close();
}

//-----------------------------------------

class AttendanceService : IAttendanceService
{
    private IEmployeeRepository _employeeRepository;
    private ILoginRepository _loginRepository;
    private string _failureMessage;

    public class AttendanceService(
        IEmployeeRepository employeeRepository,
        ILoginRepository loginRepository)
    {
        this._employeeRepository = employeeRepository;
        this._loginRepository = loginRepository;
    }

    public bool attempEmployeeLogin(IFingerprintSignature fingerprintSignature)
    {
        IEmployee employee = this._employeeRepository.findEmployee(fingerprintSignature);

        if(employee != null)
        {
            //check for already logged in to avoid duplicate logins..

            this._loginRepository.loginEmployee(employee, DateTime.Now);
            //or create a login record with timestamp and insert into login repository

            return true;
        }
        else
        {
            this._failureMessage = "employee not found";
            return false;
        }
    }

    public string getFailureMessage()
    {
        return "reason for failure";
    }

    public void startService()
    {
        this._employeeRepository.open();
        this._loginRepository.open();
    }

    public void stopService()
    {
        this._employeeRepository.close();
        this._loginRepository.close();
    }
}

//-----------------------------------------

class AttendanceController : IAttedanceController, IFingerprintHandler
{
    private ILoginView _loginView;
    private IAttendanceService _attedanceService;
    private IFingerprintScanner _fingerprintScanner;

    public AttendanceController(
        ILoginView loginView,
        IAttendanceService attendanceService,
        IFingerprintScanner fingerprintScanner)
    {
        this._loginView = loginView;
        this._attedanceService = attedanceService;
        this._fingerprintScanner = fingerprintScanner;
    }

    public void run()
    {
        this._attedanceService.startService();
        this._fingerprintScanner.run(this);
        this._loginView.show();
    }

    public void IFingerprintHandler.processFingerprint(IFingerprintSignature fingerprintSignature)
    {
        if(this._attedanceService.login(fingerprintSignature))
        {
        this._loginView.showMessage("Login successful");
        }
        else
        {
        string errorMessage = string getFailureMessage();
        this._loginView.showMessage("errorMessage");
        }

        //on return the fingerprint monitor is ready to take another finter print
    }
}

//-----------------------------------------

App.init()
{
    //Run app bootstrap
    //Initialize abstract factories or DI containers

    IAttedanceController attedanceController = DIContainer.resolve("AttedanceController");
    attedanceController.run();
}

//-----------------------------------------

OriginalL'auteur bhavik shah