in Web-Anwendung oop sollte riesigen Benutzerobjekt haben Aktionen oder Aktionsklassen erhalten einen Benutzer?

Question

Die Objekte meines Unternehmens benötigen Sicherheit von Programmierern, die Beziehungen zusammenschrauben, so dass wir einen Benutzernamen für jedes Objekt benötigen. Wir möchten immer noch alten Code umgestalten und aufräumen und haben eine Struktur um diese herum. Unser auf dem Gehen Argument einig glauben, die CRUD wie Aktionen auf einem Objekt sollte von einem Benutzer in Beispiel

$user = new User('usernameExample'); 
$profileData = $user->getProfile(12313); 
echo json_encode($profileData); 
$ID = $user->createProfile($_POST); 
$user->updateProfile($_POST); 
$user->refreshProfile(12321394); 
$user->deleteProfile(234242); 

$user = new User('usernameExample'); 
$batches = $user->getGroupList(); 
$user->updateGroup($_POST); 
$user->deleteGroup(23242); 
$newBatchID = $user->createGroup(); 

$user = new User('usernameExample'); 
$user->addSubuser($_POST); 
$user->deleteSubuser('usernameExample'); 
$user->updateSubuser($_POST); 
$user->getSubusers(); 

$user new User('usernameExample'); 
$user->updateSetting($_POST); 

Wirft in 50 Methoden oder so für Benutzerobjekt zu viel oder die Dinge sein sollten auflösen pro Basis aufgerufen werden und einen Benutzernamen oder ein unveränderliches Benutzerobjekt übergeben? Beispiel unten

$userProfiles = new UserProfile('usernameExample'); 
$profileData = $userProfile->getProfile(12313); 

Answer 1

viel Funktionalität in Ihre Business-Objekte Stuffing Interaktion mit anderen Objekten zu handhaben kann besonders hässlich schnell, erhalten, wenn Sie mit komplexen Beziehungen und Logik zu tun hat.

Der erste Schritt über diese Art von Architektur hinaus ist die Implementierung von Serviceklassen, um die Interaktion zwischen Ihren Objekten zu erleichtern.

Beachten Sie Folgendes:

<?php 
/** 
* Class UserBasedServiceAbstract 
* Base class for our user based services. All services must be instantiated 
* with a valid user 
*/ 
abstract class UserBasedServiceAbstract 
{ 
    protected $user; 

    /** 
    * UserBasedServiceAbstract constructor. 
    * @param User $user 
    * @throws Exception 
    */ 
    public function __construct(User $user) 
    { 
     if($user->isNew()) 
     { 
      throw new Exception('User must be persisted before doing anything useful with it'); 
     } 

     $this->user = $user; 
    } 

    /** 
    * @param $message 
    */ 
    protected function logAction($message) 
    { 
     $formattedMessage = (is_array($message)) ? json_encode($message):$message; 
     echo 'User action for '.$this->user->getUsername().': '.$formattedMessage; 
    } 
} 

class GroupService extends UserBasedServiceAbstract 
{ 
    /** 
    * Get a list of groups that the current user belongs to 
    * @return array 
    */ 
    public function getGroupList() 
    { 
     // We always have a reference to our user 
     $userId = $this->user->getId(); 

     $this->logAction('Getting group list'); 

     //Fetch groups for user 
     $groupList = []; 

     return $groupList; 
    } 

    /** 
    * Update the specified group if the current user has permission to do so 
    * @param Group $group 
    * @param array $params 
    * @throws Exception 
    */ 
    public function updateGroup(Group $group, array $params) 
    { 
     if(!$this->_userCanUpdateGroup()) 
     { 
      throw new Exception('User does not have permission to update this group'); 
     } 

     $this->logAction('Updating group'); 

     //update group 
    } 

    /** 
    * Delete the specified group if the current user has permission to do so 
    * @param Group $group 
    * @throws Exception 
    */ 
    public function deleteGroup(Group $group) 
    { 
     if(!$this->_userCanDeleteGroup($group)) 
     { 
      throw new Exception('User does not have permission to delete this group'); 
     } 

     $this->logAction('Deleting group'); 

     //delete group 
    } 

    /** 
    * Determine whether or not the current user can delete the specified group 
    * @param Group $group 
    * @return bool 
    * @throws Exception 
    */ 
    private function _userCanDeleteGroup(Group $group) 
    { 
     //Maybe there is some logic we need to check on the group before we go further 
     if(!$group->isDeletable()) 
     { 
      throw new Exception('This group cannot be deleted'); 
     } 

     // Implement some user-specific logic 
     return ($this->user->hasPermission('group_admin') && $this->user->getKarma()>100); 
    } 

    /** 
    * Determine whether or not the current user can update the specified group 
    * @return bool 
    */ 
    private function _userCanUpdateGroup() 
    { 
     // Implement some user-specific logic 
     return ($this->user->hasPermission('group_moderator') && $this->user->getKarma()>50); 
    } 
} 

Sie erstellen eine abstrakte Klasse mit den gemeinsamen Funktionen, die Sie brauchen, und um zu überprüfen, und einen Verweis auf Ihre Benutzer zu halten. Alle Ihre Dienste, die auf einer Benutzerinstanz basieren müssen, erweitern diese Klasse und erleichtern die Interaktion zwischen dem Benutzerobjekt und den zugehörigen Objekten. Alle Ihre Logik um Berechtigungen geht in diese Serviceklassen. Dies ist viel wartungsfreundlicher, als all das in die Geschäftsobjekte zu füllen.

Dieser Ansatz kann Sie weit bringen. OO-Astronauten könnten dir sagen, dass du Designmuster wie das Mediator-Muster für diese Art von Dingen betrachten sollst, und das kann definitiv gut funktionieren, aber es gibt immer einen Kompromiss zwischen Komplexität und Benutzerfreundlichkeit. Für die meisten CRUD-Anwendungen halte ich diesen serviceorientierten Ansatz für den idealen Ausgangspunkt.