分类目录归档：PHP

PHP

laravel/lumen 数据库和 Eloquent 浅析

2016年7月10日 chen

一、 `DatabaseServiceProvider` 服务提供者

主要做了一下几件事：
– 初始化Model
– 注册Eloquent工厂
– 注册可队列化实体解析器实现
– 注册DB工厂
– 注册DB
– 注册DB连接

1、初始化`Model`

    Model::clearBootedModels();

    public static function clearBootedModels()
    {
        static::$booted = [];
        static::$globalScopes = [];
    }

Model::clearBootedModels();

public static function clearBootedModels()

{

static::$booted = [];

static::$globalScopes = [];

}

主要清空初始化的类库和全局作用域。

2、注册`Eloquent`工厂

    protected function registerEloquentFactory()
    {
        $this->app->singleton(FakerGenerator::class, function () {
            return FakerFactory::create();
        });

        $this->app->singleton(EloquentFactory::class, function ($app) {
            $faker = $app->make(FakerGenerator::class);

            return EloquentFactory::construct($faker, database_path('factories'));
        });
    }

protected function registerEloquentFactory()

{

$this->app->singleton(FakerGenerator::class, function () {

return FakerFactory::create();

});

$this->app->singleton(EloquentFactory::class, function ($app) {

$faker = $app->make(FakerGenerator::class);

return EloquentFactory::construct($faker, database_path('factories'));

});

}

作用暂未理解。
从代码中可以看到框架首先绑定了FakerGenerator::class数据伪造生成类，将其初始化到EloquentFactory中，并却传入了database_path('factories'),那么可以猜到大致作用为数据伪造器。

todo：理解EloquentFactory

3、注册可队列化实体解析器实现

    protected function registerQueueableEntityResolver()
    {
        $this->app->singleton('Illuminate\Contracts\Queue\EntityResolver', function () {
            return new QueueEntityResolver;
        });
    }

protected function registerQueueableEntityResolver()

{

$this->app->singleton('Illuminate\Contracts\Queue\EntityResolver', function () {

return new QueueEntityResolver;

});

}

用作暂时未理解。

todo：理解QueueEntityResolver

4、注册`DB工厂`

        $this->app->singleton('db.factory', function ($app) {
            return new ConnectionFactory($app);
        });

$this->app->singleton('db.factory', function ($app) {

return new ConnectionFactory($app);

});

ConnectionFactory通过配置创建不同的的链接。
以mysql为例，框架会通过MySqlConnector为我们创建一个数据库连接。MySqlConnector创建出来的其实就是PDO。

另外，当我们开启主从分离的时候，ConnectionFactory还会根据相应的规则，创建读链接或者是写链接。

5、注册`DB`

        $this->app->singleton('db', function ($app) {
            return new DatabaseManager($app, $app['db.factory']);
        });

$this->app->singleton('db', function ($app) {

return new DatabaseManager($app, $app['db.factory']);

});

DatabaseManager负责管理ConnectionFactory创建出来的连接。
并且对外提供connection（创建）、purge（清除）、disconnect（断开）、reconnect（重连）方法，让外部进行统一调用。

6、注册`DB连接`

        $this->app->bind('db.connection', function ($app) {
            return $app['db']->connection();
        });

$this->app->bind('db.connection', function ($app) {

return $app['db']->connection();

});

app('db.connection')后，返回一个有ConnectionFactory创建DatabaseManager负责管理的PDO连接。

Connection对外提供select、insert、update、delete、commit、rollBack、beginTransaction等方法，提供对数据库的基本操作。

二、 `Eloquent\Model`、`Eloquent\Builder`、`Query\Builder`、`Schema\Builder`

Eloquent是框架提供的ORM 。

1、`Eloquent\Model`

Eloquent\Model是一个抽象类。模型必须继承它。Eloquent\Model类的主要作用，也是抽象类的主要作用是对子类所有功能的的一个抽象归纳。

主要抽象功能有：

全局作用域管理，比如方法：addGlobalScope、hasGlobalScope、getGlobalScope、getGlobalScopes等。
事件管理，比如方法：observe、flushEventListeners、registerModelEvent、getObservableEvents、setObservableEvents等。
读写分离链接的主动选择，比如方法：on、onWriteConnection
关联关系管理，比如方法：hasOne、morphOne、belongsTo、morphTo、hasMany、hasManyThrough等。
模型输入/输出数据管理，比如方法：guard系列方法（负责输入时过滤不想要的字段）、fill系列方法输入方法、getAttribute系列方法（负责输出时过滤敏感字段，格式化输出）
数据操作方法，比如create、update、push、save、destroy、destroy、delete等。这些方法提供了常用的数据库操作方法，并且在内部封装了事件机制。

个人感觉Eloquent\Model封装了比较多的东西，过于庞大，功能比较复杂，但是好处也是功能齐全，简便操作。可以更具自己要求是否开启Eloquent，为了简便开启Eloquent，抑或是为了追求性能放弃Eloquent。

2、`Eloquent\Builder`

Eloquent\Builder 在我看来才是真正的 Eloquent的核心， Eloquent\Model只是对其提供的方法进行封装和管理。

比如我们调用Model\User::first()方法，其实是通过Eloquent\Model的__callStatic方法或者__call方法转发到了Eloquent\Builder上面。

我们需要注意到，通过Eloquent\Model每一次对数据的操作都会创建一个Eloquent\Builder。主要作用是一次请求封装在一个上下文中，我们可以很好的对其控制。好处有：

防止请求数据被污染
可以很好的管理内存

同理，http请求访问laravel\lumen框架，框架都会创建一个request也是为了如此。

还有一个细节需要注意的是Eloquent\Builder中的$passthru变量。Eloquent\Builder的__call方法中，会判断如果请求放在存在于这个变量中的的时候，会返回Query\Builder，反之返回他自己Eloquent\Builder。

3、 `Query\Builder`

Query\Builder 的作用就是存储本次数据库操作的基本操作。并且提供toSql方法，调用Query\Grammars\Grammar类来生成SQL语句。最后将SQL语句和绑定参数传给Connection类进行数据库操作。

Eloquent\Model在创建Eloquent\Builder的时候，会同时创建一个QueryBuilder，做一对一对于，所以QueryBuilder也可以很好的做好隔离工作。

    public function newQueryWithoutScopes()
    {
        $builder = $this->newEloquentBuilder(
            $this->newBaseQueryBuilder()
        );

        // Once we have the query builders, we will set the model instances so the
        // builder can easily access any information it may need from the model
        // while it is constructing and executing various queries against it.
        return $builder->setModel($this)->with($this->with);
    }


    protected function newBaseQueryBuilder()
    {
        $conn = $this->getConnection();

        $grammar = $conn->getQueryGrammar();

        return new QueryBuilder($conn, $grammar, $conn->getPostProcessor());
    }

public function newQueryWithoutScopes()

{

$builder = $this->newEloquentBuilder(

$this->newBaseQueryBuilder()

);

// Once we have the query builders, we will set the model instances so the

// builder can easily access any information it may need from the model

// while it is constructing and executing various queries against it.

return $builder->setModel($this)->with($this->with);

}

protected function newBaseQueryBuilder()

{

$conn = $this->getConnection();

$grammar = $conn->getQueryGrammar();

return new QueryBuilder($conn, $grammar, $conn->getPostProcessor());

}

4、 `Schema\Builder`

Schema\Builder是框架对数据库表操作的封装。

比如数据库的新增、修改、删除、索引、外键的管理等。

三、其他

1、 UML类图

PHP

laravel/lumen —— Artisan Console 命令行

2016年5月28日 chen

1、简介

laravel和lumen提供了artisan命令行接口，以便我们来进行命令行操作。

我们可以通过php artisan list来查看框架为我们提供了哪些接口。

root@chen-Ubuntu:/data/test/lumen_5_2# php artisan list
Laravel Framework version Lumen (5.2.4) (Laravel Components 5.2.*)

Usage:
  command [options] [arguments]

Options:
  -h, --help            Display this help message
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi            Force ANSI output
      --no-ansi         Disable ANSI output
  -n, --no-interaction  Do not ask any interactive question
      --env[=ENV]       The environment the command should run under.
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:
  help              Displays help for a command
  list              Lists commands
  migrate           Run the database migrations
 cache
  cache:clear       Flush the application cache
 db
  db:seed           Seed the database with records
 make
  make:migration    Create a new migration file
 migrate
  migrate:install   Create the migration repository
  migrate:refresh   Reset and re-run all migrations
  migrate:reset     Rollback all database migrations
  migrate:rollback  Rollback the last database migration
  migrate:status    Show the status of each migration
 queue
  queue:failed      List all of the failed queue jobs
  queue:flush       Flush all of the failed queue jobs
  queue:forget      Delete a failed queue job
  queue:listen      Listen to a given queue
  queue:restart     Restart queue worker daemons after their current job
  queue:retry       Retry a failed queue job
  queue:work        Process the next job on a queue
 schedule
  schedule:run      Run the scheduled commands

root@chen-Ubuntu:/data/test/lumen_5_2# php artisan list

Laravel Framework version Lumen (5.2.4) (Laravel Components 5.2.*)

Usage:

command [options] [arguments]

Options:

-h, --help Display this help message

-q, --quiet Do not output any message

-V, --version Display this application version

--ansi Force ANSI output

--no-ansi Disable ANSI output

-n, --no-interaction Do not ask any interactive question

--env[=ENV] The environment the command should run under.

-v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:

help Displays help for a command

list Lists commands

migrate Run the database migrations

cache

cache:clear Flush the application cache

db:seed Seed the database with records

make

make:migration Create a new migration file

migrate

migrate:install Create the migration repository

migrate:refresh Reset and re-run all migrations

migrate:reset Rollback all database migrations

migrate:rollback Rollback the last database migration

migrate:status Show the status of each migration

queue

queue:failed List all of the failed queue jobs

queue:flush Flush all of the failed queue jobs

queue:forget Delete a failed queue job

queue:listen Listen to a given queue

queue:restart Restart queue worker daemons after their current job

queue:retry Retry a failed queue job

queue:work Process the next job on a queue

schedule

schedule:run Run the scheduled commands

也可以用help命令来查看，如何使用命令。

root@chen-Ubuntu:/data/test/lumen_5_2# php artisan help cache:clear 
Usage:
  cache:clear [<store>]

Arguments:
  store                 The name of the store you would like to clear.

Options:
  -h, --help            Display this help message
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi            Force ANSI output
      --no-ansi         Disable ANSI output
  -n, --no-interaction  Do not ask any interactive question
      --env[=ENV]       The environment the command should run under.
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Help:
 Flush the application cache

root@chen-Ubuntu:/data/test/lumen_5_2# php artisan help cache:clear

Usage:

cache:clear [<store>]

Arguments:

store The name of the store you would like to clear.

Options:

-h, --help Display this help message

-q, --quiet Do not output any message

-V, --version Display this application version

--ansi Force ANSI output

--no-ansi Disable ANSI output

-n, --no-interaction Do not ask any interactive question

--env[=ENV] The environment the command should run under.

-v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Help:

Flush the application cache

2、编写命令

laravel的话你可以直接使用命令行来创建命令。

php artisan make:console SayHello

1 2	php artisan make:console SayHello

你还可以使用--command参数来设置终端命令名。

php artisan make:console SayHello --command say:hello

1 2	php artisan make:console SayHello --command say:hello

这样app\Console\Commands目录下就多了SayHello这个类。

变量protected $signature = 'say:hello'; 就是刚刚设置的终端命令名。
变量protected $description = 'a test command, just say hello';是用来描述改名了作用的。

我们可以将我们想做的操作写入handle方法。

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        echo "hello world!!! \n";
    }

/**

* Execute the console command.

* @return mixed

public function handle()

{

echo "hello world!!! \n";

}

接下来我们将该命令注册到App\Console\Kernel中就可以执行了。

/**
     * The Artisan commands provided by your application.
     *
     * @var array
     */
    protected $commands = [
        // Commands\Inspire::class,
        Commands\SayHello::class,
    ];

/**

* The Artisan commands provided by your application.

* @var array

protected $commands = [

// Commands\Inspire::class,

Commands\SayHello::class,

];

通过php artisan list命令可以查看到，say:hello已经注册成功。

...
 say
  say:hello           a test command, just say hello
...

...

say

say:hello a test command, just say hello

...

执行命令

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello
hello world!!!

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

hello world!!!

3、交互命令

3.1、自定义参数

我们可以通过以下方式进行传参。

protected $signature = 'say:hello {user}';

1 2	protected $signature = 'say:hello {user}';

还可以让该参数可选可不选，以及定义默认的可选参数值：

// 选项参数...
say:hello {user?}
// 带默认值的选项参数...
say:hello {user=cc}

// 选项参数...

say:hello {user?}

// 带默认值的选项参数...

say:hello {user=cc}

使用argument方法可以来获取参数

/**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $user = $this->argument('user');

        echo "hello world!!!, i'm {$user} \n";
    }

/**

* Execute the console command.

* @return mixed

public function handle()

{

$user = $this->argument('user');

echo "hello world!!!, i'm {$user} \n";

}

通过php artisan say:hello cc来进行调用

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc
hello world!!!, i'm cc

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc

hello world!!!, i'm cc

还有一种传出方式，可以通过--方式来进行传参。

protected $signature = 'say:hello {user} {--queue}';

1 2	protected $signature = 'say:hello {user} {--queue}';

这种方式我们需要用option方法来接收参数。

/**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $user = $this->argument('user');

        echo "hello world!!!, i'm {$user} \n";

        $queue = $this->option('queue');
        var_dump($queue);
    }

/**

* Execute the console command.

* @return mixed

public function handle()

{

$user = $this->argument('user');

echo "hello world!!!, i'm {$user} \n";

$queue = $this->option('queue');

var_dump($queue);

}

如果--queue开关被传递，其值是true，否则其值是false：

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc --queue
hello world!!!, i'm cc 
bool(true)
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc
hello world!!!, i'm cc 
bool(false)

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc --queue

hello world!!!, i'm cc

bool(true)

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc

hello world!!!, i'm cc

bool(false)

也可以将其改造成传值方式

say:hello {user} {--queue=}

1 2	say:hello {user} {--queue=}

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc --queue=default
hello world!!!, i'm cc 
string(7) "default"

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc --queue=default

hello world!!!, i'm cc

string(7) "default"

简写方式

say:hello {user} {--Q|queue=}

1 2	say:hello {user} {--Q\|queue=}

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc -Q default
hello world!!!, i'm cc 
string(7) "default"

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc -Q default

hello world!!!, i'm cc

string(7) "default"

传数组

say:hello {user} {--Q|queue=} {id*} // argument 方式
// 或则
say:hello {user} {--Q|queue=} {--id*} // option 方式

say:hello {user} {--Q|queue=} {id*} // argument 方式

// 或则

say:hello {user} {--Q|queue=} {--id*} // option 方式

    # argument 方式
    public function handle()
    {
        $user = $this->argument('user');

        echo "hello world!!!, i'm {$user} \n";

        $queue = $this->option('queue');

        var_dump($queue);

        $id = $this->argument('id');

        print_r($id);
    }

# argument 方式

public function handle()

{

$user = $this->argument('user');

echo "hello world!!!, i'm {$user} \n";

$queue = $this->option('queue');

var_dump($queue);

$id = $this->argument('id');

print_r($id);

}

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc -Q default 1 2 3
hello world!!!, i'm cc 
string(7) "default"
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
)

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello cc -Q default 1 2 3

hello world!!!, i'm cc

string(7) "default"

Array

(

[0] => 1

[1] => 2

[2] => 3

)

3.2、输入提示

我们将命令改回say:hello不传参数形式。

输入提示分4种模式：

询问
密码
确认
选择

询问模式

    public function handle()
    {
        $name = $this->ask('What is your name?');
        echo $name;
    }

public function handle()

{

$name = $this->ask('What is your name?');

echo $name;

}

不输入内容，自定会进行重试操作。

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 What is your name?:
 > 



 [ERROR] A value is required.                                                                                           


 What is your name?:
 > cc
cc

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

What is your name?:

[ERROR] A value is required.

What is your name?:

> cc

密码模式

        $password = $this->secret('What is the password?');
        echo $password;

$password = $this->secret('What is the password?');

echo $password;

密码模式输入字符不会再命令行中显示。但是需要开启exec的函数使用权。

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 What is the password?:
 > 


 [ERROR] A value is required.                                                                                           


 What is the password?:
 > 

123

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

What is the password?:

[ERROR] A value is required.

What is the password?:

123

确认模式

        if ($this->confirm('Do you wish to continue? [y|N]')) {
            echo "ok \n";
        } else {
            echo "not ok \n";
        }

if ($this->confirm('Do you wish to continue? [y|N]')) {

echo "ok \n";

} else {

echo "not ok \n";

}

默认为no，只有输入y、Y、yes、YES才算通过

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 Do you wish to continue? [y|N] (yes/no) [no]:
 > 

not ok 
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 Do you wish to continue? [y|N] (yes/no) [no]:
 > 1

not ok 
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 Do you wish to continue? [y|N] (yes/no) [no]:
 > y

ok 
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 Do you wish to continue? [y|N] (yes/no) [no]:
 > yes

ok 
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 Do you wish to continue? [y|N] (yes/no) [no]:
 > Y

ok

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Do you wish to continue? [y|N] (yes/no) [no]:

not ok

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Do you wish to continue? [y|N] (yes/no) [no]:

> 1

not ok

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Do you wish to continue? [y|N] (yes/no) [no]:

> y

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Do you wish to continue? [y|N] (yes/no) [no]:

> yes

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Do you wish to continue? [y|N] (yes/no) [no]:

> Y

选择模式

第一种anticipate用户可以无视给出的提示，自己填写。

        $name = $this->anticipate('What is your name?', ['Taylor', 'Dayle']);
        echo $name, "\n";

$name = $this->anticipate('What is your name?', ['Taylor', 'Dayle']);

echo $name, "\n";

第二种choice，用户必须选择提示中的选项，否则失败。

$name = $this->choice('What is your name?', ['Taylor', 'Dayle'], false);
echo $name, "\n";

$name = $this->choice('What is your name?', ['Taylor', 'Dayle'], false);

echo $name, "\n";

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 What is your name? [Taylor]:
  [0] Taylor
  [1] Dayle
 > 1

Dayle
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 What is your name? [Taylor]:
  [0] Taylor
  [1] Dayle
 > Dayle

Dayle
root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

 What is your name? [Taylor]:
  [0] Taylor
  [1] Dayle
 > 

Taylor

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

What is your name? [Taylor]:

[0] Taylor

[1] Dayle

> 1

Dayle

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

What is your name? [Taylor]:

[0] Taylor

[1] Dayle

> Dayle

Dayle

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

What is your name? [Taylor]:

[0] Taylor

[1] Dayle

Taylor

3.3、不同的输出样式

        # 行样式
        $this->info('Display this on the screen');  
        $this->error('Something went wrong!');      
        $this->line('Display this on the screen');  

        # 表格
        $headers = ['Name', 'Age'];
        $users = [
            ['aa', 11],
            ['bb', 22],
            ['cc', 33],
        ];
        $this->table($headers, $users);

        # 进度条
        $this->output->progressStart(10);

        for($i = 0; $i < 10; $i++) {
            $this->output->progressAdvance();
            sleep(1);
        }
        $this->output->progressFinish();

# 行样式

$this->info('Display this on the screen');

$this->error('Something went wrong!');

$this->line('Display this on the screen');

# 表格

$headers = ['Name', 'Age'];

$users = [

['aa', 11],

['bb', 22],

['cc', 33],

];

$this->table($headers, $users);

# 进度条

$this->output->progressStart(10);

for($i = 0; $i < 10; $i++) {

$this->output->progressAdvance();

sleep(1);

}

$this->output->progressFinish();

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello
Display this on the screen    # 绿字
Something went wrong!         # 红底白字
Display this on the screen    # 白字
+------+-----+
| Name | Age |
+------+-----+
| aa   | 11  |
| bb   | 22  |
| cc   | 33  |
+------+-----+
 10/10 [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓] 100%

root@chen-Ubuntu:/data/test/laravel_5_2# php artisan say:hello

Display this on the screen # 绿字

Something went wrong! # 红底白字

Display this on the screen # 白字

+------+-----+

| Name | Age |

+------+-----+

| aa | 11 |

| bb | 22 |

| cc | 33 |

+------+-----+

10/10 [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓] 100%

4、调用command

我们可以在routes.php中去调用命令。当然，这只是个例子，你可以在任何地方调用它。

Route::get('/foo', function () {
    $exitCode = Artisan::call('say:hello');
    # $exitCode = Artisan::call('say:hello', ['user' => 'cc', '--queue' => 'default']); // 参数
    var_dump($exitCode);
});

Route::get('/foo', function () {

$exitCode = Artisan::call('say:hello');

# $exitCode = Artisan::call('say:hello', ['user' => 'cc', '--queue' => 'default']); // 参数

var_dump($exitCode);

});

PHP

laravel/lumen —— 面向接口编程

2016年4月3日 chen

面向接口编程和面向对象编程并不是平级的，它并不是比面向对象编程更先进的一种独立的编程思想，而是附属于面向对象思想体系，属于其一部分。或者说，它是面向对象编程体系中的思想精髓之一。

多态

类有三大特性：封装、继承、多态。

封装和继承比较好理解，而多态比较抽象，不是很好解释。使用面向接口编程的思想就可以轻松简单的来解释。

多态顾名思义就是多种形态的意思。

以人和动物的例子来说明。人属于动物，可以走路、跑步、吃东西、睡觉、发声等。但是人区别于低级动物的地方是，人有思想。

使用代码来实现：

定义动物接口和人类接口。

interface iAnimal {
    public function walk();
    public function run();
    public function eat();
    public function sleep();
    public function say();
}

interface iHuman {
    public function mind();
}

interface iAnimal {

public function walk();

public function run();

public function eat();

public function sleep();

public function say();

}

interface iHuman {

public function mind();

}

人和猫两个类来实现。

class Cat implements iAnimal {
    public function walk() {
        echo "猫步走路", "\n";
    }

    public function run() {
        echo "猫步奔跑", "\n";
    }

    public function eat() {
        echo "吃鱼", "\n";
    }

    public function sleep() {
        echo "午后，睡在太阳低下，舒服", "\n";
    }

    public function say() {
        echo "喵喵", "\n";
    }
}

class Human implements iAnimal, iHuman {
    public function walk() {
        echo "两条腿走路", "\n";
    }

    public function run() {
        echo "两条腿奔跑", "\n";
    }

    public function eat() {
        echo "可以使用工具吃烹饪出来的美食", "\n";
    }

    public function sleep() {
        echo "睡在床上", "\n";
    }

    public function say() {
        echo "表达思想", "\n";
    }

    public function mind() {
        echo "思考，创造，发明", "\n";
    }
}

class Cat implements iAnimal {

public function walk() {

echo "猫步走路", "\n";

}

public function run() {

echo "猫步奔跑", "\n";

}

public function eat() {

echo "吃鱼", "\n";

}

public function sleep() {

echo "午后，睡在太阳低下，舒服", "\n";

}

public function say() {

echo "喵喵", "\n";

}

class Human implements iAnimal, iHuman {

public function walk() {

echo "两条腿走路", "\n";

}

public function run() {

echo "两条腿奔跑", "\n";

}

public function eat() {

echo "可以使用工具吃烹饪出来的美食", "\n";

}

public function sleep() {

echo "睡在床上", "\n";

}

public function say() {

echo "表达思想", "\n";

}

public function mind() {

echo "思考，创造，发明", "\n";

}

猫饿了可以吃鱼。

$cat = new Cat();
$cat -> eat();

$cat = new Cat();

$cat -> eat();

但是人类高级一点，可以先思考，我要吃什么，怎么烹饪，创造工具，来提升我们生活水平。

$human = new Human();
$human -> mind();
$human -> eat();

$human = new Human();

$human -> mind();

$human -> eat();

这个时候我们可以说，动物有两种形态，一种是人，另外一种是猫。反过来也可以说人是动物，也是思想的高级生物。

怎么在代码上体现呢？

class House {

    public $owner;

    public function __construct(iAnimal $animal) {
        $this -> owner = $animal;
    }

    public function sleep() {
        $this -> owner -> sleep();
    }
}

$catHouse = new House($cat);
$humanHouse = new House($human);

$catHouse -> sleep();
$humanHouse -> sleep();

class House {

public $owner;

public function __construct(iAnimal $animal) {

$this -> owner = $animal;

}

public function sleep() {

$this -> owner -> sleep();

}

$catHouse = new House($cat);

$humanHouse = new House($human);

$catHouse -> sleep();

$humanHouse -> sleep();

房子可以属于猫，或者人。拥有着可以在里面睡觉，使用不同的方式睡觉。

但是实验室，只有有思想能创造能发明的人类才能进入，而猫不行。

class Labs {

    public $human;

    public function __construct(iHuman $human) {
        $this -> human = $human;
    }

    public function mind() {
        $this -> human -> mind();
    }
}

$labs = new Labs($human);
$labs -> mind();

class Labs {

public $human;

public function __construct(iHuman $human) {

$this -> human = $human;

}

public function mind() {

$this -> human -> mind();

}

$labs = new Labs($human);

$labs -> mind();

上面的例子可能有不妥的地方，但是也大致说明了，面向接口编程在多态中的应用。

契约

laravel/lumen框架中提供了契约这个概念。契约是指框架提供的一系列定义核心服务的接口。

比如，框架提供了Illuminate\Contracts\Mail\Mailer契约，那么我们可以通过实现这个契约来定制我们自己的发送邮件代码了。当然别人写的代码，由于他也实现了这个契约，我们可以直接拿过来使用。

laravel/lumen提供了一个Illuminate\Contracts\Config\Repository队列的契约。我们可以通过实现它来定制我们自己的配置操作类。

正常情况，我们都需要写一个package包，发布到packagist.org上去，然后通过composer下载到vendor中去。

但是为了方便起见，我就直接写在了app\Config目录下了。如题如何发布包到packagist.org上去可以参考我之前的博客创建自己的Composer包。

我们需要实现Illuminate\Contracts\Config\Repository中所有的方法。

# app\Config\RedisConfig.php

<?php 

namespace App\Config;


use Illuminate\Redis\Database as RedisDatabase;
use Illuminate\Contracts\Config\Repository as ConfigRepository;

class RedisConfig implements ConfigRepository
{
    public $redis;
    public $connection = 'default';

    public function __construct(RedisDatabase $redis) {
        $this -> redis = $redis;
    }

    /**
     * Determine if the given configuration value exists.
     *
     * @param  string  $key
     * @return bool
     */
    public function has($key) {
        return $this -> getConnection() -> exists($key);
    }

    /**
     * Get the specified configuration value.
     *
     * @param  string  $key
     * @param  mixed   $default
     * @return mixed
     */
    public function get($key, $default = null) {
        $value = $this -> getConnection() -> get($key);
        return is_null($value) ? $default : $value;
    }

    /**
     * Get all of the configuration items for the application.
     *
     * @return array
     */
    public function all() {

    }

    /**
     * Set a given configuration value.
     *
     * @param  array|string  $key
     * @param  mixed   $value
     * @return void
     */
    public function set($key, $value = null) {
        $this -> getConnection() -> set($key, $value);
    }

    /**
     * Prepend a value onto an array configuration value.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return void
     */
    public function prepend($key, $value) {

    }

    /**
     * Push a value onto an array configuration value.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return void
     */
    public function push($key, $value) {

    }

    protected function getConnection()
    {
        return $this->redis->connection($this->connection);
    }
}

# app\Config\RedisConfig.php

<?php

namespace App\Config;

use Illuminate\Redis\Database as RedisDatabase;

use Illuminate\Contracts\Config\Repository as ConfigRepository;

class RedisConfig implements ConfigRepository

{

public $redis;

public $connection = 'default';

public function __construct(RedisDatabase $redis) {

$this -> redis = $redis;

}

/**

* Determine if the given configuration value exists.

* @param string $key

* @return bool

public function has($key) {

return $this -> getConnection() -> exists($key);

}

/**

* Get the specified configuration value.

* @param string $key

* @param mixed $default

* @return mixed

public function get($key, $default = null) {

$value = $this -> getConnection() -> get($key);

return is_null($value) ? $default : $value;

}

/**

* Get all of the configuration items for the application.

* @return array

public function all() {

}

/**

* Set a given configuration value.

* @param array|string $key

* @param mixed $value

* @return void

public function set($key, $value = null) {

$this -> getConnection() -> set($key, $value);

}

/**

* Prepend a value onto an array configuration value.

* @param string $key

* @param mixed $value

* @return void

public function prepend($key, $value) {

}

/**

* Push a value onto an array configuration value.

* @param string $key

* @param mixed $value

* @return void

public function push($key, $value) {

}

protected function getConnection()

{

return $this->redis->connection($this->connection);

}

调用

        $redis = app('redis');
        $config = new RedisConfig($redis);
        var_dump($config -> has('hello'));             # 不存在
        var_dump($config -> get('hello', 'nihao'));    # 获取不到以后，拿到默认值nihao
        var_dump($config -> set('hello', 'world'));    # 设值
        var_dump($config -> has('hello'));             # 存在
        var_dump($config -> get('hello', 'nihao'));    # 得到world

$redis = app('redis');

$config = new RedisConfig($redis);

var_dump($config -> has('hello')); # 不存在

var_dump($config -> get('hello', 'nihao')); # 获取不到以后，拿到默认值nihao

var_dump($config -> set('hello', 'world')); # 设值

var_dump($config -> has('hello')); # 存在

var_dump($config -> get('hello', 'nihao')); # 得到world

laravel/lumen框架中，其实已经多这部分做了实现。上面只是一个简单的例子，用来说明契约的用法。

laravel/lumen提供的所有契约都可以在他的Github上找到。

服务容器和服务提供者

服务容器是一个用于管理类依赖和执行依赖注入的强大工具。他可以降低类之间的耦合，也可以方便我们去创建调用。

我们可以在bootstrap/app.php中去注册RedisConfig。然后使用app('redisconfig')方式来获取配置对象。

# bootstrap/app.php

$app->singleton(
    'redisconfig',
    function() {
        return new App\Config\RedisConfig(app('redis'));
    }
);

# 当然你不想绑定单例，那么可以使用`bind`方法
$app->bind(
    'redisconfig',
    function() {
        return new App\Config\RedisConfig(app('redis'));
    }
);

# bootstrap/app.php

$app->singleton(

'redisconfig',

function() {

return new App\Config\RedisConfig(app('redis'));

}

);

# 当然你不想绑定单例，那么可以使用`bind`方法

$app->bind(

'redisconfig',

function() {

return new App\Config\RedisConfig(app('redis'));

}

);

接下来调用与刚刚一样。

        $config = app('redisconfig');
        var_dump($config -> has('hello'));
        var_dump($config -> get('hello', 'nihao'));
        var_dump($config -> set('hello', 'world'));
        var_dump($config -> has('hello'));
        var_dump($config -> get('hello', 'nihao'));

$config = app('redisconfig');

var_dump($config -> has('hello'));

var_dump($config -> get('hello', 'nihao'));

var_dump($config -> set('hello', 'world'));

var_dump($config -> has('hello'));

var_dump($config -> get('hello', 'nihao'));

关于服务容器我们有3中绑定方式。

1、单例

$app->singleton('xxxx', function ($app) {
    return new xxx();
});

$app->singleton('xxxx', function ($app) {

return new xxx();

});

2、普通

$app->bind('xxxx', function ($app) {
    return new xxx();
});

$app->bind('xxxx', function ($app) {

return new xxx();

});

3、绑定实例

$fooBar = new FooBar();
$app->instance('FooBar', $fooBar);

$fooBar = new FooBar();

$app->instance('FooBar', $fooBar);

当服务容器变多如何管理？还是第三方无法侵入我们的代码，如何提供服务容器？这时候可以使用服务提供者。

我们可以将服务提供者写在app/Providers目录下。然后将bootstrap/app.php中注册的容器搬入里面。最后在bootstrap/app.php注册服务提供者。

# app\Providers\RedisConfigServiceProvider.php

<?php

namespace App\Providers;

use App\Config\RedisConfig;
use Illuminate\Support\ServiceProvider;

class RedisConfigServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton(
            'redisconfig',
            function() {
                return new RedisConfig($this->app->make('redis'));
            }
        );
    }
}

# app\Providers\RedisConfigServiceProvider.php

<?php

namespace App\Providers;

use App\Config\RedisConfig;

use Illuminate\Support\ServiceProvider;

class RedisConfigServiceProvider extends ServiceProvider

{

/**

* Register any application services.

* @return void

public function register()

{

$this->app->singleton(

'redisconfig',

function() {

return new RedisConfig($this->app->make('redis'));

}

);

}

# bootstrap/app.php

去掉服务容器
/*
$app->singleton(
    'redisconfig',
    function() {
        return new App\Config\RedisConfig(app('redis'));
    }
);
*/

# 然后注册服务提供者
$app->register(App\Providers\RedisConfigServiceProvider::class);

# bootstrap/app.php

去掉服务容器

$app->singleton(

'redisconfig',

function() {

return new App\Config\RedisConfig(app('redis'));

}

);

# 然后注册服务提供者

$app->register(App\Providers\RedisConfigServiceProvider::class);

和之前一样可以调用。

门面

laravel/lumen的门面作为服务容器中的底层类的“静态代理”，相比于传统静态方法，在维护时能够提供更加易于测试、更加灵活的、简明且富有表现力的语法。

门面我们可以写入app\Facades文件夹下。

<?php 

namespace App\Facades;

use Illuminate\Support\Facades\Facade;

class RedisConfig extends Facade{
    /**
     * 获取组件注册名称
     *
     * @return string
     */
    protected static function getFacadeAccessor() { 
        return 'redisconfig'; 
    }
}

<?php

namespace App\Facades;

use Illuminate\Support\Facades\Facade;

class RedisConfig extends Facade{

/**

* 获取组件注册名称

* @return string

protected static function getFacadeAccessor() {

return 'redisconfig';

}

修改RedisConfigServiceProvider。

/**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton(
            'redisconfig',
            function() {
                return new RedisConfig($this->app->make('redis'));
            }
        );

        /**
         * 这里
         */
        class_alias('App\Facades\RedisConfig', 'RedisConfig');
    }

/**

* Register any application services.

* @return void

public function register()

{

$this->app->singleton(

'redisconfig',

function() {

return new RedisConfig($this->app->make('redis'));

}

);

/**

* 这里

class_alias('App\Facades\RedisConfig', 'RedisConfig');

}

然后我们就可以使用门面了。

<?php

namespace App\Http\Controllers;

use RedisConfig;
// use App\Config\RedisConfig;

class ConfigController extends Controller
{

    public function test() {
        // $redis = app('redis');
        // $config = new RedisConfig($redis);

        // $config = app('redisconfig');
        // var_dump($config -> has('hello'));
        // var_dump($config -> get('hello', 'nihao'));
        // var_dump($config -> set('hello', 'world'));
        // var_dump($config -> has('hello'));
        // var_dump($config -> get('hello', 'nihao'));

        var_dump(RedisConfig::has('hello'));

    }

}

<?php

namespace App\Http\Controllers;

use RedisConfig;

// use App\Config\RedisConfig;

class ConfigController extends Controller

{

public function test() {

// $redis = app('redis');

// $config = new RedisConfig($redis);

// $config = app('redisconfig');

// var_dump($config -> has('hello'));

// var_dump($config -> get('hello', 'nihao'));

// var_dump($config -> set('hello', 'world'));

// var_dump($config -> has('hello'));

// var_dump($config -> get('hello', 'nihao'));

var_dump(RedisConfig::has('hello'));

}

PHP

laravel/lumen —— 软删除

2016年3月27日 chen

在项目中，总是会碰到一些需要删除的数据。但是数据理论上是不能够物理删除（硬删除）的，只能进行逻辑删除（软删除）。

laravel/lumen的Eloquent ORM为我们提供了方便的软删除操作。

单表软删除

我们先创建user表。结构比较简单，三个字段：自增ID、用户名和密码。

Field       Type              Collation        Null    Key     Default  Extra           
----------  ----------------  ---------------  ------  ------  -------  --------------  
id          int(10) unsigned  (NULL)           NO      PRI     (NULL)   auto_increment          
username    varchar(32)       utf8_general_ci  NO              (NULL)                   
password    varchar(32)       utf8_general_ci  NO              (NULL)

Field Type Collation Null Key Default Extra

---------- ---------------- --------------- ------ ------ ------- --------------

id int(10) unsigned (NULL) NO PRI (NULL) auto_increment

username varchar(32) utf8_general_ci NO (NULL)

password varchar(32) utf8_general_ci NO (NULL)

并且为其插入一些数据。

id  username    password
1   aa  aa
2   bb  bb  
3   cc  cc  
4   dd  dd

id username password

1 aa aa

2 bb bb

3 cc cc

4 dd dd

正常情况下，我们进行删除操作。就是将数据重数据库中完全删除了。除了重二进制日志中进行回复，其他已无法恢复数据了。

        $model = User::find(1);
        if($model->delete()){
            echo '删除成功！';
        }else{
            echo '删除失败！';
        }

$model = User::find(1);

if($model->delete()){

echo '删除成功！';

}else{

echo '删除失败！';

}

# 数据库结果
id  username    password
2   bb  bb  
3   cc  cc  
4   dd  dd

# 数据库结果

id username password

2 bb bb

3 cc cc

4 dd dd

接下来我们进行软删除配置：

1、在Model中引入SoftDeletes

namespace App\Model;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;


class User extends Model
{

    use SoftDeletes;

    protected $table = 'user';

    public function content() 
    {
        return $this->hasMany('App\Model\Content');
    }

}

namespace App\Model;

use Illuminate\Database\Eloquent\Model;

use Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model

{

use SoftDeletes;

protected $table = 'user';

public function content()

{

return $this->hasMany('App\Model\Content');

}

2、为我们的数据增加几个字段created_at、updated_at、deleted_at

进入项目根目录执行命令，我们使用迁移来实现添加字段。

root@chen-Ubuntu:/data/test/lumen-test# php artisan make:migration alter_user_deleted_at --table=user
Created Migration: 2016_03_27_043709_alter_user_deleted_at

root@chen-Ubuntu:/data/test/lumen-test# php artisan make:migration alter_user_deleted_at --table=user

Created Migration: 2016_03_27_043709_alter_user_deleted_at

随后就会在database\migrations目录下找到2016_03_27_043709_alter_user_deleted_at这个文件。我们修改up方法如下。

/**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('user', function (Blueprint $table) {
            $table->timestamps();
            $table->softDeletes();
        });
    }

/**

* Run the migrations.

* @return void

public function up()

{

Schema::table('user', function (Blueprint $table) {

$table->timestamps();

$table->softDeletes();

});

}

随后执行php artisan migrate命令，数据库中字段就以添加。

root@chen-Ubuntu:/data/test/lumen-test# php artisan migrate
Migrated: 2016_03_27_043709_alter_user_deleted_at

root@chen-Ubuntu:/data/test/lumen-test# php artisan migrate

Migrated: 2016_03_27_043709_alter_user_deleted_at

3、实现软删除

        $model = User::find(2);
        $model->delete()
        if($model->trashed()){  # 判断是否已经软删除
            echo '软删除成功！';
        }else{
            echo '软删除失败！';
        }

$model = User::find(2);

$model->delete()

if($model->trashed()){ # 判断是否已经软删除

echo '软删除成功！';

}else{

echo '软删除失败！';

}

# 数据库结果
id  username    password    created_at  updated_at  deleted_at
2   bb  bb  \N  2016-03-27 04:42:27 2016-03-27 04:42:27
3   cc  cc  \N  \N  \N
4   dd  dd  \N  \N  \N

# 数据库结果

id username password created_at updated_at deleted_at

2 bb bb \N 2016-03-27 04:42:27 2016-03-27 04:42:27

3 cc cc \N \N \N

4 dd dd \N \N \N

我们可以看到 deleted_at字段就会被填入删除时间点。

4、查询

当我们去再去查询的时候，就会发现已经查询不到了。

$model = User::find(2);
var_dump($model); // null

$model = User::find(2);

var_dump($model); // null

如果说我们一定要查到被软删除的数据我们可以使用withTrashed。

$model = User::withTrashed()->find(2);
# 数据就会被查询到

$model = User::withTrashed()->find(2);

# 数据就会被查询到

查询到后我们也可以将其恢复。

$model = User::withTrashed()->find(2);
$model -> restore();

$model = User::withTrashed()->find(2);

$model -> restore();

5、原理

为什么引入SoftDeletes后就可以现象软删除呢？

当我们创建Eloquent对象的时候。会对引入的SoftDeletes Trait进行初始化。

__construct -> bootIfNotBooted -> boot -> bootTraits

在bootTraits方法中会去进行初始化SoftDeletes Trait

# Illuminate\Database\Eloquent\Model 文件
    /**
     * Boot all of the bootable traits on the model.
     *
     * @return void
     */
    protected static function bootTraits()
    {
        $class = static::class;

        foreach (class_uses_recursive($class) as $trait) {
            if (method_exists($class, $method = 'boot'.class_basename($trait))) {
                # 判断是否存在初始化方法，存在即初始化。
                forward_static_call([$class, $method]); 
            }
        }
    }

# Illuminate\Database\Eloquent\Model 文件

/**

* Boot all of the bootable traits on the model.

* @return void

protected static function bootTraits()

{

$class = static::class;

foreach (class_uses_recursive($class) as $trait) {

if (method_exists($class, $method = 'boot'.class_basename($trait))) {

# 判断是否存在初始化方法，存在即初始化。

forward_static_call([$class, $method]);

}

SoftDeletes Trait中的bootSoftDeletes就是被初始化的方法。意思是添加一个软删除的作用于。

作用域的详情可以看到这里：http://laravelacademy.org/post/2995.html#ipt_kb_toc_2995_19

# Illuminate\Database\Eloquent\SoftDeletes 文件

    /**
     * Boot the soft deleting trait for a model.
     *
     * @return void
     */
    public static function bootSoftDeletes()
    {
        static::addGlobalScope(new SoftDeletingScope);
    }

# Illuminate\Database\Eloquent\SoftDeletes 文件

/**

* Boot the soft deleting trait for a model.

* @return void

public static function bootSoftDeletes()

{

static::addGlobalScope(new SoftDeletingScope);

}

SoftDeletes Trait 主要作用的就是通过不同手段（重写方法、添加作用域等）来实现软删除，以及查询是自动添加deleted_at is null。

多表软删除

我们再创建一个content和comment表。并且重复上面的步骤添加上软删除。

# content 表

Field       Type              Collation        Null    Key     Default  Extra           
----------  ----------------  ---------------  ------  ------  -------  --------------  
id          int(10) unsigned  (NULL)           NO      PRI     (NULL)   auto_increment  
user_id     int(11)           (NULL)           NO              (NULL)                   
content     varchar(32)       utf8_general_ci  NO              (NULL)                   
created_at  timestamp         (NULL)           YES             (NULL)                   
updated_at  timestamp         (NULL)           YES             (NULL)                   
deleted_at  timestamp         (NULL)           YES             (NULL)                   

# 数据
id  user_id content created_at  updated_at  deleted_at
1   2   123 \N  \N  \N
2   3   234 \N  \N  \N
3   3   333 \N  2016-03-27 13:53:30 2016-03-27 13:53:35

# content 表

Field Type Collation Null Key Default Extra

---------- ---------------- --------------- ------ ------ ------- --------------

id int(10) unsigned (NULL) NO PRI (NULL) auto_increment

user_id int(11) (NULL) NO (NULL)

content varchar(32) utf8_general_ci NO (NULL)

created_at timestamp (NULL) YES (NULL)

updated_at timestamp (NULL) YES (NULL)

deleted_at timestamp (NULL) YES (NULL)

# 数据

id user_id content created_at updated_at deleted_at

1 2 123 \N \N \N

2 3 234 \N \N \N

3 3 333 \N 2016-03-27 13:53:30 2016-03-27 13:53:35

# comment 表
Field       Type              Collation        Null    Key     Default  Extra         
----------  ----------------  ---------------  ------  ------  -------  --------------
id          int(10) unsigned  (NULL)           NO      PRI     (NULL)   auto_increment
content     varchar(32)       utf8_general_ci  NO              (NULL)                 
content_id  int(11)           (NULL)           NO              (NULL)                 
user_id     int(11)           (NULL)           NO              (NULL)                 
created_at  timestamp         (NULL)           YES             (NULL)                 
updated_at  timestamp         (NULL)           YES             (NULL)                 
deleted_at  timestamp         (NULL)           YES             (NULL)                 

# 数据
id  content content_id  user_id created_at  updated_at  deleted_at
1   c1  2   4   \N  \N  \N
2   c2  2   3   \N  \N  \N

# comment 表

Field Type Collation Null Key Default Extra

---------- ---------------- --------------- ------ ------ ------- --------------

id int(10) unsigned (NULL) NO PRI (NULL) auto_increment

content varchar(32) utf8_general_ci NO (NULL)

content_id int(11) (NULL) NO (NULL)

user_id int(11) (NULL) NO (NULL)

created_at timestamp (NULL) YES (NULL)

updated_at timestamp (NULL) YES (NULL)

deleted_at timestamp (NULL) YES (NULL)

# 数据

id content content_id user_id created_at updated_at deleted_at

1 c1 2 4 \N \N \N

2 c2 2 3 \N \N \N

形成了一个如下关系

user -> content    一对多 has many
content -> user    多对一 belongs to
content -> comment 一对多 has many
comment -> user    多对一 belongs to

user -> content 一对多 has many

content -> user 多对一 belongs to

content -> comment 一对多 has many

comment -> user 多对一 belongs to

接下来进行操作

1、查询

$model = User::find(3);

$contents = $model -> content;

print_r($model);

App\Model\User Object

(

[table:protected] => user

[connection:protected] =>

[primaryKey:protected] => id

[perPage:protected] => 15

[incrementing] => 1

[timestamps] => 1

[attributes:protected] => Array

(

[id] => 3

[username] => bb

[password] => bb

[created_at] =>

[updated_at] =>

[deleted_at] =>

)

[original:protected] => Array

(

[id] => 3

[username] => bb

[password] => bb

[created_at] =>

[updated_at] =>

[deleted_at] =>

)

[relations:protected] => Array

(

[content] => Illuminate\Database\Eloquent\Collection Object

(

[items:protected] => Array

(

[0] => App\Model\Content Object

(

[table:protected] => content

[connection:protected] =>

[primaryKey:protected] => id

[perPage:protected] => 15

[incrementing] => 1

[timestamps] => 1

[attributes:protected] => Array

(

[id] => 2

[user_id] => 3

[content] => 234

[created_at] =>

[updated_at] =>

[deleted_at] =>

)

[original:protected] => Array

(

[id] => 2

[user_id] => 3

[content] => 234

[created_at] =>

[updated_at] =>

[deleted_at] =>

)

...

)

。。。

)

我们可以被软删除的id=3的content数据并没有查出来。

结合withTrashed来查询，就可以查出来被软删除的数据。

$contents = $model -> content() -> withTrashed() -> get();

1 2	$contents = $model -> content() -> withTrashed() -> get();

关联查询

$content = Content::find(2);
$content -> user;
$comment = $content -> comment -> each(function($item, $key) {
     $item -> user;
 });

$content = Content::find(2);

$content -> user;

$comment = $content -> comment -> each(function($item, $key) {

$item -> user;

});

软删除是Eloquent提供的功能，如果直接使用门面DB来操作或者使用leftJoin等操作是没办法自动实现的，需要我们手动来控制。

# 可以查到被软删除的数据
DB::table('user') -> find(2);
# 手动过滤
DB::table('user') -> whereNull('deleted_at') -> find(2);

# 可以查到被软删除的数据

DB::table('user') -> find(2);

# 手动过滤

DB::table('user') -> whereNull('deleted_at') -> find(2);

# user表中的软删除数据查询不出，但是leftJoin表中的软删除数据可以被查询到。一样要做手动过滤
User::leftJoin('content', 'user.id', '=', 'content.user_id') -> select(['user.id', 'content.id as content_id', 'content.user_id']) -> get();

# user表中的软删除数据查询不出，但是leftJoin表中的软删除数据可以被查询到。一样要做手动过滤

User::leftJoin('content', 'user.id', '=', 'content.user_id') -> select(['user.id', 'content.id as content_id', 'content.user_id']) -> get();

PHP

finite state machine

2016年3月13日 chen

状态模式
状态间切换的控制
基于事件

状态模式

状态模式(State Pattern) ：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

主要角色

抽象状态角色：定义一个接口，用以封装环境对象的一个特定的状态所对应的行为
具体状态角色：每一个具体状态类都实现了环境的一个状态所对应的行为
环境角色：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态

为什么要用状态模式

为了解耦各个状态间的工作，让人能够清晰的看懂某个状态下做些什么事情。

代码实现

# iState
# 抽象状态接口
interface iState {
    public function handle(Context $context);
}

# iState

# 抽象状态接口

interface iState {

public function handle(Context $context);

}

# 具体状态角色
# 开关的开状态
class ConcreteStateOpen implements iState {

    public function handle(Context $context) {
        echo "open to close \n";
        $context -> setState(new ConcreteStateClose());
    }

}

# 开关的关状态
class ConcreteStateClose implements iState {

    public function handle(Context $context) {
        echo "close to open \n";
        $context -> setState(new ConcreteStateOpen());
    }

}

# 具体状态角色

# 开关的开状态

class ConcreteStateOpen implements iState {

public function handle(Context $context) {

echo "open to close \n";

$context -> setState(new ConcreteStateClose());

}

# 开关的关状态

class ConcreteStateClose implements iState {

public function handle(Context $context) {

echo "close to open \n";

$context -> setState(new ConcreteStateOpen());

}

# 环境角色

class Context {

    private $state;

    public function setState(iState $state) {
        $this -> state = $state;
    }

    public function getState() {
        return $this -> state;
    }

    public function request() {
        $this -> state -> handle($this);
    }
}

# 环境角色

class Context {

private $state;

public function setState(iState $state) {

$this -> state = $state;

}

public function getState() {

return $this -> state;

}

public function request() {

$this -> state -> handle($this);

}

接下来就是进行实践：

<br />$open = new ConcreteStateOpen();
$close = new ConcreteStateClose();

$context = new Context();
$context -> setState($open);

$context -> request();
$context -> request();
$context -> request();
/*
# 开关在开和关之间不断的切换。
open to close 
close to open 
open to close 
*/

<br />$open = new ConcreteStateOpen();

$close = new ConcreteStateClose();

$context = new Context();

$context -> setState($open);

$context -> request();

# 开关在开和关之间不断的切换。

open to close

close to open

open to close

状态间切换的控制

状态切换

举个人类跑步的例子：

人的最大体力和当前体力为5，
需要跑步13KM，每1KM消耗1HP，
当体力不够是需要停下来休息，回复到最大体力后，继续跑，
跑完13KM，结束。

# 状态

interface iState {
    public function handle(Context $context);
}

abstract class AbstractState implements iState {

    public $name;

    public function __construct($name) {
        $this -> name = $name;
    }

    abstract public function handle(Context $context);
}

abstract class AbstractRuningState extends AbstractState{
}


class ReadyState extends AbstractRuningState {

    public function handle(Context $context) {
        echo "state: Ready \n";
    }

}

class RunState extends AbstractRuningState {

    public function handle(Context $context) {
        echo "state: Run \n";
        # 体力 - 1
        # 路程 + 1

        $context -> hp --;
        $context -> runKM ++;
        echo "hp: {$context -> hp}, runKm: {$context -> runKM} \n";
    }

}

class RestState extends AbstractRuningState {

    public function handle(Context $context) {
        echo "state: Rest \n";

        # 体力 + 1 ...

        $context -> hp ++;
        echo "hp: {$context -> hp} \n";
    }

}

class EndState extends AbstractRuningState {

    public function handle(Context $context) {
        echo "state: End \n";
    }

}

# 状态

interface iState {

public function handle(Context $context);

}

abstract class AbstractState implements iState {

public $name;

public function __construct($name) {

$this -> name = $name;

}

abstract public function handle(Context $context);

}

abstract class AbstractRuningState extends AbstractState{

}

class ReadyState extends AbstractRuningState {

public function handle(Context $context) {

echo "state: Ready \n";

}

class RunState extends AbstractRuningState {

public function handle(Context $context) {

echo "state: Run \n";

# 体力 - 1

# 路程 + 1

$context -> hp --;

$context -> runKM ++;

echo "hp: {$context -> hp}, runKm: {$context -> runKM} \n";

}

class RestState extends AbstractRuningState {

public function handle(Context $context) {

echo "state: Rest \n";

# 体力 + 1 ...

$context -> hp ++;

echo "hp: {$context -> hp} \n";

}

class EndState extends AbstractRuningState {

public function handle(Context $context) {

echo "state: End \n";

}

# 上下文环境
class Context {

    protected $state;      // 当前状态

    public function setState(iState $state) {
        if ($this -> state -> name != $state -> name) {
            $this -> state = $state;
        }
        return $this;
    }

    public function getState() {
        return $this -> state;
    }

    public function request() {
        $this -> state -> handle($this);
    }
}

class RunningContext extends Context {

    public $maxHp;
    public $hp;
    public $totalKM;
    public $runKM = 0;

    protected $readyState;
    protected $runState;
    protected $restState;
    protected $endState;

    public function __construct($maxHp, $totalKM) {
        $this -> maxHp   = $maxHp;
        $this -> hp      = $maxHp;
        $this -> totalKM = $totalKM;

        $this -> readyState = new ReadyState('ready');
        $this -> runState = new RunState('run');
        $this -> restState = new RestState('rest');
        $this -> endState = new EndState('end');

    }

    public function ready() {
        $this -> setState($this -> readyState) -> request();
    }

    public function run() {
        $this -> setState($this -> runState) -> request();
    }

    public function rest() {
        $this -> setState($this -> restState) -> request();
    }

    public function end() {
        $this -> setState($this -> endState) -> request();
    }

    public function toRun() {
        # 预备
        $this -> ready();

        # 跑步
        while ($this -> totalKM > $this -> runKM) {
            if ($this -> hp <= 0) {
                # 休息，回复体力
                while ($this -> hp < $this -> maxHp) {
                    $this -> rest();
                }
            }
            $this -> run();
        }

        # 终点结束
        $this -> end();
    }

}

# 上下文环境

class Context {

protected $state; // 当前状态

public function setState(iState $state) {

if ($this -> state -> name != $state -> name) {

$this -> state = $state;

}

return $this;

}

public function getState() {

return $this -> state;

}

public function request() {

$this -> state -> handle($this);

}

class RunningContext extends Context {

public $maxHp;

public $hp;

public $totalKM;

public $runKM = 0;

protected $readyState;

protected $runState;

protected $restState;

protected $endState;

public function __construct($maxHp, $totalKM) {

$this -> maxHp = $maxHp;

$this -> hp = $maxHp;

$this -> totalKM = $totalKM;

$this -> readyState = new ReadyState('ready');

$this -> runState = new RunState('run');

$this -> restState = new RestState('rest');

$this -> endState = new EndState('end');

}

public function ready() {

$this -> setState($this -> readyState) -> request();

}

public function run() {

$this -> setState($this -> runState) -> request();

}

public function rest() {

$this -> setState($this -> restState) -> request();

}

public function end() {

$this -> setState($this -> endState) -> request();

}

public function toRun() {

# 预备

$this -> ready();

# 跑步

while ($this -> totalKM > $this -> runKM) {

if ($this -> hp <= 0) {

# 休息，回复体力

while ($this -> hp < $this -> maxHp) {

$this -> rest();

}

$this -> run();

}

# 终点结束

$this -> end();

}

最后运行：

$context = new RunningContext();
$context -> toRun();
/*
state: Ready 
state: Run 
hp: 4, runKm: 1 
state: Run 
hp: 3, runKm: 2 
state: Run 
hp: 2, runKm: 3 
state: Run 
hp: 1, runKm: 4 
state: Run 
hp: 0, runKm: 5 
state: Rest 
hp: 1 
state: Rest 
hp: 2 
state: Rest 
hp: 3 
state: Rest 
hp: 4 
state: Rest 
hp: 5 
state: Run 
hp: 4, runKm: 6 
state: Run 
hp: 3, runKm: 7 
state: Run 
hp: 2, runKm: 8 
state: Run 
hp: 1, runKm: 9 
state: Run 
hp: 0, runKm: 10 
state: Rest 
hp: 1 
state: Rest 
hp: 2 
state: Rest 
hp: 3 
state: Rest 
hp: 4 
state: Rest 
hp: 5 
state: Run 
hp: 4, runKm: 11 
state: Run 
hp: 3, runKm: 12 
state: Run 
hp: 2, runKm: 13 
state: End 
*/

$context = new RunningContext();

$context -> toRun();

state: Ready

state: Run

hp: 4, runKm: 1

state: Run

hp: 3, runKm: 2

state: Run

hp: 2, runKm: 3

state: Run

hp: 1, runKm: 4

state: Run

hp: 0, runKm: 5

state: Rest

hp: 1

state: Rest

hp: 2

state: Rest

hp: 3

state: Rest

hp: 4

state: Rest

hp: 5

state: Run

hp: 4, runKm: 6

state: Run

hp: 3, runKm: 7

state: Run

hp: 2, runKm: 8

state: Run

hp: 1, runKm: 9

state: Run

hp: 0, runKm: 10

state: Rest

hp: 1

state: Rest

hp: 2

state: Rest

hp: 3

state: Rest

hp: 4

state: Rest

hp: 5

state: Run

hp: 4, runKm: 11

state: Run

hp: 3, runKm: 12

state: Run

hp: 2, runKm: 13

state: End

状态控制

虽然这个时候代码结构已经很清晰。但是还有一个问题就是无法控制状态之间的转换。

比如，征程流程准备->跑步->休息->跑步->结束，但是这个时候的代码可以跑步->准备之间切换。这个很显然违反的我们的规则。

这个时候就需要引入规律机制。

首先，增加一个简单的过程类

class Transition {

    public $transitions = [];

    public function add($name, $from, $to) {
        $this -> transitions[$name] = [$from, $to];
    }

}

class Transition {

public $transitions = [];

public function add($name, $from, $to) {

$this -> transitions[$name] = [$from, $to];

}

其次，Context变量中增加，过程对象

class Context {

    protected $state;      // 当前状态
    protected $transition;

    public function __construct(Transition $transition) {
        $this -> transition = $transition;
    }

    public function setState(iState $state) {
        if (empty($this -> state) || $this -> state -> name != $state -> name) {

            $isSet = false;

            if (!empty($this -> state)) {
                foreach ($this -> transition -> transitions as $tk => $tv) {
                    if ($tv[0] == $this -> state -> name && $tv[1] == $state -> name) {
                        $isSet = true;
                        break;
                    }
                }
            }

            if ($isSet) {
                $this -> state = $state;
            } else {
                if (!empty($this -> state)) {
                    throw new Exception("cannot set state from {$this->state->name} to {$state->name}");
                } else {
                    $this -> state = $state;
                }
            }
        }
        return $this;
    }

    public function getState() {
        return $this -> state;
    }

    public function request() {
        $this -> state -> handle($this);
    }
}

class RunningContext extends Context {

    public $maxHp;
    public $hp;
    public $totalKM;
    public $runKM = 0;

    protected $readyState;
    protected $runState;
    protected $restState;
    protected $endState;

    public function __construct(Transition $transition, $maxHp, $totalKM) {

        parent::__construct($transition);

        $this -> maxHp   = $maxHp;
        $this -> hp      = $maxHp;
        $this -> totalKM = $totalKM;

        $this -> readyState = new ReadyState('ready');
        $this -> runState = new RunState('run');
        $this -> restState = new RestState('rest');
        $this -> endState = new EndState('end');
    }

    public function ready() {
        $this -> setState($this -> readyState) -> request();
    }

    public function run() {
        $this -> setState($this -> runState) -> request();
    }

    public function rest() {
        $this -> setState($this -> restState) -> request();
    }

    public function end() {
        $this -> setState($this -> endState) -> request();
    }

    public function toRun() {
        # 预备
        $this -> ready();

        # 跑步
        while ($this -> totalKM > $this -> runKM) {
            if ($this -> hp <= 0) {
                # 休息，回复体力
                while ($this -> hp < $this -> maxHp) {
                    $this -> rest();
                }
            }
            $this -> run();
        }

        # 终点结束
        $this -> end();
    }

}

100

101

102

103

104

105

106

107

108

109

class Context {

protected $state; // 当前状态

protected $transition;

public function __construct(Transition $transition) {

$this -> transition = $transition;

}

public function setState(iState $state) {

if (empty($this -> state) || $this -> state -> name != $state -> name) {

$isSet = false;

if (!empty($this -> state)) {

foreach ($this -> transition -> transitions as $tk => $tv) {

if ($tv[0] == $this -> state -> name && $tv[1] == $state -> name) {

$isSet = true;

break;

}

if ($isSet) {

$this -> state = $state;

} else {

if (!empty($this -> state)) {

throw new Exception("cannot set state from {$this->state->name} to {$state->name}");

} else {

$this -> state = $state;

}

return $this;

}

public function getState() {

return $this -> state;

}

public function request() {

$this -> state -> handle($this);

}

class RunningContext extends Context {

public $maxHp;

public $hp;

public $totalKM;

public $runKM = 0;

protected $readyState;

protected $runState;

protected $restState;

protected $endState;

public function __construct(Transition $transition, $maxHp, $totalKM) {

parent::__construct($transition);

$this -> maxHp = $maxHp;

$this -> hp = $maxHp;

$this -> totalKM = $totalKM;

$this -> readyState = new ReadyState('ready');

$this -> runState = new RunState('run');

$this -> restState = new RestState('rest');

$this -> endState = new EndState('end');

}

public function ready() {

$this -> setState($this -> readyState) -> request();

}

public function run() {

$this -> setState($this -> runState) -> request();

}

public function rest() {

$this -> setState($this -> restState) -> request();

}

public function end() {

$this -> setState($this -> endState) -> request();

}

public function toRun() {

# 预备

$this -> ready();

# 跑步

while ($this -> totalKM > $this -> runKM) {

if ($this -> hp <= 0) {

# 休息，回复体力

while ($this -> hp < $this -> maxHp) {

$this -> rest();

}

$this -> run();

}

# 终点结束

$this -> end();

}

调用后，返回内容和上面一致。

$transition = new Transition();
$transition -> add('readyToRun', 'ready', 'run');
$transition -> add('runToRest', 'run', 'rest');
$transition -> add('runToEnd', 'run', 'end');
$transition -> add('restToRun', 'rest', 'run');

$context = new RunningContext($transition, 5, 13);
$context -> toRun();

$transition = new Transition();

$transition -> add('readyToRun', 'ready', 'run');

$transition -> add('runToRest', 'run', 'rest');

$transition -> add('runToEnd', 'run', 'end');

$transition -> add('restToRun', 'rest', 'run');

$context = new RunningContext($transition, 5, 13);

$context -> toRun();

但是当出现不允许调用情况是会抛出异常。

    public function toRun() {
        # 预备
        $this -> ready();

        # 跑步
        while ($this -> totalKM > $this -> runKM) {
            if ($this -> hp <= 0) {
                # 休息，回复体力
                while ($this -> hp < $this -> maxHp) {
                    $this -> rest();
                }
            }
            $this -> run();
            $this -> ready(); # 异常步骤
        }

        # 终点结束
        $this -> end();
    }
/*
PHP Fatal error:  Uncaught exception 'Exception' with message 'cannot set state from run to ready' ...
...
...
...
*/

public function toRun() {

# 预备

$this -> ready();

# 跑步

while ($this -> totalKM > $this -> runKM) {

if ($this -> hp <= 0) {

# 休息，回复体力

while ($this -> hp < $this -> maxHp) {

$this -> rest();

}

$this -> run();

$this -> ready(); # 异常步骤

}

# 终点结束

$this -> end();

}

PHP Fatal error: Uncaught exception 'Exception' with message 'cannot set state from run to ready' ...

...

基于事件

我们还可以为进入状态，离开状态添加事件，以便代码更清晰，更容易解耦。

事件的底层其实就是观察模式。为了方便我就使用illuminate/events包。

1、为Context类添加event变量

class RunningContext extends Context {

    public $maxHp;
    public $hp;
    public $totalKM;
    public $runKM = 0;

    protected $readyState;
    protected $runState;
    protected $restState;
    protected $endState;

    public function __construct(Illuminate\Events\Dispatcher $event, Transition $transition, $maxHp, $totalKM) {

        parent::__construct($event, $transition);

        $this -> maxHp   = $maxHp;
        $this -> hp      = $maxHp;
        $this -> totalKM = $totalKM;

        $this -> readyState = new ReadyState('ready');
        $this -> runState = new RunState('run');
        $this -> restState = new RestState('rest');
        $this -> endState = new EndState('end');
    }


class Context {

    protected $state;      // 当前状态
    protected $transition;

    protected $event;

    public function __construct(Illuminate\Events\Dispatcher $event, Transition $transition) {
        $this -> transition = $transition;
        $this -> event = $event;
    }

class RunningContext extends Context {

public $maxHp;

public $hp;

public $totalKM;

public $runKM = 0;

protected $readyState;

protected $runState;

protected $restState;

protected $endState;

public function __construct(Illuminate\Events\Dispatcher $event, Transition $transition, $maxHp, $totalKM) {

parent::__construct($event, $transition);

$this -> maxHp = $maxHp;

$this -> hp = $maxHp;

$this -> totalKM = $totalKM;

$this -> readyState = new ReadyState('ready');

$this -> runState = new RunState('run');

$this -> restState = new RestState('rest');

$this -> endState = new EndState('end');

}

class Context {

protected $state; // 当前状态

protected $transition;

protected $event;

public function __construct(Illuminate\Events\Dispatcher $event, Transition $transition) {

$this -> transition = $transition;

$this -> event = $event;

}

2、设置事件

     public function request() {
        $this -> event -> fire('state.before.'.$this->state->name);
        $this -> state -> handle($this);
        $this -> event -> fire('state.after.'.$this->state->name);
    }

public function request() {

$this -> event -> fire('state.before.'.$this->state->name);

$this -> state -> handle($this);

$this -> event -> fire('state.after.'.$this->state->name);

}

3、设置监听点以及调用

$transition = new Transition();
$transition -> add('readyToRun', 'ready', 'run');
$transition -> add('runToRest', 'run', 'rest');
$transition -> add('runToEnd', 'run', 'end');
$transition -> add('restToRun', 'rest', 'run');

$event = new Illuminate\Events\Dispatcher();
$event -> listen('state.before.ready', function() {
    echo "before ready \n";
});
$event -> listen('state.after.ready', function() {
    echo "after ready \n";
});

$context = new RunningContext($event, $transition, 5, 13);
$context -> toRun();

/*
before ready 
state: Ready 
after ready 
state: Run 
...
...
*/

$transition = new Transition();

$transition -> add('readyToRun', 'ready', 'run');

$transition -> add('runToRest', 'run', 'rest');

$transition -> add('runToEnd', 'run', 'end');

$transition -> add('restToRun', 'rest', 'run');

$event = new Illuminate\Events\Dispatcher();

$event -> listen('state.before.ready', function() {

echo "before ready \n";

});

$event -> listen('state.after.ready', function() {

echo "after ready \n";

});

$context = new RunningContext($event, $transition, 5, 13);

$context -> toRun();

before ready

state: Ready

after ready

state: Run

...

PHP

swoole —— process

2016年3月6日 chen

创建进程
进程间通信
- 管道
- 队列
- 信号
其他
- 执行系统命令
- 回收
- 守护进程
- 命名进程
- CPU亲和性

swoole_process

swoole的进程对比pcntl扩展进程的优势：

pcntl无法用在fpm/apache中
pcntl没有提供进程间通信的功能
pcntl不支持重定向标准输入和输出
pcntl只提供了fork这样原始的接口，容易使用错误
swoole_process提供了比pcntl更强大的功能，更易用的API，使PHP在多进程编程方面更加轻松。

创建进程

原型：

int swoole_process::__construct(mixed $function, $redirect_stdin_stdout = false, $create_pipe = true);

1 2	int swoole_process::__construct(mixed $function, $redirect_stdin_stdout = false, $create_pipe = true);

参数：

function：子进程创建成功后要执行的函数
redirect_stdin_stdout：重定向子进程的标准输入和输出。启用此选项后，在进程内echo将不是打印屏幕，而是写入到管道。读取键盘输入将变为从管道中读取数据。默认为阻塞读取。
create_pipe：是否创建管道，启用redirect_stdin_stdout后，此选项将忽略用户参数，强制为true 如果子进程内没有进程间通信，可以设置为false

返回值：

swoole_process对象，数据结构包括了管道描述符和回调函数。

$process = new swoole_process(function (swoole_process $worker) {
    echo "process: echo 1";
    print_r($worker);
});

$pid = $process -> start();

echo "pid:", $pid, "\n";

/*
pid:12057
process: echo 1
swoole_process Object
(
    [pipe] => 4
    [callback] => Closure Object
        (
            [parameter] => Array
                (
                    [$worker] => <required>
                )

        )

    [pid] => 12167
)

*/

$process = new swoole_process(function (swoole_process $worker) {

echo "process: echo 1";

print_r($worker);

});

$pid = $process -> start();

echo "pid:", $pid, "\n";

pid:12057

process: echo 1

swoole_process Object

(

[pipe] => 4

[callback] => Closure Object

(

[parameter] => Array

(

[$worker] => <required>

)

[pid] => 12167

)

进程间通信

管道

当创建进程时，进行了输入输出重定向，swoole就会帮我们自动创建管道。

$process = new swoole_process(function (swoole_process $worker) {
    echo "process: echo 1";
}, true);

$pid = $process -> start();

echo "pid:", $pid, "\n";
/*
pid:12057
*/

$process = new swoole_process(function (swoole_process $worker) {

echo "process: echo 1";

}, true);

$pid = $process -> start();

echo "pid:", $pid, "\n";

pid:12057

这里运行程序并不会输出process: echo 1。因为输出意见被输入到管道中去了。

$process = new swoole_process(function (swoole_process $worker) {
    echo "process: echo 1";
}, true);

$pid = $process -> start();

echo "pid:", $pid, "\n";

echo $process -> read();
/*
pid:12057
process_1.php 
*/

$process = new swoole_process(function (swoole_process $worker) {

echo "process: echo 1";

}, true);

$pid = $process -> start();

echo "pid:", $pid, "\n";

echo $process -> read();

pid:12057

process_1.php

这里我们关闭输出输入重定向，并且开启管道。进行一个简单的案例说明：

$process = new swoole_process(function (swoole_process $worker) {
    echo $worker -> read(), "\n";
    $worker -> write("hello parent, I'm child #" . $worker->pid);
    $worker -> exit(0);
}, false, true);

$pid = $process -> start();

$process -> write("hello, child #".$pid.",  I'm parent");

echo $process -> read(), "\n";

/*
hello, child #12197,  I'm parent
hello parent, I'm child #12197
*/

$process = new swoole_process(function (swoole_process $worker) {

echo $worker -> read(), "\n";

$worker -> write("hello parent, I'm child #" . $worker->pid);

$worker -> exit(0);

}, false, true);

$pid = $process -> start();

$process -> write("hello, child #".$pid.", I'm parent");

echo $process -> read(), "\n";

hello, child #12197, I'm parent

hello parent, I'm child #12197

队列

$process = new swoole_process(function (swoole_process $worker) {
    echo $worker -> pop(), "\n";
    $worker -> push("hello parent, i'm child #".$worker->pid);
    $worker->exit(0);
}, false);
$process->useQueue();
$pid = $process->start();

$process->push("hello child #{$pid}, i'm parent");
echo $process -> pop(), "\n";
$ret = swoole_process::wait();
print_r($ret);
/*
hello child #23747, i'm parent
hello parent, i'm child #23747
Array
(
    [code] => 0
    [pid] => 23749
    [signal] => 0
)
*/

$process = new swoole_process(function (swoole_process $worker) {

echo $worker -> pop(), "\n";

$worker -> push("hello parent, i'm child #".$worker->pid);

$worker->exit(0);

}, false);

$process->useQueue();

$pid = $process->start();

$process->push("hello child #{$pid}, i'm parent");

echo $process -> pop(), "\n";

$ret = swoole_process::wait();

print_r($ret);

hello child #23747, i'm parent

hello parent, i'm child #23747

Array

(

[code] => 0

[pid] => 23749

[signal] => 0

)

信号

$process = new swoole_process(function (swoole_process $worker) {

    /**
     * 注册信号
     * 当前进程被kill触发
     */
    swoole_process::signal(SIGTERM, function($signal_num) use ($worker) {
        echo "signal SIGTERM call = $signal_num, #{$worker -> pid}\n";

        // todo something

        $worker -> exit(0);
    });

    for ($i=0; $i < 100000000; $i++) { }
}, false);

/**
 * 注册信号
 * 子进程被kill触发
 */
swoole_process::signal(SIGCHLD, function($signal_num) use ($process) {
    echo "signal SIGCHLD call = $signal_num, #{$process -> pid}\n";

    /**
     * 回收子进程
     */
    while($ret =  swoole_process::wait(false)) {
        echo "PID={$ret['pid']}\n";
    }
});

$pid = $process->start();

swoole_process::kill($pid); # kill 子进程

$process = new swoole_process(function (swoole_process $worker) {

/**

* 注册信号

* 当前进程被kill触发

swoole_process::signal(SIGTERM, function($signal_num) use ($worker) {

echo "signal SIGTERM call = $signal_num, #{$worker -> pid}\n";

// todo something

$worker -> exit(0);

});

for ($i=0; $i < 100000000; $i++) { }

}, false);

/**

* 注册信号

* 子进程被kill触发

swoole_process::signal(SIGCHLD, function($signal_num) use ($process) {

echo "signal SIGCHLD call = $signal_num, #{$process -> pid}\n";

/**

* 回收子进程

while($ret = swoole_process::wait(false)) {

echo "PID={$ret['pid']}\n";

}

});

$pid = $process->start();

swoole_process::kill($pid); # kill 子进程

父进程中注册信号（子进程被kill触发），自进程中注册信号（本身被kill触发）。

开启子进程后，父进程立即杀死子进程，触发子进程信号事件。子进程关闭后，触发父进程信号事件。

# 信号类型列表

编号  信号名称    缺省动作    说明
1   SIGHUP  终止  终止控制终端或进程
2   SIGINT  终止  键盘产生的中断(Ctrl-C)
3   SIGQUIT dump    键盘产生的退出
4   SIGILL  dump    非法指令
5   SIGTRAP dump    debug中断
6   SIGABRT／SIGIOT  dump    异常中止
7   SIGBUS／SIGEMT   dump    总线异常/EMT指令
8   SIGFPE  dump    浮点运算溢出
9   SIGKILL 终止  强制进程终止
10  SIGUSR1 终止  用户信号,进程可自定义用途
11  SIGSEGV dump    非法内存地址引用
12  SIGUSR2 终止  用户信号，进程可自定义用途
13  SIGPIPE 终止  向某个没有读取的管道中写入数据
14  SIGALRM 终止  时钟中断(闹钟)
15  SIGTERM 终止  进程终止
16  SIGSTKFLT   终止  协处理器栈错误
17  SIGCHLD 忽略  子进程退出或中断
18  SIGCONT 继续  如进程停止状态则开始运行
19  SIGSTOP 停止  停止进程运行
20  SIGSTP  停止  键盘产生的停止
21  SIGTTIN 停止  后台进程请求输入
22  SIGTTOU 停止  后台进程请求输出
23  SIGURG  忽略  socket发生紧急情况
24  SIGXCPU dump    CPU时间限制被打破
25  SIGXFSZ dump    文件大小限制被打破
26  SIGVTALRM   终止  虚拟定时时钟
27  SIGPROF 终止  profile timer clock
28  SIGWINCH    忽略  窗口尺寸调整
29  SIGIO/SIGPOLL   终止  I/O可用
30  SIGPWR  终止  电源异常
31  SIGSYS／SYSUNUSED    dump    系统调用异常

# 信号类型列表

编号信号名称缺省动作说明

1 SIGHUP 终止终止控制终端或进程

2 SIGINT 终止键盘产生的中断(Ctrl-C)

3 SIGQUIT dump 键盘产生的退出

4 SIGILL dump 非法指令

5 SIGTRAP dump debug中断

6 SIGABRT／SIGIOT dump 异常中止

7 SIGBUS／SIGEMT dump 总线异常/EMT指令

8 SIGFPE dump 浮点运算溢出

9 SIGKILL 终止强制进程终止

10 SIGUSR1 终止用户信号,进程可自定义用途

11 SIGSEGV dump 非法内存地址引用

12 SIGUSR2 终止用户信号，进程可自定义用途

13 SIGPIPE 终止向某个没有读取的管道中写入数据

14 SIGALRM 终止时钟中断(闹钟)

15 SIGTERM 终止进程终止

16 SIGSTKFLT 终止协处理器栈错误

17 SIGCHLD 忽略子进程退出或中断

18 SIGCONT 继续如进程停止状态则开始运行

19 SIGSTOP 停止停止进程运行

20 SIGSTP 停止键盘产生的停止

21 SIGTTIN 停止后台进程请求输入

22 SIGTTOU 停止后台进程请求输出

23 SIGURG 忽略 socket发生紧急情况

24 SIGXCPU dump CPU时间限制被打破

25 SIGXFSZ dump 文件大小限制被打破

26 SIGVTALRM 终止虚拟定时时钟

27 SIGPROF 终止 profile timer clock

28 SIGWINCH 忽略窗口尺寸调整

29 SIGIO/SIGPOLL 终止 I/O可用

30 SIGPWR 终止电源异常

31 SIGSYS／SYSUNUSED dump 系统调用异常

其他

执行系统命令

$process = new swoole_process(function (swoole_process $worker) {

    $worker -> exec('/bin/ps', ['-ef']);

}, false);

$pid = $process->start();

swoole_process::wait();

$process = new swoole_process(function (swoole_process $worker) {

$worker -> exec('/bin/ps', ['-ef']);

}, false);

$pid = $process->start();

swoole_process::wait();

会输出 ps -ef执行后内容。

回收

子进程结束必须要执行wait进行回收，否则子进程会变成僵尸进程

守护进程

使当前进程脱变为一个守护进程。

swoole_process::daemon();

while (true) {
    echo "hello";
    sleep(1);
}

swoole_process::daemon();

while (true) {

echo "hello";

sleep(1);

}

命名进程

$process = new swoole_process(function (swoole_process $worker) {

    $worker -> name('child_namne_process_#' . $worker->pid);

    sleep(10);

}, false);

$pid = $process->start();

swoole_process::wait();

$process = new swoole_process(function (swoole_process $worker) {

$worker -> name('child_namne_process_#' . $worker->pid);

sleep(10);

}, false);

$pid = $process->start();

swoole_process::wait();

ps -ef 

root     24211 11981  0 16:48 pts/2    00:00:00 php process_name.php
root     24212 24211  0 16:48 pts/2    00:00:00 child_namne_process_#24212

ps -ef

root 24211 11981 0 16:48 pts/2 00:00:00 php process_name.php

root 24212 24211 0 16:48 pts/2 00:00:00 child_namne_process_#24212

CPU亲和性

设置CPU亲和性，可以将进程绑定到特定的CPU核上。

PHP

事务嵌套解决方案

2016年2月29日 chen

mysql官方并不支持事务嵌套，当第二个事务开始时候，会隐式的先调用commit提交之前的事务，而后在开启第二次的事务。

在正常开发中难免会出现失误嵌套的情况。如何解决呢？

laravel/lumen框架使用了mysql的SAVEPOINT方法来解决这一问题。

mysql savepoint

首先来看下mysql原生案例。

# 表结构
+----------+------------------+------+-----+---------+----------------+
| Field    | Type             | Null | Key | Default | Extra          |
+----------+------------------+------+-----+---------+----------------+
| id       | int(10) unsigned | NO   | PRI | NULL    | auto_increment |
| username | varchar(32)      | NO   |     | NULL    |                |
| password | varchar(32)      | NO   |     | NULL    |                |
+----------+------------------+------+-----+---------+----------------+

# 表结构

+----------+------------------+------+-----+---------+----------------+

+----------+------------------+------+-----+---------+----------------+

| id | int(10) unsigned | NO | PRI | NULL | auto_increment |

+----------+------------------+------+-----+---------+----------------+

2次开启事务案例

# 操作
mysql> begin;       # 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');
Query OK, 1 row affected (0.00 sec)

mysql> begin;       # 此处mysql会先提交前一个事务，再开启后一个事务。
Query OK, 0 rows affected (0.01 sec)

mysql> insert into user(username, password) values('ee', 'ee');
Query OK, 1 row affected (0.00 sec)

mysql> rollback;    # 事务回滚，把username=ee回滚掉了，而ff已插入数据库。
Query OK, 0 rows affected (0.00 sec)

# 操作

mysql> begin; # 开启事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');

Query OK, 1 row affected (0.00 sec)

mysql> begin; # 此处mysql会先提交前一个事务，再开启后一个事务。

Query OK, 0 rows affected (0.01 sec)

mysql> insert into user(username, password) values('ee', 'ee');

Query OK, 1 row affected (0.00 sec)

mysql> rollback; # 事务回滚，把username=ee回滚掉了，而ff已插入数据库。

Query OK, 0 rows affected (0.00 sec)

savepoint 案例

mysql> begin;                   # 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');
Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_1;       # 创建回滚点trans_1
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ee', 'ee');
Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_2;       # 创建回滚点trans_2
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('gg', 'gg');
Query OK, 1 row affected (0.00 sec)

mysql> ROLLBACK TO SAVEPOINT trans_2;   # 回滚到trans_2，将username=gg回滚掉了
Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('hh', 'hh');
Query OK, 1 row affected (0.00 sec)

mysql> commit;                  # 提交数据
Query OK, 0 rows affected (0.00 sec)

mysql> begin; # 开启事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ff', 'ff');

Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_1; # 创建回滚点trans_1

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('ee', 'ee');

Query OK, 1 row affected (0.00 sec)

mysql> SAVEPOINT trans_2; # 创建回滚点trans_2

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('gg', 'gg');

Query OK, 1 row affected (0.00 sec)

mysql> ROLLBACK TO SAVEPOINT trans_2; # 回滚到trans_2，将username=gg回滚掉了

Query OK, 0 rows affected (0.00 sec)

mysql> insert into user(username, password) values('hh', 'hh');

Query OK, 1 row affected (0.00 sec)

mysql> commit; # 提交数据

Query OK, 0 rows affected (0.00 sec)

上面例子中username=gg被回滚掉了，最终数据库中插入了username=ee,ff,hh。如果最后commit换成rollback所有数据将全部回滚。

laravel/lumen 实现

    /**
     * Start a new database transaction.
     *
     * @return void
     */
    public function beginTransaction()
    {
        ++$this->transactions;

        if ($this->transactions == 1) {
            $this->getPdo()->beginTransaction();
        } elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {
            $this->getPdo()->exec(
                $this->queryGrammar->compileSavepoint('trans'.$this->transactions)
            );
        }

        $this->fireConnectionEvent('beganTransaction');
    }

/**

* Start a new database transaction.

* @return void

public function beginTransaction()

{

++$this->transactions;

if ($this->transactions == 1) {

$this->getPdo()->beginTransaction();

} elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {

$this->getPdo()->exec(

$this->queryGrammar->compileSavepoint('trans'.$this->transactions)

);

}

$this->fireConnectionEvent('beganTransaction');

}

开启事务时检测当前transactions等级，如果等于1开启事务，如果大于1则创建相应level的savepoint。

    /**
     * Commit the active database transaction.
     *
     * @return void
     */
    public function commit()
    {
        if ($this->transactions == 1) {
            $this->getPdo()->commit();
        }

        --$this->transactions;

        $this->fireConnectionEvent('committed');
    }

/**

* Commit the active database transaction.

* @return void

public function commit()

{

if ($this->transactions == 1) {

$this->getPdo()->commit();

}

--$this->transactions;

$this->fireConnectionEvent('committed');

}

commit操作时候，检测当前transactions等级，如果不等于1跳过操作，并且transactions等级减1。如果等于1，事务提交。

    /**
     * Rollback the active database transaction.
     *
     * @return void
     */
    public function rollBack()
    {
        if ($this->transactions == 1) {
            $this->getPdo()->rollBack();
        } elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {
            $this->getPdo()->exec(
                $this->queryGrammar->compileSavepointRollBack('trans'.$this->transactions)
            );
        }

        $this->transactions = max(0, $this->transactions - 1);

        $this->fireConnectionEvent('rollingBack');
    }

/**

* Rollback the active database transaction.

* @return void

public function rollBack()

{

if ($this->transactions == 1) {

$this->getPdo()->rollBack();

} elseif ($this->transactions > 1 && $this->queryGrammar->supportsSavepoints()) {

$this->getPdo()->exec(

$this->queryGrammar->compileSavepointRollBack('trans'.$this->transactions)

);

}

$this->transactions = max(0, $this->transactions - 1);

$this->fireConnectionEvent('rollingBack');

}

而rollback操作，检测当前transactions等级，如果不等于1回滚到相应等级的savepoint，等于1这全部回滚。

PHP

Functional Programming

2016年2月20日 chen

函数式编程是什么
函数式编程的特点
函数式编程的意义
函数式编程的几个技术

一、函数式编程是什么？

函数式编程就是编写纯函数，尽可能移除隐含的输入与输出，这样我们的代码就是仅描述输入与输出之间关系的代码。

1、纯函数

Q: 什么是纯函数？
A: 该函数所有的输入都是显示的（无隐含输入），同样它的所有输出都是显示输出。

让我们来看2个例子：

# 示例1
# 设定参数int类型和返回值类型为php7特性
function square(int $x) : int {
    return $x * $x;
}

# 示例1

# 设定参数int类型和返回值类型为php7特性

function square(int $x) : int {

return $x * $x;

}

# 示例2
function processNext() {
    $message = Queue::pop();

    if ($message != null) {
        process($message);
    }
}

# 示例2

function processNext() {

$message = Queue::pop();

if ($message != null) {

process($message);

}

示例1我们可以清晰的知道输入的是一个int类型，输出的也是一个int类型。对于这种我们称之为纯函数。
而示例2这个函数既没有输入也没有输出，然而很明显它依赖着什么，并且很显然也在做着什么。但是我们不知道。对于这种我们称之为不纯函数。

为什么我们要写纯函数呢？因为不纯函数有很多副作用。详情可参考：
【译】什么是函数式编程？

二、函数式编程的特点

1、函数是”第一等公民”

所谓”第一等公民”（first class），指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

举例来说，下面代码中的$print变量就是一个函数，可以作为另一个函数的参数。

$print = function($i) {
    print_r($i);
};

$arr = [1,2,3];

array_map($print, $arr);
// 123

$print = function($i) {

print_r($i);

};

$arr = [1,2,3];

array_map($print, $arr);

// 123

2、没有”副作用”

所谓”副作用”（side effect），指的是函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。
函数式编程强调没有”副作用”，意味着函数要保持独立，所有功能就是返回一个新的值，没有其他行为，尤其是不得修改外部变量的值。

3、不修改状态

上一点已经提到，函数式编程只是返回新的值，不修改系统变量。因此，不修改变量，也是它的一个重要特点。
在其他类型的语言中，变量往往用来保存”状态”（state）。不修改变量，意味着状态不能保存在变量中。函数式编程使用参数保存状态，最好的例子就是递归。下面的代码是一个将字符串逆序排列的函数，它演示了不同的参数如何决定了运算所处的”状态”。

4、引用透明

引用透明（Referential transparency），指的是函数的运行不依赖于外部变量或”状态”，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
有了前面的第三点和第四点，这点是很显然的。其他类型的语言，函数的返回值往往与系统状态有关，不同的状态之下，返回值是不一样的。这就叫”引用不透明”，很不利于观察和理解程序的行为。

三、函数式编程的意义

简单的说函数式编程有什么好处，我们为什么要去掌握它。

1、代码简洁，开发快速

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

2、接近自然语言，易于理解

函数式编程的自由度很高，可以写出很接近自然语言的代码。
用户函数式语言表达(1 + 2) * 3 - 4：

　　subtract(multiply(add(1,2), 3), 4);

1 2	subtract(multiply(add(1,2), 3), 4);

对它进行变形，不难得到另一种写法：

　　$obj -> add(1,2) -> multiply(3) -> subtract(4);

1 2	$obj -> add(1,2) -> multiply(3) -> subtract(4);

3、更方便的代码管理

函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。

4、易于”并发编程”

函数式编程不需要考虑”死锁”（deadlock），因为它不修改变量，所以根本不存在”锁”线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署”并发编程”（concurrency）。

四、函数式编程的几个技术

1、 map、 reduce & filte

函数式编程中，我们不应该用循环迭代的方式，我们应该用更为高级的方法。

# 循环
$len = function($str) {
    return strlen($str);
};
$strings = [
    'hello', 'world', 'functional'
];

$lens = array_map($len, $strings);

print_r($lens);
/*
Array
(
    [0] => 5
    [1] => 5
    [2] => 10
)
*/

# 循环

$len = function($str) {

return strlen($str);

};

$strings = [

'hello', 'world', 'functional'

];

$lens = array_map($len, $strings);

print_r($lens);

Array

(

[0] => 5

[1] => 5

[2] => 10

)

这样的代码很易读，因为，这样的代码是在描述要干什么，而不是怎么干。

# 过滤
$filter = function($int) {
    return($int & 1);
};

$nums = [1,2,3,4,5,6,7,8,9];

$odd = array_filter($nums, $filter);

print_r($odd);
/*
Array
(
    [0] => 1
    [2] => 3
    [4] => 5
    [6] => 7
    [8] => 9
)
*/

# 过滤

$filter = function($int) {

return($int & 1);

};

$nums = [1,2,3,4,5,6,7,8,9];

$odd = array_filter($nums, $filter);

print_r($odd);

Array

(

[0] => 1

[2] => 3

[4] => 5

[6] => 7

[8] => 9

)

$reduceToTable = function($html, $p) {
   $html .= "<TR><TD><a href=\"$p.html\">$p</a></td></tr>\n";
   return $html;
};

$list = ["page1", "page2", "page3"];

$table = array_reduce($list, $reduceToTable);
echo "<table>\n".$table . "</table>\n";

/*
<table>
<TR><TD><a href="page1.html">page1</a></td></tr>
<TR><TD><a href="page2.html">page2</a></td></tr>
<TR><TD><a href="page3.html">page3</a></td></tr>
</table>
*/

$reduceToTable = function($html, $p) {

$html .= "<TR><TD><a href=\"$p.html\">$p</a></td></tr>\n";

return $html;

};

$list = ["page1", "page2", "page3"];

$table = array_reduce($list, $reduceToTable);

echo "<table>\n".$table . "</table>\n";

<table>

</table>

2、 pipeline

详情参考我的另外一篇博客：pipeline

3、 recursing 递归

递归最大的好处就简化代码，他可以把一个复杂的问题用很简单的代码描述出来。注意：递归的精髓是描述问题，而这正是函数式编程的精髓。

通常递归的效率低下，内存占用量比较大，这是它长期不能在业界推广的主要原因。

所以这里推荐使用尾递归。

递归和尾递归有何区别？

以斐波那契数列为例：

/**
 * 递归
 */
function f1($a) {
    if ($a <= 1) {
        return 1 ;
    }
    else {
        return f1($a - 1) + f1($a - 2);
    }
}

/**
 * 尾递归
 */
function f2($a, $b, $n) {
    if ($n == 0) {
        return $a;
    } else {
        return f2($b, $a + $b, $n - 1);
    }
}

/**

* 递归

function f1($a) {

if ($a <= 1) {

return 1 ;

}

else {

return f1($a - 1) + f1($a - 2);

}

/**

* 尾递归

function f2($a, $b, $n) {

if ($n == 0) {

return $a;

} else {

return f2($b, $a + $b, $n - 1);

}

初看一下没有看出什么太大区别。但是执行效率却是天差地别。

递归函数在return的时候进行了计算f1($a - 1) + f1($a - 2)。这个时候计算机底层就会创建stack累积而后计算

f1(4);
return f1(3) + f1(2);
return f1(2) + f1(1) + f1(2);
return f1(1) + f1(0) + f1(1) + f1(2);
return 1 + 1 + 1 + f1(2);
return 1 + 1 + 1 + f1(1) + f1(0);
return 1 + 1 + 1 + 1 + 1;
5;

f1(4);

return f1(3) + f1(2);

return f1(2) + f1(1) + f1(2);

return f1(1) + f1(0) + f1(1) + f1(2);

return 1 + 1 + 1 + f1(2);

return 1 + 1 + 1 + f1(1) + f1(0);

return 1 + 1 + 1 + 1 + 1;

这个曲线就代表内存占用大小的峰值，从左到右，达到顶峰，再从右到左收缩。

而尾递归不会如此耗内存。

f2(1, 1, 4);
return f2(1, 2, 3);
return f2(2, 3, 2);
return f2(3, 5, 1);
return f2(5, 8, 0);
return $a;
5;

f2(1, 1, 4);

return f2(1, 2, 3);

return f2(2, 3, 2);

return f2(3, 5, 1);

return f2(5, 8, 0);

return $a;

他的内存比较平稳。

下面是一个f1和f2以及循环测试，展示他们各自的使用时间，可以看出他们之间的巨大差别。

            时间  
f1(33)      3.05s
f2(33)      0.00015s
for(33)     0.00011s

时间

f1(33) 3.05s

f2(33) 0.00015s

for(33) 0.00011s

4、 currying 柯里化

写一个数组连接成字符串的函数

$concatArray = function($arr) {
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};
echo $concatArray([1,2,3]), "\n"; // 123

$concatArray = function($arr) {

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3]), "\n"; // 123

现在我要其中所有数字加1, 然后在连接

$concatArray = function($arr, $plus) {
    $arr = array_map(function($i) use($plus) {
        return $i + $plus;
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

echo $concatArray([1,2,3], 1), "\n"; // 234

$concatArray = function($arr, $plus) {

$arr = array_map(function($i) use($plus) {

return $i + $plus;

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3], 1), "\n"; // 234

然后结果所有数字乘以2, 再进行连接

$concatArray = function($arr, $plus, $multiple) {
    $arr = array_map(function($i) use ($plus) {
        return $i + $plus;
    }, $arr);
    $arr = array_map(function($i) use ($multiple) {
        return $i * $multiple;
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

echo $concatArray([1,2,3], 1, 2), "\n"; // 468

$concatArray = function($arr, $plus, $multiple) {

$arr = array_map(function($i) use ($plus) {

return $i + $plus;

}, $arr);

$arr = array_map(function($i) use ($multiple) {

return $i * $multiple;

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

echo $concatArray([1,2,3], 1, 2), "\n"; // 468

是不是觉得很烦了？
如果需要再添加一个功能，是不是又要添加一个参数了？
是不是违背了函数式编程简洁、接近人类语言的好处了？

这个使用就需要用到柯里化了。

什么是柯里化?

柯里化是这样的一个转换过程，把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，如果其他的参数是必要的，返回接受余下的参数且返回结果的新函数。

$concatArray = function($arr, $funcs) {
    $arr = array_reduce($funcs, function($result, $input) {
        return array_map($input, $result);
    }, $arr);
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

$plus = function($num) {
    return function($a) use ($num) {
        return $a + $num;
    };
};

$multiple = function($num) {
    return function($a) use ($num) {
        return $a * $num;
    };
}; 

$arr = [1,2,3];

echo $concatArray($arr, [$plus(1), $multiple(2)]), "\n";

$concatArray = function($arr, $funcs) {

$arr = array_reduce($funcs, function($result, $input) {

return array_map($input, $result);

}, $arr);

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

$plus = function($num) {

return function($a) use ($num) {

return $a + $num;

};

$multiple = function($num) {

return function($a) use ($num) {

return $a * $num;

};

$arr = [1,2,3];

echo $concatArray($arr, [$plus(1), $multiple(2)]), "\n";

这里有人就会说了，柯里化不是到最后变换成接受一个单一参数的函数吗？这里为什么还有2个参数？

其实如果将其转换为没想对象的来看他就是接收了一个参数：

$arrayObject -> concatArray([$plus(1), $multiple(2)]);

1 2	$arrayObject -> concatArray([$plus(1), $multiple(2)]);

当然还有其他非柯里化方式可以来实现简化如下：

$concatArray = function($arr) {
    return array_reduce($arr, function($result, $input) {
        return $result . $input;
    });
};

$plus = function($arr, $num) {
    return array_map(function($i) use($num) {
        return $i + $num;
    }, $arr);
};

$multiple = function($arr, $num) {
    return array_map(function($i) use($num) {
        return $i * $num;
    }, $arr);
}; 

$arr = [1,2,3];
echo $concatArray($multiple($plus($arr, 1), 2)), "\n"; // 468

$concatArray = function($arr) {

return array_reduce($arr, function($result, $input) {

return $result . $input;

});

};

$plus = function($arr, $num) {

return array_map(function($i) use($num) {

return $i + $num;

}, $arr);

};

$multiple = function($arr, $num) {

return array_map(function($i) use($num) {

return $i * $num;

}, $arr);

};

$arr = [1,2,3];

echo $concatArray($multiple($plus($arr, 1), 2)), "\n"; // 468

5、 higher order function 高阶函数

所谓高阶函数就是函数当参数，把传入的函数做一个封装，然后返回这个封装函数。现象上就是函数传进传出，就像面向对象对象满天飞一样。

6、 lazy evaluation 惰性求值

柯里化中我们的案例就又到了惰性求值。

7、 determinism 确定性

确定性就是只要输入参数一致，输出结果就是一致的。就像数学那样 f(x) = y ，这个函数无论在什么场景下，都会得到同样的结果。

参考以及转载自：
【译】什么是函数式编程？
阮一峰：函数式编程初探
 左耳朵耗子：函数式编程
 为什么要柯里化

PHP

swoole入门 —— C/S架构

2016年2月14日 chen

一、什么是swoole

官方定义：特别霸气。
Swoole：重新定义PHP

官方介绍：

PHP语言的异步、并行、高性能网络通信框架，使用纯C语言编写，提供了PHP语言的异步多线程服务器，异步TCP/UDP网络客户端，异步MySQL，数据库连接池，AsyncTask，消息队列，毫秒定时器，异步文件读写，异步DNS查询。

它让PHP能够做出了WEB以外的更多事。

二、安装

swoole是一个php扩展。安装方式与其他扩展一样。

也可以用pecl进行安装：

一、 DatabaseServiceProvider 服务提供者

1、 初始化Model

2、 注册Eloquent工厂

3、 注册可队列化实体解析器实现

4、 注册DB工厂

5、 注册DB

6、注册DB连接

二、 Eloquent\Model、Eloquent\Builder、Query\Builder、Schema\Builder

1、Eloquent\Model

2、Eloquent\Builder

3、 Query\Builder

4、 Schema\Builder

三、其他

1、 UML类图

1、 简介

2、编写命令

3、交互命令

3.1、 自定义参数

3.2、 输入提示

3.3、 不同的输出样式

4、调用command

多态

契约

服务容器和服务提供者

门面

单表软删除

多表软删除

状态模式

主要角色

为什么要用状态模式

代码实现

状态间切换的控制

状态切换

状态控制

基于事件

swoole_process

创建进程

进程间通信

管道

队列

信号

其他

执行系统命令

回收

守护进程

命名进程

CPU亲和性

mysql savepoint

laravel/lumen 实现

一、函数式编程是什么？

1、 纯函数

二、 函数式编程的特点

1、 函数是”第一等公民”

2、 没有”副作用”

3、 不修改状态

4、 引用透明

三、 函数式编程的意义

1、 代码简洁，开发快速

2、 接近自然语言，易于理解

3、 更方便的代码管理

4、易于”并发编程”

四、 函数式编程的几个技术

1、 map、 reduce & filte

2、 pipeline

3、 recursing 递归

4、 currying 柯里化

5、 higher order function 高阶函数

6、 lazy evaluation 惰性求值

7、 determinism 确定性

一、什么是swoole

二、安装

一、 `DatabaseServiceProvider` 服务提供者

1、初始化`Model`

2、注册`Eloquent`工厂

3、注册可队列化实体解析器实现

4、注册`DB工厂`

5、注册`DB`

6、注册`DB连接`

二、 `Eloquent\Model`、`Eloquent\Builder`、`Query\Builder`、`Schema\Builder`

1、`Eloquent\Model`

2、`Eloquent\Builder`

3、 `Query\Builder`

4、 `Schema\Builder`

1、简介

3.1、自定义参数

3.2、输入提示

3.3、不同的输出样式

1、纯函数

二、函数式编程的特点

1、函数是”第一等公民”

2、没有”副作用”

3、不修改状态

4、引用透明

三、函数式编程的意义

1、代码简洁，开发快速

2、接近自然语言，易于理解

3、更方便的代码管理

四、函数式编程的几个技术