重构以符合DRY原则

Question

I am trying to find a way to refactor this code so I don't to repeat same code in many places. I am looking for DRY principle.

This is an example of createDaemon() method.

function createDaemon($server, $command, $user)
    {
        try {
            DB::beginTransaction();

            $model = $server->daemons()->create([
                'command' => $command,
                'user' => $user,
            ]);

            $shell = $this->getCommand('add-daemon', [
                'daemonId' => $daemon->id,
                'command' => $command,
                'user' => $user,
            ]);

            $this->pushToQueue($model, $shell);

            DB::commit();
        } catch (\Exception $e) {
            DB::rollback();
            throw $e;
        }

        return $model;
    }

This is another example of createRule() in another class, as you can see the code is almost the same. How to refactor this into DRY principle - would you create a new method or class to do the same logic?

   public function createRule($server, $name, $port, $ipAddress = null)
    {
        try {
            DB::beginTransaction();

            $model = $server->rule()->create([
                'name' => $name,
                'port' => $port,
            ]);

            $shell = $this->getCommand('rule', [
                'port' => $port,
                'ipAddress' => $ipAddress
            ]);

            $this->pushToQueue($model, $shell);

            DB::commit();
        } catch (\Exception $e) {
            DB::rollback();
            throw $e;
        }

        return $model;
    }

Answer 1

I think I would create one common method like this:

public function createGeneralRule(Closure $closure)
{
    try {
        DB::beginTransaction();

        [$model, $shell] = $closure();

        $this->pushToQueue($model, $shell);

        DB::commit();
    } catch (\Exception $e) {
        DB::rollback();
        throw $e;
    }

    return $model;
}

and now you can do use it like this:

function createDaemon($server, $command, $user)
{
    return $this->createGeneralRule(function() use ($server, $command, $user) {
        $model = $server->daemons()->create([
            'command' => $command,
            'user' => $user,
        ]);

        $shell = $this->getCommand('add-daemon', [
            'daemonId' => $daemon->id,
            'command' => $command,
            'user' => $user,
        ]);

        return [$model, $shell];
     }
}

and

public function createRule($server, $name, $port, $ipAddress = null)
{
    return $this->createGeneralRule(function() use ($server, $name, $port, $ipAddress) {
        $model = $server->rule()->create([
            'name' => $name,
            'port' => $port,
        ]);

        $shell = $this->getCommand('rule', [
            'port' => $port,
            'ipAddress' => $ipAddress
        ]);

        return [$model, $shell];
     }
 }

Of course you could also use classes, but it really depends how many times you are going to reuse this code and what flexibility do you really need.

Using classes it could be something like this:

abstract class Rule
{
    public function process()
    {
        try {
            DB::beginTransaction();

            $model = $this->model();
            $shell = $this->shell();

            $this->pushToQueue($model, $shell);

            DB::commit();
        } catch (\Exception $e) {
            DB::rollback();
            throw $e;
        }

        return $model;
    }

    protected function getCommand($name, $data)
    {
        // here you put implementation you had before of getCommand
    }

    abstract protected function model();

    abstract protected function shell();
}

class Deamon extends Rule
{
    protected $server;
    protected $command;
    protected $user;

    public function __construct($server, $command, $user)
    {
        $this->server = $server;
        $this->command = $command;
        $this->user = $user;
    }

    protected function model()
    {
        return $this->server->daemons()->create([
            'command' => $this->command,
            'user' => $this->user,
        ]);
    }

    protected function shell()
    {
        return $this->getCommand('add-daemon', [
            'daemonId' => $daemon->id, // this is unknown, should be passed in constructor?
            'command' => $this->command,
            'user' => $this->user,
        ]);
    }
}

and in your controller you would use it like this:

(new Deamon($server, $command, $user))->process();

Just in case - keep in mind you have $deamon variable which is not defined (it's not defined also in your controller)

Answer 2

Extends

You can make them extend the same base class:

class foo{
     public function myMethod(){}
}

class bar extends foo{ }

class biz extends foo{ }

Now both subclasses have the method myMethod

Trait

You can use a trait for the shared functionality

trait foo{
   public function myMethod(){}
}

class bar{
  use foo;
}

class biz{ 
  use foo;
}

As for the actual functionality I would break it down into 3 methods: I was going to write something on it but I see @Marcin Nabiałek, has a good answer for that part. I just wanted to cover how to structure the classes in order to re-use a common method.

Cheers.