borogadi

Laravel 5文档阅读摘要

Laravel 5项目结构分析及中文文档阅读摘要

HTTP路由 1

中间件 5

控制器 5

HTTP请求 7

HTTP 响应 8

视图 9

Service Providers 11

Service Container 12

Contracts 13

Facades 14

请求的生命周期 15

应用程序结构 16

认证 20

缓存 24

集合 26

Artisan Console 26

扩展框架* 27

Laravel Elixir* 27

加密 27

错误与日志 28

事件 28

文件系统 / 云存储 30

哈希 31

辅助方法 31

本地化* 31

邮件* 31

扩展包开发* 31

分页* 31

队列* 31

会话 32

Blade模板 33

单元测试* 35

数据验证 35

数据库使用基础 36

查询构造器 38

结构生成器 41

迁移和数据填充 41

Eloquent ORM 41

HTTP路由

基本路由

定义针对不同Http Method的路由，如：

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

Route::post('foo/bar', function(){

Route::match(['get', 'post'], '/', function(){ # 多个方法

Route::any('foo', function(){ # 所有方法

使用url方法生成url：$url = url('foo');

CSRF保护

Laravel会自动在每一位用户的session中放置随机的token。VerifyCsrfToken 中间件将保存在session中的请求和输入的token配对来验证token。除了寻找CSRF token 作为「POST」参数，中间件也检查X-XSRF-TOKEN请求头。

插入CSRF Token到表单：

在Blade模板引擎使用：

添加到X-XSRF-TOKEN请求头中：

$.ajaxSetup({

headers: {

'X-CSRF-TOKEN': $('meta[name="csrf-token"]').attr('content')

}

});

...

# 这样所有ajax请求中将会带上该头信息：

$.ajax({

url: "/foo/bar",

})

方法欺骗

路由参数

Route::get('user/{id}', function($id){ # 基础参数

Route::get('user/{name?}', function($name = null){ # 可选参数

Route::get('user/{name?}', function($name = 'John'){ # 带默认值的参数

可以定义参数的全局模式，在RouteServiceProvider的boot方法里定义模式：

$router->pattern('id', '[0-9]+');

之后，会作用在所有使用这个特定参数的路由上：

Route::get('user/{id}', function($id)

if ($route->input('id') == 1){ # 在路由外部取得参数

也可以通过依赖注入来取得参数：

use Illuminate\Http\Request;

Route::get('user/{id}', function(Request $request, $id){

if ($request->route('id')){

路由命名

Route::get('user/profile', ['as' => 'profile', function(){

# 为控制器动作指定路由名称

Route::get('user/profile', [

'as' => 'profile',

'uses' => 'UserController@showProfile'

]);

# 使用命名路由进行重定向

$url = route('profile');

$redirect = redirect()->route('profile');

# 返回当前路由请求的名称

$name = Route::currentRouteName();

路由群组

将共享属性作为一个数组当做Route::group第一个参数：

# 共享中间件

Route::group(['middleware' => ['foo', 'bar']], function()

{

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

{

// Has Foo And Bar Middleware

});

Route::get('user/profile', function()

{

// Has Foo And Bar Middleware

});

# 上例中foo和bar为中间件键名。自定义的中间件的键名与类名映射关系需要在Kernel.php中添加。

# 共享命名空间

Route::group(['namespace' => 'Admin'], function()

{

// Controllers Within The "App\Http\Controllers\Admin" Namespace

Route::group(['namespace' => 'User'], function()

{

// Controllers Within The "App\Http\Controllers\Admin\User" Namespace

});

子域名路由

Route::group(['domain' => '{account}.myapp.com'], function()

{

Route::get('user/{id}', function($account, $id)

{

});

路由前缀

Route::group(['prefix' => 'admin'], function()

{

Route::get('users', function()

{

// Matches The "/admin/users" URL

});

# 在路由前缀中定义参数

Route::group(['prefix' => 'accounts/{account_id}'], function()

{

Route::get('detail', function($account_id)

{

});

路由模型绑定

模型绑定提供方便的方式将模型实体注入到路由中：比起注入User ID，你可以选择注入符合给定ID的User类实体。在RouteServiceProvider::boot方法定义模型绑定：

public function boot(Router $router)

{

parent::boot($router);

$router->model('user', 'App\User');

}

然后定义一个有 {user} 参数的路由：

Route::get('profile/{user}', function(App\User $user){

});

请求至profile/1将注入ID为1的User实体。若实体不存在，则抛出404。可以传给第三个参数一个闭包，定义找不到时的行为。

抛出404错误

两种方法：

abort(404); # 本质上是抛出了一个带有特定状态码的Symfony\Component\HttpKernel\Exception\HttpException 。

或者：手工抛出HttpException

中间件

新建中间件

php artisan make:middleware OldMiddleware # 新建一个中间件

中间件的主要功能在handle()方法中实现：

class OldMiddleware {

public function handle($request, Closure $next){

if (xxx){

return redirect('xx');

}

return $next($request);

}

分析其结构可以发现，基本上就是执行一个判断，然后依次进行重定向或者继续向前。

全局中间件

若是希望中间件被所有的 HTTP 请求给执行，只要将中间件的类加入到app/Http/Kernel.php的$middleware 属性清单列表中。

指派中间件给路由

新建中间件后，在app/Http/Kernel.php的$routeMiddleware中添加中间件键名与类名的映射关系，然后就可以在路由中使用这个键名来指派路由：

Route::get('admin/profile', ['middleware' => 'auth', function(){

可终止中间件

可终止中间件需要继承自TerminableMiddleware，并实现terminate()方法。其用处是在HTTP响应已经被发送到用户端后再执行。可终止中间件需要添加到app/Http/Kernel.php的全局中间件清单中。

控制器

基础控制器

所有的控制器都应该扩展基础控制器类

<?php namespace App\Http\Controllers;

use App\Http\Controllers\Controller;

class UserController extends Controller { # 继承Controller

public function showProfile($id) # 动作

{

App\Http\Controllers\Controller的定义如下：

<?php

namespace Borogadi\Http\Controllers;

use Illuminate\Foundation\Bus\DispatchesJobs;

use Illuminate\Routing\Controller as BaseController;

use Illuminate\Foundation\Validation\ValidatesRequests;

abstract class Controller extends BaseController

{

use DispatchesJobs, ValidatesRequests;

}

可见最终是继承自Illuminate\Routing\Controller类。

# 命名控制器路由

Route::get('foo', ['uses' => 'FooController@method', 'as' => 'name']);

# 指向控制器的URL

$url = action('App\Http\Controllers\FooController@method');

或者：

URL::setRootControllerNamespace('App\Http\Controllers');

$url = action('FooController@method');

# 获取正在执行的控制器动作名称

$action = Route::currentRouteAction();

控制器中间件

两种方式，一是在控制器路由中指定：

Route::get('profile', [

'middleware' => 'auth',

'uses' => 'UserController@showProfile'

]);

另一种是直接在控制器构造器中指定：

class UserController extends Controller {

public function __construct(){

$this->middleware('auth');

$this->middleware('log', ['only' => ['fooAction', 'barAction']]);

隐式控制器

隐式控制器实现定义单一路由来处理控制器中的每一项行为：

定义一个路由：

Route::controller('users', 'UserController');

定义控制器类的实现：

class UserController extends BaseController {

public function getIndex(){ # 响应user

public function postProfile(){ # 响应post方式的user/profile

public function anyLogin(){ # 响应所有方式的user/login

可以通过使用“-”来支持多个字词的控制器行为：
public function getAdminProfile() {} # 响应users/admin-profile，不是user/adminprofile。注意动作名中使用的驼峰命名方法

RESTful资源控制器

其实就是隐式控制器的一个具体应用。

路由缓存

如果应用中只使用了控制器路由，则可以利用路由缓存来提高性能。

php artisan route:cache

缓存路由文件将会被用来代替app/Http/routes.php文件

HTTP请求

取得请求

两种方式，一是通过Request facade：

use Request;

$name = Request::input('name');

或者通过依赖注入：在控制器中的构造函数或方法对该类使用类型提示。当前请求的实例将会自动由服务容器注入：

<?php namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Illuminate\Routing\Controller;

class UserController extends Controller {

public function store(Request $request){

$name = $request->input('name');

若同时还有使用路由参数输入的数据，只需将路由参数置于其他依赖之后：

public function update(Request $request, $id){

取得输入数据

$name = Request::input('name'); # 取得特定输入数据

$name = Request::input('name', 'Sally'); # 取得特定输入数据，若没有则取得默认值

if (Request::has('name')){ # 确认是否有输入数据

$input = Request::all(); # 取得所有输入数据

$input = Request::only('username', 'password'); # 取得部分输入数据

$input = Request::except('credit_card'); # 取得部分输入数据排除法

$input = Request::input('products.0.name'); # 取得数组形式的数据

旧输入数据

Request::flash(); # 将当前的输入数据存进 session中

Request::flashOnly('username', 'email'); # 将部分数据存成session

Request::flashExcept('password'); # 将部分数据存成session，排除法

return redirect('form')->withInput(); # 重定向，同时将当期输入数据缓存到session

return redirect('form')->withInput(Request::except('password')); # 重定向，同时将当期输入的部分数据缓存到session

$username = Request::old('username'); # 取得前一次请求所保存的一次性Session

{{ old('username') }} # 在blade模板中显示旧输入数据

Laravel 所建立的 cookie 会加密并且加上认证记号。

$value = Request::cookie('name'); # 取得Cookie值

# 在响应中添加Cookies

$response = new Illuminate\Http\Response('Hello World');

$response->withCookie(cookie('name', 'value', $minutes));

$response->withCookie(cookie()->forever('name', 'value')); # 添加永久有效的Cookie

# 以队列方式添加Cookie，即在实际发送响应之前设置Cookie

Cookie::queue('name', 'value');

return response('Hello World');

上传文件

$file = Request::file('photo'); # 取得上传文件

if (Request::hasFile('photo')) # 确认文件是否有上传

if (Request::file('photo')->isValid()) # 确认上传的文件是否有效

Request::file('photo')->move($destinationPath); # 移动上传的文件

Request::file('photo')->move($destinationPath, $fileName); # 移动上传的文件，并重命名

其他的请求信息

$uri = Request::path(); # 取得请求 URI

if (Request::ajax()) # 判断一个请求是否使用了 AJAX

# 判断请求的方法

$method = Request::method();

if (Request::isMethod('post'))

if (Request::is('admin/*')) # 确认请求路径是否符合特定格式

$url = Request::url(); # 取得请求URL

HTTP 响应

基本响应

Route::get('/', function(){ # 返回字符串

return 'Hello World';

# 返回完整的Responses实例，有两种方法

返回Responses对象：

use Illuminate\Http\Response;

return (new Response($content, $status))

->header('Content-Type', $value);

或者使用response辅助方法：

return response($content, $status)->header('Content-Type', $value);

# 返回视图

return response()->view('hello')->header('Content-Type', $type);

# 添加Cookies

return response($content)->withCookie(cookie('name', 'value'));

重定向

return redirect('user/login'); # 使用redirect重定向方法

return redirect('user/login')->with('message', 'Login Failed'); # 重定向，并将当前数据保存至Session

return redirect()->back(); # 重定向至前一个位置

return redirect()->route('login'); # 重定向到特定路由

# 重定向到特定路由，并带参数

return redirect()->route('profile', [1]); # 路由的 URI 为：profile/{id}

return redirect()->route('profile', ['user' => 1]); # 路由的 URI 为：profile/{user}

# 根据控制器动作的重定向

return redirect()->action('App\Http\Controllers\HomeController@index');

return redirect()->action('App\Http\Controllers\UserController@profile', ['user' => 1]); # 带参数

其他响应

# 返回json

return response()->json(['name' => 'Abigail', 'state' => 'CA']);

# 返回jsonp

return response()->json(['name' => 'Abigail', 'state' => 'CA'])

->setCallback($request->input('callback'));

# 文件下载

return response()->download($pathToFile, $name, $headers);

响应宏

# 定义响应宏，通常定义在Provider的boot方法内

Response::macro('caps', function($value) use ($response){ # PHP在默认情况下，匿名函数不能调用所在代码块的上下文变量，而需要通过使用use关键字。use会复制一份变量到闭包内，也支持引用形式，如use ( &$rmb )

return $response->make(strtoupper($value));

});

# 调用响应宏

return response()->caps('foo');

视图

基本视图

# 视图定义文件路径及文件名：resources/views/greeting.php

<html>

<body>

<h1>Hello, <?php echo $name; ?></h1>

</body>

</html>

# 视图调用

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

{

return view('greeting', ['name' => 'James']); # 传给视图的参数为一个键值对数组

});

# 子文件夹视图调用定义位置：resources/views/admin/profile.php

return view('admin.profile', $data);

# 传递数据到视图的其他方法

$view = view('greeting')->with('name', 'Victoria'); # 传统方法

$view = view('greeting')->withName('Victoria'); # 魔术方法

$view = view('greetings', $data); #直接传数组 $data为一个键值对数组

# 共享数据给所有视图

自定义一个Provider，或者直接在AppServiceProvider的boot方法内添加：

view()->share('data', [1, 2, 3]);

或者：

View::share('data', [1, 2, 3]);

# 确认视图是否存在

if (view()->exists('emails.customer'))

# 从一个文件路径产生视图

return view()->file($pathToFile, $data);

视图组件

视图组件就是在视图被渲染前，会调用的闭包或类方法。

# 定义视图组件

<?php namespace App\Providers;

use View;

use Illuminate\Support\ServiceProvider;

class ComposerServiceProvider extends ServiceProvider {

public function boot(){

View::composer('profile', 'App\Http\ViewComposers\ProfileComposer'); # 使用类来指定视图组件

View::composer('dashboard', function($view){ # 使用闭包来指定视图组件

...

});

}

...

}

使用类来指定视图组件，在视图被渲染之前将调用所指定类的名为compose的方法。如上例中，ProfileComposer'类的定义为：

<?php namespace App\Http\ViewComposers;

use Illuminate\Contracts\View\View;

use Illuminate\Users\Repository as UserRepository;

class ProfileComposer {

protected $users;

public function __construct(UserRepository $users){ # service container 会自动解析所需的参数

$this->users = $users;

}

public function compose(View $view){ # compose方法被传入了一个View的实例，在此可以传参给View

$view->with('count', $this->users->count());

}

# 在视图组件内使用通配符

View::composer('*', function($view){ # 相当于定义给所有视图

# 同时对多个视图附加视图组件

View::composer(['profile', 'dashboard'], 'App\Http\ViewComposers\MyViewComposer');

# 定义多个视图组件

View::composers([

'App\Http\ViewComposers\AdminComposer' => ['admin.index', 'admin.profile'],

'App\Http\ViewComposers\UserComposer' => 'user',

'App\Http\ViewComposers\ProductComposer' => 'product'

]);

Service Providers

每个自定义的Provider都必须继承自Illuminate\Support\ServiceProvider，并在config/app.php中的Providers数组中注册。自定义的Provider必须定义register()方法，用于定义注册时的行为。此外还有两个可选方法和一个可选属性：boot()方法在所有的Provider都被加载后才会调用，而provides()方法用来和$defer可选属性配合，提供缓载功能。

通过服务提供者的方式来提供服务的思路：实现一个完成实际工作的类，定义一个Provider，并在Provider的register()方法中往系统容器注册实际工作类以及获取实际工作类实例的方法。然后再在应用配置中注册这个Provider。这样，应用初始化时会调用所有Provider的register()方法来间接注册获取实际工作类实例的方式。

# 定义一个基本Provider

<?php namespace App\Providers;

use Riak\Connection;

use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider {

public function register(){

# 往容器中注册一个类及获取其实例的方法

$this->app->singleton('Riak\Contracts\Connection', function($app){

return new Connection($app['config']['riak']);

});

}

Service Container

基本用法

在Provider内部，可以通过$this->app来访问服务容器。

注册依赖主要有两种方式：回调接口方式和绑定实例接口。

# 闭包回调的方式

$this->app->bind('FooBar', function($app){

return new FooBar($app['SomethingElse']);

});

# 以单例方式注册，之后的调用都返回相同的实例

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

return new FooBar($app['SomethingElse']);

});

# 绑定为一个已经存在的实例

$fooBar = new FooBar(new SomethingElse);

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

从容器解析出实例也有两种方式：

$fooBar = $this->app->make('FooBar'); # 使用make()方法解析

$fooBar = $this->app['FooBar']; # 因为容器实现了ArrayAccess接口，所以可以用数组访问形式

在定义好注册、解析信息后，就可以直接在类的构造函数中通过type-hint的方式指定所需要的依赖，容器将自动注入所需要的所有依赖。

<?php namespace App\Http\Controllers;

use Illuminate\Routing\Controller;

use App\Users\Repository as UserRepository;

class UserController extends Controller {

protected $users;

public function __construct(UserRepository $users){ # type-hint

$this->users = $users;

}

public function show($id){

}

绑定接口

interface EventPusher {

public function push($event, array $data);

}

class PusherEventPusher implements EventPusher {

...

}

因为PusherEventPusher类实现了EventPusher接口，所以可以直接注册这个接口并绑定为某个实现了该接口的类：

$this->app->bind('App\Contracts\EventPusher', 'App\Services\PusherEventPusher');

当有类需要EventPusher接口时，会告诉容器应该注入PusherEventPusher。

上下文绑定

$this->app->when('App\Handlers\Commands\CreateOrderHandler')

->needs('App\Contracts\EventPusher')

->give('App\Services\PubNubEventPusher');

标签

$this->app->bind('SpeedReport', function(){

});

$this->app->bind('MemoryReport', function(){

});

$this->app->tag(['SpeedReport', 'MemoryReport'], 'reports'); # 将上两步注册的类打成一个标签‘reports’

一旦服务打上标签，可以通过 tagged 方法轻易地解析它们：

$this->app->bind('ReportAggregator', function($app){

return new ReportAggregator($app->tagged('reports'));

});

容器事件

容器在解析每一个对象时就会触发一个事件。可以用resolving方法来监听此事件（被解析的对象将被传入到闭包方法中）：

$this->app->resolving(function($object, $app){ # 当容器解析任意类型的依赖时被调用

...

});

$this->app->resolving(function(FooBar $fooBar, $app){ # 当容器解析’FooBar’类型的依赖时被调用

...

});

Contracts

Contracts是所有Laravel主要组件实现所用的接口，可以看到Contracts目录下的目录结构和Illuminate中的一样。Contracts中为接口定义，Illuminate为具体实现。Illuminate中每个具体实现的类都扩展了其在Contracts中对应的接口。这样将接口和实现相分离，可以使依赖注入变得低耦合。

/laravel

/framework

/src

/Illuminate

/Auth

/Broadcasting

/Bus

...

/Contracts

/Auth

/Broadcasting

/Bus

...

Facades

基本用法

Facades提供一个静态接口给在应用程序的服务容器中可以取用的类。（设计模式中“装饰模式”的一个应用，主要是使用class_alias来创建类别名，另外使用__callStatic()来提供一个静态代理，其最终是使用模拟对象的方式模拟PHP对象并调用对象的方法）

Laravel的facades和你建立的任何自定义facades，将会继承基类Facade，并只需要去实现一个方法：getFacadeAccessor()。

如Cache这个facade的调用：$value = Cache::get('key');

看一下类的实现：

class Cache extends Facade {

protected static function getFacadeAccessor() { return 'cache'; } # 该方法的作用就是返回服务容器绑定的名称

}

当用户在Cache的facade上执行任何的静态方法，Laravel会从服务容器解析被绑定的cache ，并对该对象执行被请求的方法 (在这个例子中，get)

所有的facades存在于全局命名空间，当在有嵌套的命名空间中使用时，需要导入facade类进入命名空间：

<?php namespace App\Http\Controllers;

use Cache; # 导入Cache facade

class PhotosController extends Controller {

public function index(){

$photos = Cache::get('photos');

}

建立Facades

自定义一个facade需要3步：

1.一个服务容器绑定

2.一个facade类

3.一个facade别名配置

比如现有一个如下类：

namespace PaymentGateway;

class Payment {

public function process(){

}

首先绑定到服务容器： # 当然更好的实现方式是用一个Provider包装一下，然后把以下绑定添加到register()中

App::bind('payment', function(){

return new \PaymentGateway\Payment;

});

然后定义一个facade类：

use Illuminate\Support\Facades\Facade;

class Payment extends Facade {

protected static function getFacadeAccessor() { return 'payment'; }

}

最后在config/app.php配置文件为facade加个别名到aliases数组。

'aliases' => [

‘Payment’ =>PaymentGateway\Payment::class,

这时就可以调用该facade了：

Payment::process();

请求的生命周期

（1）通过服务器配置将public/index.php设为所有请求的进入点；

（2）index.php中通过require __DIR__.'/../bootstrap/autoload.php';加载所有需要与加载的项，在autoload.php中，通过如下调用实现：require __DIR__.'/../vendor/autoload.php';即加载了vendor目录下的所有由Composer管理的库。

（3）index.php接收由bootstrap/app.php文件所产生的Laravel应用程序实例：

index.php中：$app = require_once __DIR__.'/../bootstrap/app.php';

而bootstrap/app.php中文件最后：return $app;

再看一下Application类的实际定义：

class Application extends Container implements ApplicationContract, HttpKernelInterface

由此可知，Application实际就是一个Container。

查看一下Application的构造函数：

public function __construct($basePath = null){

$this->registerBaseBindings(); # 初始化Container环境

$this->registerBaseServiceProviders(); # 注册系统级事件服务和路由服务

$this->registerCoreContainerAliases(); # 添加系统所有facade别名关联

if ($basePath) {

$this->setBasePath($basePath);

}

（4）index.php中新建HTTP核心对象：$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);该核心对象是所有请求流向的中心位置。其构造函数签名如下：

public function __construct(Application $app, Router $router)

再看一下Application类中的make方法定义：

public function make($abstract, array $parameters = []){

if (isset($this->deferredServices[$abstract])) { # 注册缓载Providers

（5）HTTP核心对象中定义了一个bootstrappers数组，在http请求被执行前，会加载数组中定义的所有启动项，具体功能包括配置错误处理、日志记录、侦测应用程序环境等等；

（6）HTTP核心对象中定义了2个HTTP中间件清单（Illuminate\Foundation\Http\Kernel中是空数组，App\Http\Kernel类继承后在数组中加入了具体的项），$middleware数组定义全局的中间件，$routeMiddleware定义了特定路由的中间件。

（7）index.php中最终实际是调用了kernel的核心方法handle()，handle()方法接收一个Request，返回一个Response；

（8）handle方法中实际调用了路由分发等：$this->router->dispatch($request);

应用程序结构

Laravel 5全面采用新的自动加载标准PSR-4。PSR-4是关于由文件路径自动载入对应类的相关规范。描述了完整类名、命名空间前缀、文件基目录、文件路径这4者之间的关系。详情可参考：https://github.com/PizzaLiu/PHP-FIG/blob/master/PSR-4-autoloader-cn.md

~/.composer/vendor/bin/laravel new borogadi 命令创建项目后，生成了如下结构的项目，目录结构相对旧版本有较大变化，Laravel 5项目目录结构及说明如下：

borogadi

/app

/Console

/Commands 命令对象，可以作为队列任务

/Inspire.php

/Kernel.php

/Events

/Event.php

/Exceptions

/Handler.php

/Http

/Controllers 控制器

/Auth

/AuthController.php

/PasswordController.php

/Controller.php

/Middleware 中间件（过滤器）

/Authenticate.php

/EncryptCookies.php

/RedirectIfAuthenticated.php

/VerifyCsrfToken.php 自动验证保存在session中的CSRF token与用户发送过来的是否一致（Laravel会自动在每一位用户的session中放置随机的token，用于防止跨站伪造请求攻击）。具体验证行为主要是两个，一个是post数据中的_token值（表单），另一个是X-XSRF-TOKEN请求头（ajax）。此外，Laravel会在Cookies中放置这个值。

/Requests 请求

/Requests.php

/Kernel.php 定义应用程序全局中间件列表（$middleware），以及不同路由需要执行的中间件列表（$routeMiddleware）

/routes.php 路由定义文件，被/Providers/RouteServiceProvider.php文件所require

/Jobs

/Job.php

/Listeners

/Providers 服务提供者，全都继承自ServiceProvider 自定义的Provider可以考虑放在这里

/AppServiceProvider.php

/EventServiceProvider.php

/RouteServiceProvider.php 继承自Illuminate\Foundation\Support\Providers\RouteServiceProvider，并require了/app/Http/routes.php文件

/Users.php

/bootstrap

/cache

services.json

/app.php

/autoload.php

/config 项目配置

可以使用Config facade来获取或设置配置，如：Config::get('app.timezone'); 也可以使用config方法：$value = config('app.timezone');

可以使用 Artisan 命令config:cache将所有的配置文件缓存到单一文件。通过命令会将所有的配置选项合并成一个文件，让框架能够快速加载。

/app.php 应用程序配置，主要包括：

是否打开调试模式

时区、地理位置等本地化配置

providers 所有用到的服务提供者

aliases 所有类别名定义

/auth.php

/broadcasting.php

/cache.php

/compile.php

/database.php

/filesystems.php

/mail.php

/queue.php

/services.php

/session.php

/view.php

/database

/factories

/ModelFactory.php

/migrations

/2014_10_12_000000_create_users_table.php

/2014_10_12_100000_create_password_resets_table.php

/seeds

/DatabaseSeeder.php

/public

/.htaccess 分布式配置文件，提供了针对目录改变配置的方法，可以通过Apache的AllowOverride指令来设置是否启用

/favicon.ico

/index.php

/robots.txt

/resources 资源文件，包括视图、语言文件等

/assets

/sass

/app.scss .scss文件是sass工具使用的文件。sass是一个用来开发CSS的工具，可以像编程一样来开发CSS（生成的文件后缀名就是.scss），然后编译转换为实际的CSS文件

/lang

/en 在/config/app.php中可以指定 'locale' => 'en'等本地化设置

/auth.php

/pagination.php

/passwords.php

/validation.php

/view

/errors

/503.blade.php 维护模式响应视图，当应用程序处于维护模式中，将不会处理任何队列工作。所有的队列工作将会在应用程序离开维护模式后继续被进行。

启用网站维护模式：php artisan down

关闭网站维护模式：php artisan up

/vendor

/welcome.blade.php

/storage

/app

/framework

/cache

/sessions

/e974577fcae1531911b8e227f5b3041fcf2da5cf

/views

/74ea641521c4c2e25fef87398795c7c3

/logs

/tests

/ExampleTest.php

/TestCase.php

/vendor

/bin

/composer

/danieIstjules

/dnoegel

/doctrine

/fzaninotto

/hamcrest

/jakub-onderka

/jeremeamia

/laravel

/framework

/src

/Illuminate

/Auth

/Broadcasting

/Bus

...

/Contracts 所有Laravel主要组件实现所用的接口，可以看到Contracts目录下的目录结构和Illuminate中的一样。Contracts中为接口定义，Illuminate为具体实现。Illuminate中每个具体实现的类都扩展了其在Contracts中对应的接口。这样将接口和实现相分离，可以使依赖注入变得低耦合。

/Auth

/Broadcasting

/Bus

...

/league

/mockery

/monolog

/mtdowling

/nesbot

/nikic

/phpdocumentor

/phpspec

/phpunit

/psr

/psy

/sebastian

/swiftmailer

/symfony

/vlucas

autoload.php

/artisan

/composer.json

/composer.lock

/gulpfile.js

/package.json

/phpspec.xml

/sever.php

/.env 本地环境配置，该文件是在版本控制之外的。主要定义：APP_DEBUG、APP_KEY、CACHE_DRIVER、SESSION_DRIVER等等

Laravel通过DotEnv（https://github.com/vlucas/phpdotenv）写的一个类库来加载.env中的配置，当应用程序收到请求，.env中所有的变量都会被加载到$_ENV这个超级全局变量中，然后可以使用env()这个辅助方法来查看，如：'debug' => env('APP_DEBUG', false),

/.env.example

总结一下：

（1）控制器位置：/app/Http/Controllers

（2）视图位置：/app/resources/views

（）路由定义：app/Http/routes.php

（3）需要有写入权限的目录和文件：

1）/storage

2）/vendor

3）/bootstrap/cache

（4）配置加载流程：

1）.env中为版本控制之外的环境配置，通过env()方法来访问

2）/config目录中为各个模块的配置，通过Config facade或者config方法来访问

（）注册Provide位置：config/app.php中的Provides数组

认证

认证服务模型

Laravel提供了一个认证服务，配置文件为config/auth.php，需要和满足特定条件的数据库表了配合使用。在app/User.php文件中定义了User模型：

class User extends Model implements AuthenticatableContract, CanResetPasswordContract{

protected $table = 'users'; # User模型所映射的数据库表名

protected $fillable = ['name', 'email', 'password']; # 数据库字段

protected $hidden = ['password', 'remember_token']; # 以json形式返回用户信息时，需要排除的字段

}

模型所映射的数据库表（比如users）必须满足以下条件：

1.password列的长度至少为60

2.必须包含一个名为remember_token的列，该列可为空，长度为100。这个列将用来存储session token。

控制器

Laravel提供了2个有关用户认证的控制器，都在app/Http/Controllers/Auth目录下：AuthController用来处理新用户注册，PasswordController用来处理已注册用户的密码重置。这2个控制器通过引入trait的方式进行工作，一般不需要做任何修改。

路由

需要手动往app/Http/routes.php文件添加指向到认证控制的路由，如：

# 认证路由

Route::get('auth/login', 'Auth\AuthController@getLogin');

Route::post('auth/login', 'Auth\AuthController@postLogin');

Route::get('auth/logout', 'Auth\AuthController@getLogout');

# 注册路由

Route::get('auth/register', 'Auth\AuthController@getRegister');

Route::post('auth/register', 'Auth\AuthController@postRegister');

视图

需要手工实现登录和注册的视图：

# 用户登录视图

resources/views/auth/login.blade.php

{!! csrf_field() !!}

<div>

</div>

<div>

Password

</div>

<div>

<input type="checkbox" name="remember"> Remember Me

</div>

<div>

<button type="submit">Login</button>

</div>

</form>

# 用户注册视图

{!! csrf_field() !!}

<div>

Name

</div>

<div>

</div>

<div>

Password

</div>

<div>

Confirm Password

</div>

<div>

<button type="submit">Register</button>

</div>

</form>

流程

当用户成功登录后，默认会重定向至/home这个路由，所以需要在路由配置中添加这一条路由。也可以在AuthController中重写redirectPath属性来修改默认的设置，如：

protected $redirectPath = '/dashboard'; # 用户登录后重定向至/dashboard

当用户登录失败时，默认会重定向至/auth/login这个路由，可以通过重写AuthController中的loginPath属性来修改：

protected $loginPath = '/login'; # 用户登录失败后重定向至/login

自定义

要自定义认证行为，需要修改AuthController的validator方法。

要自定义注册行为（比如添加其他字段），需要修改AuthController的create方法。

获取登录用户

$user = Auth::user(); # 使用Auth facade获取登录用户

class ProfileController extends Controller{

public function updateProfile(Request $request){

if ($request->user()) { # 通过Request对象来获取登录用户

}

判断用户是否登录

if (Auth::check()) {

// The user is logged in...

}

保护路由

保护路由中间件auth定义在app\Http\Middleware\Authenticate.php文件中，可以通过如下方式为需要登录保护的路由添加该中间件：

# 为普通路由添加

Route::get('profile', ['middleware' => 'auth', function() {

...

}]);

# 为控制器路由添加

Route::get('profile', [

'middleware' => 'auth',

'uses' => 'ProfileController@show'

]);

# 直接在控制器的构造函数中添加

public function __construct(){

$this->middleware('auth');

}

认证限制

如果使用Laravel自带的AuthController，可以使用Illuminate\Foundation\Auth\ThrottlesLogins 这个trait来限制登录次数。它将根据唯一的用户名、email、ip地址来进行限制：当数次登录尝试失败后，一分钟内将不能再进行登录操作。

class AuthController extends Controller{

use AuthenticatesAndRegistersUsers, ThrottlesLogins;

}

手工进行用户认证

class AuthController extends Controller{

public function authenticate(){

if (Auth::attempt(['email' => $email, 'password' => $password])) { # 会查找指定email值的用户，若找到了，则再比较password的hash值。

// Authentication passed...

return redirect()->intended('dashboard');

}

# 添加认证条件：active为1

if (Auth::attempt(['username' => $username, 'password' => $password, 'active' => 1])) {

// The user is active, not suspended, and exists.

}

# 注销登录

Auth::logout();

记住用户

需要数据库包含remember_token列，并在调用attempt方法时传入一个$remember参数。这样，除非用户手工进行注销，否则将会记住用户的登陆态。

if (Auth::attempt(['email' => $email, 'password' => $password], $remember)) {

// The user is being remembered...

}

在使用了记住用户的情况下获取用户信息：

if (Auth::viaRemember()) {

}

重置密码
1.用户类必须实现了Illuminate\Contracts\Auth\CanResetPassword接口，且使用了Illuminate\Auth\Passwords\CanResetPassword这个trait（自带的User类已经实现）。

2.生成一个数据库表来存储重设密码标志。Laravel默认已经包含了这个迁移表，放在database/migrations目录下。通过如下命令执行迁移：

php artisan migrate

3.往Auth\PasswordController中添加路由：

// Password reset link request routes...

Route::get('password/email', 'Auth\PasswordController@getEmail');

Route::post('password/email', 'Auth\PasswordController@postEmail');

// Password reset routes...

Route::get('password/reset/{token}', 'Auth\PasswordController@getReset');

Route::post('password/reset', 'Auth\PasswordController@postReset');

4.重置密码视图 resources/views/auth/password.blade.php

{!! csrf_field() !!}

<div>

</div>

<div>

Send Password Reset Link

</button>

</div>

</form>

5.重置密码邮件视图 resources/views/emails/password.blade.php

Click here to reset your password: {{ url('password/reset/'.$token) }}

6.重置密码确认视图 resources/views/auth/reset.blade.php

{!! csrf_field() !!}

<div>

</div>

<div>

</div>

<div>

</div>

<div>

Reset Password

</button>

</div>

</form>

7.可以设置PasswordController的$redirectTo属性来指定重设密码后的重定向路由：

protected $redirectTo = '/dashboard';

第三方登录认证

Laravel提供第三方认证模块进行OAuth认证，目前支持的第三方认证有：Facebook, Twitter, LinkedIn, Google, GitHub and Bitbucket.

缓存

缓存方法

Laravel为各种不同的缓存系统提供一致的API。缓存配置文件位在config/cache.php 。

# 保存对象到缓存中

Cache::put('key', 'value', $minutes);

# 使用Carbon对象配置缓存过期时间

$expiresAt = Carbon::now()->addMinutes(10);

Cache::put('key', 'value', $expiresAt);

# 若是对象不存在，则将其存入缓存中，当对象确实被加入缓存时，使用add方法将会返回true否则会返回false 。

Cache::add('key', 'value', $minutes);

# 确认对象是否存在

if (Cache::has('key'))

# 从缓存中取得对象

$value = Cache::get('key');

# 取得对象或是返回默认值

$value = Cache::get('key', 'default');

$value = Cache::get('key', function() { return 'default'; });

# 永久保存对象到缓存中

Cache::forever('key', 'value');

# 从缓存中取得一个对象，若不存在则存入一个值。所有保存在缓存中的对象皆会被序列化

$value = Cache::remember('users', $minutes, function(){

return DB::table('users')->get();

});

# 结合remember和forever方法

$value = Cache::rememberForever('users', function(){

return DB::table('users')->get();

});

# 从缓存中取得对象后将它删除

$value = Cache::pull('key');

# 从缓存中删除对象

Cache::forget('key');

# 获取特定的缓存存储（应用于使用多种缓存进行存储时）

$value = Cache::store('foo')->get('key');

递增与递减

除了数据库以外的缓存系统都支持递增和递减操作

# 递增

Cache::increment('key');

Cache::increment('key', $amount);

# 递减

Cache::decrement('key');

Cache::decrement('key', $amount);

缓存标签

文件或数据库这类缓存系统均不支持缓存标签。此外，使用带有「forever」的缓存标签时，挑选memcached这类缓存系统将获得最好的性能，它会自动清除过期的纪录。

缓存事件

Event::listen('cache.hit', function($key, $value) {

});

Event::listen('cache.missed', function($key) {

});

Event::listen('cache.write', function($key, $value, $minutes) {

});

Event::listen('cache.delete', function($key) {

});

集合

建立集合

$collection = collect([1, 2, 3]); # 使用collect方法

$collection = Collection::make([1, 2, 3]); # 使用Collection类的make方法

Illuminate\Support\Collection类对数组进行了封装，简化数组操作，如查询、合并、去重、tojson等。

Artisan Console

编写命令

自定义的命令都保存在app/Console/Commands目录下。

# 新建一个命令

php artisan make:console SendEmails

这将会新建一个app/Console/Commands/SendEmails.php文件。

# 新建一个命令，同时为其分配一个命令名

php artisan make:console SendEmails --command=emails:send

命令结构

<?php

namespace App\Console\Commands;

use App\User;

use App\DripEmailer;

use Illuminate\Console\Command;

use Illuminate\Foundation\Inspiring;

class Inspire extends Command{

protected $signature = 'email:send {user}'; #　使用artisan list时显示的信息

protected $description = 'Send drip e-mails to a user'; #　使用artisan list时显示的信息

protected $drip;

public function __construct(DripEmailer $drip){

parent::__construct();

$this->drip = $drip;

}

public function handle(){ # 命令执行的主方法

$this->drip->send(User::find($this->argument('user')));

}

命令输入/输出

注册命令

往app/Console/Kernel.php中的$commands数组中添加命令类：

protected $commands = [

'App\Console\Commands\SendEmails'

];

从代码中调用命令

可以从代码中调用命令，并传入参数。可以指定将命令添加到队列中执行。

此外，也可以从一个命令中调用另一个命令。

扩展框架*

Laravel Elixir*

加密

前置条件：确保config/app.php文件中的key选项配置了16, 24,或32字符的随机字串，否则加密的数值不会安全。

$encrypted = Crypt::encrypt('secret'); # 加密

$decrypted = Crypt::decrypt($encryptedValue); # 解密

错误与日志

配置

日志功能的配置在Illuminate\Foundation\Bootstrap\ConfigureLogging启动类中，这个类通过加载config/app.php配置文件的log配置选项进行配置。

'log' => 'single' # 配置为单一日志文件

'log' => ‘daily’ # 配置为每天一个日志文件

config/app.php配置文件的app.debug配置选项控制应用程序透过浏览器显示错误细节。配置选项默认参照.env文件的APP_DEBUG环境变量。

错误处理

所有的异常都由app\Exceptions\Handler类处理，该类有如下2个方法和1个属性：

report方法只基本实现简单地传递异常到父类并于父类记录异常。

render方法负责把异常转换成应该被传递回浏览器的HTTP 响应。

$dontReport属性是个数组，包含应该不要被纪录的异常类型。

具体可以结合instanceof来重写，以便对各种异常进行分类处理。

HTTP异常

默认在Handler类中忽略了对HTTP异常的处理。

在整个生命周期中，可以随时抛出HTTP异常，如abort(404);

可以在resources/views/errors/404.blade.php文件中自定义404错误页面的视图。

日志

Laravel默认为应用程序建立每天的日志文件在storage/logs目录，可以如下写入日志：

Log::info('This is some useful information.');

Log::warning('Something could be going wrong.');

Log::error('Something is really going wrong.');

事件

注册事件和监听类

事件类都放在app/Events目录下，事件监听类都放在app/Listeners目录下。

在app/Providers/EventServiceProvider.php的$listen属性中添加事件及其对应监听类的映射关系：

protected $listen = [

'App\Events\PodcastWasPurchased' => [

'App\Listeners\EmailPurchaseConfirmation',

];

可以先在app/Providers/EventServiceProvider.php中列出所有的event和listener的映射关系，然后用以下命令来生成event和listener类文件：

php artisan event:generate

已经存在的event和listener不会被修改。

定义事件

一个事件类其实就是一个数据容器，携带一些和事件相关的数据，不包含逻辑内容。如：

class PodcastWasPurchased extends Event{

use SerializesModels;

public $podcast;

public function __construct(Podcast $podcast){

$this->podcast = $podcast;

}

定义监听器

class EmailPurchaseConfirmation{

public function __construct(){

}

public function handle(PodcastWasPurchased $event){

// Access the podcast using $event->podcast...

}

事件监听器都是通过服务容器进行解析的，因此可以在构造方法中自定义需要的type-hint。

要停止事件传播（不继续传播到其他监听器），需要在handle方法中返回false。

队列化事件监听

将监听器类标记为实现ShouldQueue接口，则该监听器将支持队列化行为。当接收到事件时，它将被自动被Laravel的事件分发器添加到执行队列中。当该监听器任务被成功执行，将被从任务队列中删除。

class EmailPurchaseConfirmation implements ShouldQueue{

}

如果想要操作底层任务队列的delete和release方法，需要借助Illuminate\Queue\InteractsWithQueue trait：

class EmailPurchaseConfirmation implements ShouldQueue{

use InteractsWithQueue;

public function handle(PodcastWasPurchased $event){

if (true) {

$this->release(30);

}

发出事件

$response = Event::fire(new PodcastWasPurchased($podcast)); # 使用Event facade触发

event(new PodcastWasPurchased($podcast)); # 使用event()方法

广播事件

Laravel支持通过websocket向客户端发出事件广播，这样就可以在服务器端和客户端的js代码中使用相同的事件名。

事件订阅者

事件订阅者可以同时订阅多个事件，如下：

class UserEventHandler {

public function onUserLogin($event){

}

public function onUserLogout($event){

}

public function subscribe($events){

$events->listen('App\Events\UserLoggedIn', 'UserEventHandler@onUserLogin'); # 由自己的onUserLogin方法处理

$events->listen('App\Events\UserLoggedOut', 'UserEventHandler@onUserLogout'); # 由自己的onUserLogout方法处理

}

定义了事件订阅者后，需要在EventServiceProvider中的$subscribe属性中进行注册：

protected $subscribe = [

'App\Listeners\UserEventListener',

];

文件系统 / 云存储

Laravel基于Flysystem实现了对本地文件系统、云存储访问的相同的API。文件系统的配置文件放在 config/filesystems.php中，使用本地空间时，所有的操作路径都是相对于配置文件里的local配置项的root的值。

通过Storage facade来访问：

$disk = Storage::disk('local'); # 取得本地硬盘

if (Storage::exists('file.jpg')) # 判断文件是否存在

$contents = Storage::get('file.jpg'); # 获取文件内容

Storage::put('file.jpg', $contents); # 设置文件内容

Storage::prepend('file.log', 'Prepended Text'); # 添加内容到文件开始处

Storage::append('file.log', 'Appended Text'); # 添加内容到文件结尾处

Storage::delete('file.jpg'); # 删除文件

Storage::delete(['file1.jpg', 'file2.jpg']); # 批量删除文件

Storage::copy('old/file1.jpg', 'new/file1.jpg'); # 复制文件

Storage::move('old/file1.jpg', 'new/file1.jpg'); # 移动文件

$size = Storage::size('file1.jpg'); # 获取文件大小

$time = Storage::lastModified('file1.jpg'); # 获取最近修改时间

$files = Storage::files($directory); # 取得当前目录下所有文件

$files = Storage::allFiles($directory); # 递归取得当前目录下所有文件

$directories = Storage::directories($directory); # 取得当前目录下所有子目录

$directories = Storage::allDirectories($directory); # 递归取得当前目录下所有子目录

Storage::makeDirectory($directory); # 新建目录

Storage::deleteDirectory($directory); # 删除目录

哈希

Laravel的Hash使用Bcrypt进行加密。

$password = Hash::make('secret'); # 加密

$password = bcrypt('secret'); # 直接使用函数加密

if (Hash::check('secret', $hashedPassword)) # 验证

if (Hash::needsRehash($hashed)) # 检查是否需要重新加密

辅助方法

Laravel扩展实现的一些方法：

数组方法

路径

字符串

URLs

杂项函数

本地化*

（略）

邮件*

（用到再看）

扩展包开发*

（开发插件，暂时用不到，略）

分页*

（实际应该会自己开发，用到再看）

队列*

（需要与各种队列驱动扩展包配合使用，用到再看）

会话

Laravel支持多种session后端驱动（文件、Memcached、Redis），并通过清楚、统一的API提供使用。session 的配置文件配置在config/session.php中。

如果需要加密所有的session数据，就将选项encrypt配置为true。当使用cookie作为session驱动时，永远不应该从 HTTP Kernel中移除EncryptCookie中间件。如果你移除了这个中间件，你的应用容易遭受远程代码攻击。

使用session

#　保存对象到session中

Session::put('key', 'value'); # 使用facade

session(['key' => 'value']); # 使用session方法

# 保存对象进session数组值中

Session::push('user.teams', 'developers');

# 从session取回对象

$value = Session::get('key'); # 使用facade

$value = session('key'); # 使用session方法

# 从Session取回对象，若无则返回默认值

$value = Session::get('key', 'default');

$value = Session::get('key', function() { return 'default'; });

# 从Session取回对象，并删除

$value = Session::pull('key', 'default');

# 从Session取出所有对象

$data = Session::all();

# 判断对象在 Session 中是否存在

if (Session::has('users'))

# 从 Session 中移除对象

Session::forget('key');

# 清空所有 Session

Session::flush();

# 重新产生 Session ID

Session::regenerate();

暂存数据

Session::flash('key', 'value'); # 暂存一些数据，并只在下次请求有效。

Session::reflash(); # 刷新当前暂存数据，延长到下次请求

Session::keep(['username', 'email']); # 只刷新指定快闪数据

数据库Sessions

当使用database session驱动时，必需建置一张保存 session 的数据表：

Schema::create('sessions', function($table){

$table->string('id')->unique();

$table->text('payload');

$table->integer('last_activity');

});

Blade模板

所有的Blade模板后缀名都要命名为.blade.php

# 定义一个 Blade 页面布局 resources/views/layouts/master.blade.php

<html>

<head>

<title>App Name - @yield('title')</title>

</head>

<body>

@section('sidebar')

This is the master sidebar.

@show

@yield('content')

</div>

</body>

</html>

# 在视图模板中使用Blade页面布局

@extends('layouts.master') # 继承layouts/master.blade.php

@section('title', 'Page Title')

@section('sidebar') # @section ... @stop用来替换继承模板中的@section...@show

@parent

<p>This is appended to the master sidebar.</p>

@stop

@section('content')

<p>This is my body content.</p>

@stop

如果视图继承(extend)了一个Blade页面布局会将页面布局中定义的区块用视图中所定义的区块重写。如果想要将页面布局中的区块内容也能在继承此布局的视图中呈现，那就要在区块中使用 @parent 语法指令

# 在Blade视图中打印（Echoing）数据

Hello, {{ $name }}.

The current UNIX timestamp is {{ time() }}.

# 检查数据是否存在后再打印数据

或者：
{{ $name or 'Default' }}

# 使用花括号显示文字

@{{ This will not be processed by Blade }}

# 阻止数据解析

Hello, {!! $name !!}.

# If声明

@if (count($records) === 1)

I have one record!

@elseif (count($records) > 1)

I have multiple records!

@else

I don't have any records!

@endif

@unless (Auth::check())

You are not signed in.

@endunless

# 循环

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

The current value is {{ $i }}

@endfor

@foreach ($users as $user)

@endforeach

@forelse($users as $user)

@empty

<p>No users</p>

@endforelse

@while (true)

<p>I'm looping forever.</p>

@endwhile

# 加载子视图

@include('view.name')

@include('view.name', ['some' => 'data'])

# 重写区块

@extends('list.item.container')

@section('list.item.content')

@overwrite

# 注释

单元测试*

（略）

数据验证

可以手工新建Validation类的对象来进行基本的验证。对于控制器，可以借助Controller类使用的ValidatesRequests trait来简化操作。对于复杂的验证操作，可以实现一个request类，借助依赖注入的方式来简化。

基本验证

$validator = Validator::make(

['name' => 'Dayle'],

['name' => 'required|min:5']

);

使用数组来定义规则

$validator = Validator::make(

['name' => 'Dayle'],

['name' => ['required', 'min:5']]

);

验证多个字段

$validator = Validator::make(

[

'name' => 'Dayle',

'password' => 'lamepassword',

'email' => '[email protected]'

[

'name' => 'required',

'password' => 'required|min:8',

'email' => 'required|email|unique:users'

]

);

# 判断验证是否通过

if ($validator->fails())

if ($validator->passes())

# 从验证器中接收错误信息

$messages = $validator->messages();

# 取得无法通过验证的规则

$failed = $validator->failed();

# 在完成验证后增加回调函数

$validator = Validator::make(...);

$validator->after(function($validator){

});

if ($validator->fails()){

}

控制器验证

# 借助Controller类使用的ValidatesRequests trait来简化操作

public function store(Request $request){

$this->validate($request, [

'title' => 'required|unique|max:255',

'body' => 'required',

]);

}

如果验证通过了，代码会正常继续执行。如果验证失败，那么会抛出一个 Illuminate\Contracts\Validation\ValidationException 异常。这个异常会被自动捕获，然后重定向至用户上一个页面。而错误信息甚至已经存储至 session 中！

如果收到的是一个 AJAX 请求，那么不会生成一个重定向。相反的，一个带有 422 状态码的 HTTP 响应会被返回给浏览器，包含了一个含有错误信息的 JSON 对象。

使用错误信息

echo $messages->first('email'); # 查看一个字段的第一个错误信息

foreach ($messages->get('email') as $message) # 查看一个字段的所有错误信息

foreach ($messages->all() as $message) # 查看所有字段的所有错误信息

if ($messages->has('email')) # 判断一个字段是否有错误信息

echo $messages->first('email', '<p>:message</p>'); # 错误信息格式化输出

数据库使用基础

数据库配置文件位置：config/database.php

# 使用特定数据库连接进行SELECT操作，同时使用另外的连接进行INSERT、UPDATE、以及DELETE操作。

'mysql' => [

'read' => [

'host' => '192.168.1.1',

'write' => [

'host' => '196.168.1.2'

'driver' => 'mysql',

'database' => 'database',

'username' => 'root',

'password' => '',

'charset' => 'utf8',

'collation' => 'utf8_unicode_ci',

'prefix' => '',

执行查找

$results = DB::select('select * from users where id = ?', [1]); # select

$results = DB::select('select * from users where id = :id', ['id' => 1]); # select 使用名称绑定

DB::insert('insert into users (id, name) values (?, ?)', [1, 'Dayle']); # insert

DB::update('update users set votes = 100 where name = ?', ['John']); # update

DB::delete('delete from users'); # delete

DB::statement('drop table users'); # 执行一般语句

数据库事务处理

# 使用transaction

DB::transaction(function()

{

DB::table('users')->update(['votes' => 1]);

DB::table('posts')->delete();

});

# 手工抛出

DB::beginTransaction();

DB::rollback();

DB::commit();

获取连接

$users = DB::connection('foo')->select(...); # 使用特定连接获取（应用于多种连接的情况）

$pdo = DB::connection()->getPdo(); # 获取底层PDO实例

DB::reconnect('foo'); # 重新连接到特定的数据库

DB::disconnect('foo'); # 关闭特定的数据库连接

查找日志记录

DB::connection()->enableQueryLog(); # 启用日志

$queries = DB::getQueryLog(); # 得到执行过的查找纪录数组

查询构造器

Laravel 查询构造器使用 PDO 参数绑定，以保护应用程序免于SQL注入，因此传入的参数不需额外转义特殊字符。

Selects

# 从数据表中取得所有的数据列

$users = DB::table('users')->get();

foreach ($users as $user){

var_dump($user->name);

}

# 从数据表中分块查找数据列

DB::table('users')->chunk(100, function($users){

foreach ($users as $user){

// return false; # 停止处理接下来的数据列

}

});

# 从数据表中取得单一数据列

$user = DB::table('users')->where('name', 'John')->first();

var_dump($user->name);

# 从数据表中取得单一数据列的单一字段

$name = DB::table('users')->where('name', 'John')->pluck('name');

# 取得单一字段值的列表

$roles = DB::table('roles')->lists('title');

$roles = DB::table('roles')->lists('title', 'name'); # 为返回的数组指定自定义键值

# 指定查询子句

$users = DB::table('users')->select('name', 'email')->get();

$users = DB::table('users')->distinct()->get();

$users = DB::table('users')->select('name as user_name')->get();

# 增加查询子句到现有的查询中

$query = DB::table('users')->select('name');

$users = $query->addSelect('age')->get();

# 使用where及运算符

$users = DB::table('users')->where('votes', '>', 100)->get();

# 「or」语法

$users = DB::table('users')

->where('votes', '>', 100)

->orWhere('name', 'John')

->get();

# Where Between

$users = DB::table('users')->whereBetween('votes', [1, 100])->get();

# Where Not Between

$users = DB::table('users')->whereNotBetween('votes', [1, 100])->get();

# Where In与数组

$users = DB::table('users')->whereIn('id', [1, 2, 3])->get();

$users = DB::table('users')->whereNotIn('id', [1, 2, 3])->get();

# Where Null

$users = DB::table('users')->whereNull('updated_at')->get();

# Order By、Group By及Having

$users = DB::table('users')

->orderBy('name', 'desc')

->groupBy('count')

->having('count', '>', 100)

->get();

# Offset、Limit

$users = DB::table('users')->skip(10)->take(5)->get();

Joins

# 基本的Join语法

DB::table('users')

->join('contacts', 'users.id', '=', 'contacts.user_id')

->join('orders', 'users.id', '=', 'orders.user_id')

->select('users.id', 'contacts.phone', 'orders.price')

->get();

# Left Join语法

DB::table('users')

->leftJoin('posts', 'users.id', '=', 'posts.user_id')

->get();

# 在join中使用where型式的子句

DB::table('users')

->join('contacts', function($join)

{

$join->on('users.id', '=', 'contacts.user_id')

->where('contacts.user_id', '>', 5);

})

->get();

聚合

$users = DB::table('users')->count();

$price = DB::table('orders')->max('price');

$price = DB::table('orders')->min('price');

$price = DB::table('orders')->avg('price');

$total = DB::table('users')->sum('votes');

原生表达式

$users = DB::table('users')

->select(DB::raw('count(*) as user_count, status')) # 要小心勿建立任何SQL注入点

->where('status', '<>', 1)

->groupBy('status')

->get();

添加

# 添加数据进数据表

DB::table('users')->insert(

['email' => '[email protected]', 'votes' => 0]

);

# 添加自动递增ID的数据至数据表，如果数据表有自动递增的ID，可以使用insertGetId 添加数据并返回该 ID

$id = DB::table('users')->insertGetId(

['email' => '[email protected]', 'votes' => 0]

);

# 添加多个数据进数据表

DB::table('users')->insert([

['email' => '[email protected]', 'votes' => 0],

['email' => '[email protected]', 'votes' => 0]

]);

更新

# 更新数据表中的数据

DB::table('users')->where('id', 1)->update(['votes' => 1]);

# 自增或自减一个字段的值

DB::table('users')->increment('votes');

DB::table('users')->increment('votes', 5);

DB::table('users')->decrement('votes');

DB::table('users')->decrement('votes', 5);

删除

# 删除数据表中的数据

DB::table('users')->where('votes', '<', 100)->delete();

# 删除数据表中的所有数据

DB::table('users')->delete();

# 清空数据表

DB::table('users')->truncate();

结构生成器

（提供一个与数据库无关的数据表产生方法）

迁移和数据填充

（和结构生成器一起对数据库进行版本控制）

Eloquent ORM

基本用法

模型通常放在app目录下，所有的模型都必须继承自Illuminate\Database\Eloquent\Model。

# 定义一个 Eloquent 模型

class User extends Model {}

# 通过make:model命令来生成模型

php artisan make:model User

若没有特别指定，系统会默认自动对应名称为「类名称的小写复数形态」的数据库表。也可以在类中定义table属性自定义要对应的数据库表：
class User extends Model {

protected $table = 'my_users'; # 定义模型所映射的表

}

Eloquent也会假设每个数据库表都有一个字段名称为id的主键。您可以在类里定义 primaryKey 属性来重写。同样的，您也可以定义 connection 属性，指定模型连接到指定的数据库连接。

在默认情况下，在数据库表里需要有 updated_at 和 created_at 两个字段。如果不想设定或自动更新这两个字段，则将类里的 $timestamps 属性设为 false即可。

# 取出所有记录

$users = User::all();

# 根据主键取出一条数据

$user = User::find(1);

var_dump($user->name);

# 根据主键取出一条数据或抛出异常

$model = User::findOrFail(1);

$model = User::where('votes', '>', 100)->firstOrFail(); # 所有查询构造器里的方法，查询 Eloquent 模型时也可以使用。

# 处理ModelNotFoundException

要捕获ModelNotFoundException异常，需要往app/Exceptions/Handler.php文件中添加一些逻辑：

use Illuminate\Database\Eloquent\ModelNotFoundException;

class Handler extends ExceptionHandler {

public function render($request, Exception $e){

if ($e instanceof ModelNotFoundException){

// Custom logic for model not found...

}

return parent::render($request, $e);

}

# Eloquent 模型结合查询语法

$users = User::where('votes', '>', 100)->take(10)->get();

foreach ($users as $user){

var_dump($user->name);

}

# Eloquent 聚合查询

$count = User::where('votes', '>', 100)->count();

$users = User::whereRaw('age > ? and votes = 100', [25])->get();

# 拆分查询

User::chunk(200, function($users){

foreach ($users as $user){

}

});

# 指定查询时连接数据库

$user = User::on('connection-name')->find(1);

# 强制查询使用写入连接

$user = User::onWriteConnection()->find(1);

批量赋值

fillable 属性指定了哪些字段支持批量赋值，guarded与fillable相反。可以设定在类的属性里或是实例化后设定。

class User extends Model {

protected $fillable = ['first_name', 'last_name', 'email']; # 支持批量赋值的属性

protected $guarded = ['id', 'password']; # 不支持批量赋值的属性

}

protected $guarded = ['*']; # 阻挡所有属性被批量赋值

新增，更新，删除

# 储存新的模型数据，通常Eloquent模型主键值会自动递增。但是您若想自定义主键，将incrementing属性设成 false。

$user = new User;

$user->name = 'John';

$user->save();

$insertedId = $user->id; # 获取新增模型的ID

# 使用模型的Create方法，需要设定好 fillable 或 guarded 属性，因为 Eloquent 默认会防止批量赋值

$user = User::create(['name' => 'John']); # 在数据库中建立一个新的用户

$user = User::firstOrCreate(['name' => 'John']); # 以属性找用户，若没有则新增并取得新的实例

$user = User::firstOrNew(['name' => 'John']); # 以属性找用户，若没有则建立新的实例

# 更新取出的模型

$user = User::find(1);

$user->email = '[email protected]';

$user->save();

# 结合查询语句，批次更新模型

$affectedRows = User::where('votes', '>', 100)->update(['status' => 2]);

# 删除模型

$user = User::find(1);

$user->delete();

# 按主键值删除模型

User::destroy(1);

User::destroy([1, 2, 3]);

User::destroy(1, 2, 3);

# 只更新模型的时间戳

$user->touch();

软删除

通过软删除方式删除了一个模型后，模型中的数据并不是真的从数据库被移除。而是会设定 deleted_at时间戳。要让模型使用软删除功能，只要在模型类里加入 SoftDeletingTrait 即可：

use Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model {

use SoftDeletes;

protected $dates = ['deleted_at'];

}

关联

# 定义一对一关联，一个User模型对应到一个Phone

class User extends Model {

public function phone(){

return $this->hasOne('App\Phone');

}

$phone = User::find(1)->phone; # 取得关联对象

# 自定义关联的键名

Eloquent假设对应的关联模型数据库表里，外键名称是基于模型名称。在这个例子里，默认 Phone 模型数据库表会以 user_id 作为外键。如果想要更改这个默认，可以传入第二个参数到 hasOne 方法里。更进一步，您可以传入第三个参数，指定关联的外键要对应到本身的哪个字段：

return $this->hasOne('App\Phone', 'foreign_key');

return $this->hasOne('App\Phone', 'foreign_key', 'local_key');

# 定义相对一对一关联

class Phone extends Model {

public function user(){

return $this->belongsTo('App\User', 'local_key', 'parent_key');

}

# 一对多，一篇Blog文章可能「有很多」评论

class Post extends Model {

public function comments(){

return $this->hasMany('App\Comment', 'foreign_key', 'local_key');

}

$comments = Post::find(1)->comments; # 取得所有评论

$comments = Post::find(1)->comments()->where('title', '=', 'foo')->first(); # 取得所有满足条件的评论

相对的关系使用belongsTo定义

# 多对多，一个用户（user）可能用有很多身份（role），而一种身份可能很多用户都有。多对多关联需要用到三个数据库表：users，roles，和role_user，role_user应该要有user_id和role_id字段。

class User extends Model {

public function roles(){

return $this->belongsToMany('App\Role', 'role_user', 'user_id', 'foo_id'); # 第2个参数为枢纽表名

}

$roles = User::find(1)->roles; # 从 User 模型取得 roles

当然，也可以在Role模型同样使用belongsToMany来定义相对的关联。

# 远层一对多关联

假如有以下远层关联关系

countries id - integer name - string users id - integer country_id - integer name - string posts id - integer user_id - integer title - string

虽然posts数据库表本身没有country_id字段，但hasManyThrough方法让我们可以使用$country->posts取得country 的posts。

class Country extends Model {

public function posts(){

return $this->hasManyThrough('App\Post', 'App\User', 'country_id', 'user_id');

}

# 多态关联，用一个简单的关联方法，就让一个模型同时关联多个模型

staff id - integer name - string orders id - integer price - integer photos id - integer path - string imageable_id - integer imageable_type - string

class Photo extends Model {

public function imageable(){

return $this->morphTo();

}

class Staff extends Model {

public function photos(){

return $this->morphMany('App\Photo', 'imageable');

}

class Order extends Model {

public function photos(){

return $this->morphMany('App\Photo', 'imageable');

}

# 取得多态关联的对象

$staff = Staff::find(1);

foreach ($staff->photos as $photo){

}

# 取得多态关联对象的拥有者，Photo模型里的 imageable 关联会返回Staff或Order实例，取决于这是哪一种模型拥有的照片。

$photo = Photo::find(1);

$imageable = $photo->imageable;

关联查询

以关联模型作为查询限制

$posts = Post::has('comments')->get(); # 取得所有「至少有一篇评论」的Blog 文章

$posts = Post::has('comments', '>=', 3)->get(); # 可以指定运算符和数量

$posts = Post::has('comments.votes')->get(); # 获取嵌套的has声明

预载入

用来减少N +1查询问题

class Book extends Model {

public function author(){

return $this->belongsTo('App\Author');

}

#　不使用预载入

foreach (Book::all() as $book){

echo $book->author->name;

}

如果book的数量为N，将执行N+1次查询

# 使用预载入

foreach (Book::with('author')->get() as $book){

echo $book->author->name;

}

将只执行2次查询：

select * from books

select * from authors where id in (1, 2, 3, 4, 5, ...)

# 也可以同时载入多种关联

$books = Book::with('author', 'publisher')->get();

# 预载入条件限制

$users = User::with(['posts' => function($query){

$query->where('title', 'like', '%first%');

}])->get();

# 延迟预载入

$books = Book::all();

$books->load('author', 'publisher');

# 对查询构建器进行条件限制

$books->load(['author' => function($query){

$query->orderBy('published_date', 'asc');

}]);

新增关联模型

# 附加一个关联模型

$comment = new Comment(['message' => 'A new comment.']);

$post = Post::find(1);

$comment = $post->comments()->save($comment);

新增的 comment 模型中 post_id 字段会被自动设定

# 同时新增很多关联模型

$comments = [

new Comment(['message' => 'A new comment.']),

new Comment(['message' => 'Another comment.']),

new Comment(['message' => 'The latest comment.'])

];

$post = Post::find(1);

$post->comments()->saveMany($comments);

# 从属关联模型

$account = Account::find(10);

$user->account()->associate($account);

$user->save();

集合

当查询返回的结果多于一条时，都会被转换成集合对象返回。

# 确认集合中里是否包含特定键值

$roles = User::find(1)->roles;

if ($roles->contains(2)){

}

# 集合也可以转换成数组或JSON

$roles = User::find(1)->roles->toArray();

$roles = User::find(1)->roles->toJson();

# 集合遍历

$roles = $user->roles->each(function($role){

});

# 集合过滤

$users = $users->filter(function($user){

return $user->isAdmin();

});

# 遍历传入集合里的每个对象到回调函数

$roles = User::find(1)->roles;

$roles->each(function($role){

});

# 依照属性值排序

$roles = $roles->sortBy('created_at');

$roles = $roles->sortByDesc('created_at');

$roles = $roles->sortBy(function($role){

return $role->created_at;

});

$roles = $roles->sortByDesc(function($role){

return $role->created_at;

});

# 获取器和修改器

class User extends Model {

# 获取器

public function getFirstNameAttribute($value) #　数据库中对应的字段名为first_name

{

return ucfirst($value);

}

# 修改器

public function setFirstNameAttribute($value)

{

$this->attributes['first_name'] = strtolower($value);

}

属性类型转换

如果想要某些属性始终转换成另一个数据类型，可以在模型中增加 casts 属性。否则，您需要为每个属性定义修改器。

protected $casts = [

'is_admin' => 'boolean',

];

模型事件

Eloquent模型有很多事件可以触发，可以在模型操作的生命周期的不同时间点，使用下列方法绑定事件：

creating，created，updating，updated，saving，saved，deleting，deleted，restoring，restored。

如果creating、updating、saving、deleting事件返回false的话，就会取消数据库操作。

# 在EventServiceProvider中注册模型事件绑定

public function boot(DispatcherContract $events){

parent::boot($events);

User::creating(function($user){

if ( ! $user->isValid()) return false;

});

}

模型观察者

class UserObserver {

public function saving($model){ # 观察者类里要设定对应模型事件的方法

}

public function saved($model){

}

使用observe方法注册一个观察者实例：

User::observe(new UserObserver);

模型URL生成

当把一个模型实例传递给route或者 action 方法时，模型的主键会被插入实例占位符中：

Route::get('user/{user}', 'UserController@show');

action('UserController@show', [$user]);

如果想使用其他的属性而不是ID的话，可以覆盖模型的getRouteKey方法：

public function getRouteKey(){

return $this->slug;

}

转换成数组/ JSON

# 将模型数据转成数组

$user = User::with('roles')->first();

return $user->toArray();

# 也可以把整个的模型集合转换成数组

return User::all()->toArray();

# 将模型转换成 JSON

return User::find(1)->toJson();

# 从路由中返回模型

Route::get('users', function(){

return User::all(); # 当模型或集合被转换成字符串类型时会自动转换成 JSON 格式，所以可以直接返回对象

});

# 转换成数组或JSON时隐藏属性，只要在模型里增加hidden属性即可。此外，可以使用visible属性定义白名单

class User extends Model {

protected $hidden = ['password'];

protected $visible = ['first_name', 'last_name'];

}

# 增加不存在数据库字段的属性数据：只要定义一个获取器，再把对应的属性名称加到模型里的appends属性

public function getIsAdminAttribute(){

return $this->attributes['admin'] == 'yes';

}

protected $appends = ['is_admin'];

在appends数组中定义的值同样遵循模型中visible和hidden的设定。

Laravel 5文档阅读摘要

HTTP路由

中间件

控制器

HTTP请求

HTTP 响应

视图

Service Providers

Service Container

Contracts

Facades

请求的生命周期

应用程序结构

认证

缓存

集合

Artisan Console

扩展框架*

Laravel Elixir*

加密

错误与日志

事件

文件系统 / 云存储

哈希

辅助方法

本地化*

邮件*

扩展包开发*

分页*

队列*

会话

Blade模板

单元测试*

数据验证

数据库使用基础

查询构造器

结构生成器

迁移和数据填充

Eloquent ORM

你可能感兴趣的:(PHP,laravel,文档,阅读)