Laravel Passport

• Pengenalan
• Pemasangan
  • Mula pantas dengan bahagian hadapan
  • Sediakan Pasport
  Konfigurasi
• Jangka hayat token
  mengatasi model lalai Token Akses Terbitan Token
  Buat pelanggan kebenaran kata laluan
• Minta kata laluan token kebenaran
  • Minta semua skop
  • Medan nama pengguna tersuai
  Token kebenaran dipermudahkan
• Token akses pelanggan
  Pelanggan yang mencipta token akses peribadi
  • Urus token akses peribadi
  • Tentukan skop
  • Skop lalai
  Tetapkan skop kepada token
• Semak skop
• Gunakan API Akses JavaScript

  • Pengenalan

    Dalam Laravel, sangat mudah untuk melaksanakan log masuk dan kebenaran berdasarkan borang tradisional, tetapi bagaimana untuk memenuhi keperluan kebenaran dalam senario API? Dalam senario API, kebenaran pengguna biasanya dilaksanakan melalui token dan bukannya mengekalkan keadaan sesi antara permintaan. Menggunakan Pasport dalam projek Laravel anda memudahkan untuk melaksanakan pengesahan kebenaran API Pasport boleh menyediakan pelaksanaan pelayan OAuth2 yang lengkap untuk aplikasi anda dalam beberapa minit. Pasport dibina pada pelayan League OAuth2 yang diselenggara oleh Andy Millington dan Simon Hamp.

    {nota} Dokumen ini menganggap anda sudah biasa dengan OAuth2. Jika anda tidak tahu OAuth2, sila biasakan diri anda dengan istilah biasa dan ciri OAuth2 sebelum membaca.

    Pemasangan

    Sebelum anda mula, pasang Pasport melalui pengurus pakej Komposer:

    composer require laravel/passport

    Pembekal perkhidmatan Pasport menggunakan rangka kerja untuk mendaftarkan direktori penghijrahan pangkalan datanya sendiri, jadi selepas mendaftarkan direktori penghijrahan pangkalan datanya, anda perlu mendaftar Jalankan arahan migrasi Passport untuk mencipta jadual data yang menyimpan pelanggan dan token secara automatik:

    php artisan migrate

    Seterusnya, jalankan perintah passport:install untuk mencipta kunci penyulitan yang diperlukan untuk menjana token akses selamat, pada masa yang sama , arahan ini juga akan mencipta klien "Akses Peribadi" dan klien "Kebenaran Kata Laluan" untuk menjana token akses: passport:install 命令来创建生成安全访问令牌时所需的加密密钥，同时，这条命令也会创建用于生成访问令牌的「个人访问」客户端和「密码授权」客户端：

    php artisan passport:install

    上面命令执行后，请将 LaravelPassportHasApiTokens Trait 添加到 AppUser 模型中，这个 Trait 会给你的模型提供一些辅助函数，用于检查已认证用户的令牌和使用范围：

    <?php
        namespace App;
        use Laravel\Passport\HasApiTokens;
        use Illuminate\Notifications\Notifiable;
        use Illuminate\Foundation\Auth\User as Authenticatable;
        class User extends Authenticatable{ 
           use HasApiTokens, Notifiable;
         }

    接下来，在 AuthServiceProvider 的 boot 方法中调用 Passport::routes 函数。这个函数会注册发出访问令牌并撤销访问令牌、客户端和个人访问令牌所必需的路由：

    <?php
        namespace App\Providers;
        use Laravel\Passport\Passport;
        use Illuminate\Support\Facades\Gate;
        use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
        class AuthServiceProvider extends ServiceProvider{ 
        /**
         * 应用程序的策略映射。
         *
         * @var array
         */   
         protected $policies = [  
               'App\Model' => 'App\Policies\ModelPolicy',  
                ];   
         /**
         * 注册任何认证/授权服务。
         *
         * @return void
         */   
         public function boot()
             {   
                  $this->registerPolicies();        
                  Passport::routes();    
             }
         }

    最后，将配置文件 config/auth.php 中授权看守器 guards 的 api 的 driver 选项改为 passport。此调整会让你的应用程序在在验证传入的 API 的请求时使用 Passport 的 TokenGuard 来处理：

    'guards' => [
        'web' => [ 
               'driver' => 'session',        
               'provider' => 'users',    
              ],    
         'api' => [   
                  'driver' => 'passport',        
                  'provider' => 'users',    
                ],
               ],

    自定义迁移

    如果你不打算使用 Passport 的默认迁移，你应该在 AppServiceProvider 的 register 方法中调用 Passport::ignoreMigrations 方法。 你可以用这个命令 php artisan vendor:publish --tag=passport-migrations

    php artisan vendor:publish --tag=passport-components

    Selepas melaksanakan arahan di atas, sila tambahkan LaravelPassportHasApiTokens Trait Dalam AppUser model, Trait ini akan memberikan model anda beberapa fungsi tambahan untuk menyemak token dan skop penggunaan pengguna yang disahkan:

    Vue.component(
        'passport-clients',    
        require('./components/passport/Clients.vue').default);
        Vue.component(
            'passport-authorized-clients',    
            require('./components/passport/AuthorizedClients.vue').default
           );
         Vue.component(
              'passport-personal-access-tokens',    
              require('./components/passport/PersonalAccessTokens.vue').default
            );

    Seterusnya, dalam AuthServiceProviderPassport::routes fungsi dipanggil dalam kaedah boot kod>. Fungsi ini mendaftarkan laluan yang diperlukan untuk mengeluarkan token akses dan membatalkan token akses, pelanggan dan token akses peribadi:

    <passport-clients></passport-clients>
    <passport-authorized-clients></passport-authorized-clients><
    passport-personal-access-tokens></passport-personal-access-tokens>

    Akhir sekali, tambah pengawal kebenaran dalam fail konfigurasi config/auth.php The pilihan pemandu guards's api ditukar kepada pasport. Tweak ini akan menyebabkan aplikasi anda menggunakan TokenGuard Pasport apabila mengesahkan permintaan API yang masuk:

    php artisan passport:keys

    Penghijrahan tersuai

    Jika anda tidak bercadang untuk menggunakan migrasi lalai Pasport, anda harus memanggil Passport:: dalam kaedah register kaedah AppServiceProvider ignoreMigration. Anda boleh menggunakan arahan ini php artisan vendor:publish --tag=passport-migrations untuk mengeksport migrasi lalai.

    🎜Secara lalai, Pasport menggunakan medan "user_id" untuk mengenal pasti pengguna. Jika anda ingin menggunakan medan lain untuk mengenal pasti pengguna (contohnya: uuid), anda boleh mengubah suai fail migrasi Pasport lalai. 🎜🎜🎜🎜🎜🎜🎜

    Mulakan dengan pantas di bahagian hadapan

    {nota} Untuk menggunakan komponen Vue Pasport, anda mesti menggunakan rangka kerja JavaScript Vue. Komponen ini juga menggunakan rangka kerja CSS Bootstrap. Walau bagaimanapun, jika anda tidak merancang untuk menggunakan alat ini, komponen ini juga bernilai untuk menulis komponen bahagian hadapan anda sendiri.

    Pasport menyediakan satu siri API JSON yang boleh anda gunakan untuk membolehkan pengguna anda membuat token akses pelanggan dan peribadi. Walau bagaimanapun, menulis kod bahagian hadapan yang berinteraksi dengan API ini boleh memakan masa. Oleh itu, Pasport juga termasuk komponen Vue yang telah dikompilasi yang boleh anda gunakan secara langsung atau sebagai rujukan untuk bahagian hadapan anda sendiri.

    Untuk menggunakan komponen Vue Passport, gunakan perintah vendor:publish Artisan: vendor:publish Artisan 命令：

    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){
         $this->registerPolicies();    
         Passport::routes();    
         Passport::loadKeysFrom('/secret-keys/oauth');
        }

    被发布的组件将会被放到 resources/js/components 目录下。当组件被发布后，你应该在你的 resources/js/app.js 文件中注册它们：

    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){
         $this->registerPolicies();    
         Passport::routes();    
         Passport::tokensExpireIn(now()->addDays(15));    
         Passport::refreshTokensExpireIn(now()->addDays(30));
       }

    {note} 在 Laravel v5.7.19 之前，在注册组件时添加 “.default” 会导致控制台错误。有关此更改的解释，请参阅 Laravel Mix v4.0.0 发布说明.

    在注册了组件后，请确保运行 npm run dev 来重新编译你的资源。 当你重编译你的资源后，你可以将组件放到你应用的模板中以开始创建客户端和个人访问令牌：

    use App\Models\Passport\Client;
    use App\Models\Passport\AuthCode;
    use App\Models\Passport\TokenModel;
    use App\Models\Passport\PersonalAccessClient;
    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){
         $this->registerPolicies();    
         Passport::routes();    
         Passport::useClientModel(Client::class);    
         Passport::useTokenModel(TokenModel::class);    
         Passport::useAuthCodeModel(AuthCode::class);    
         Passport::usePersonalAccessClientModel(PersonalAccessClient::class);
        }

    部署 Passport

    第一次在你的生产环境部署 Passport 时，你大概需要运行 passport:keys 命令。这个命令生成 Passport 生成访问令牌所需的密钥。生成的密钥一般情况下不应放在版本控制中：

    php artisan passport:client

    可以使用 Passport::loadKeysFrom 方法来自定义 Passport 密钥的加载路径：

    http://example.com/callback,http://examplefoo.com/callback

    配置

    令牌的有效期

    默认情况下，Passport 发放的访问令牌是有一年有效期的。但是如果你想自定义访问令牌的有效期，可以使用 tokensExpireIn 和 refreshTokensExpireIn 方法。上述两个方法同样需要在 AuthServiceProvider 的 boot 方法中调用：

    axios.get('/oauth/clients')
        .then(response => {
            console.log(response.data); 
          });

    覆盖默认模型

    可以自由扩展 Passport 使用的模型，通过 Passport

    const data = {
        name: 'Client Name',
        redirect: 'http://example.com/callback'};
        axios.post('/oauth/clients', data)
            .then(response => {
                    console.log(response.data); 
               })
             .catch (response => {
                    // 在response里列出错误详情...    
                 });

    Komponen yang diterbitkan akan diletakkan dalam direktori resources/js/components. Apabila komponen diterbitkan, anda harus mendaftarkannya dalam fail resources/js/app.js anda:

    const data = {
        name: 'New Client Name',
        redirect: 'http://example.com/callback'};
        axios.put('/oauth/clients/' + clientId, data)
            .then(response => {
                    console.log(response.data);    
                  })    
             .catch (response => { 
                    // 在response里列出错误详情...    
                });

    {note} Sebelum Laravel v5.7.19, apabila mendaftar komponen, tambah " .default" akan menyebabkan ralat konsol. Untuk mendapatkan penjelasan tentang perubahan ini, lihat Nota Keluaran Laravel Mix v4.0.0

    .

    🎜Daftar Selepas memasang komponen, pastikan anda menjalankan npm run dev untuk menyusun semula sumber anda. Selepas anda menyusun semula sumber anda, anda boleh meletakkan komponen ke dalam templat apl anda untuk mula mencipta token akses pelanggan dan peribadi: 🎜

    axios.delete('/oauth/clients/' + clientId)
        .then(response => {  
              //   
           });

    🎜🎜🎜

    🎜🎜Menggunakan Pasport🎜🎜Kali pertama anda menggunakan Pasport dalam persekitaran pengeluaran anda, anda mungkin perlu menjalankan perintah passport:keys. Perintah ini menjana kunci yang diperlukan oleh Pasport untuk menjana token akses. Kunci yang dijana biasanya tidak boleh diletakkan dalam kawalan versi: 🎜

    Route::get('/redirect', function () {
        $query = http_build_query([ 
               'client_id' => 'client-id',        
               'redirect_uri' => 'http://example.com/callback',        
               'response_type' => 'code',        
               'scope' => '',    
            ]);    
          return redirect('http://your-app.com/oauth/authorize?'.$query);
        });

    🎜Anda boleh menggunakan kaedah Passport::loadKeysFrom untuk menyesuaikan laluan pemuatan kunci Passport: 🎜

    php artisan vendor:publish --tag=passport-views

    🎜 🎜🎜

    🎜

    Konfigurasi

    🎜🎜🎜

    🎜🎜Tempoh sah token🎜🎜Secara lalai, token akses yang dikeluarkan oleh Pasport sah selama satu tahun. Tetapi jika anda ingin menyesuaikan tempoh sah token akses, anda boleh menggunakan kaedah tokensExpireIn dan refreshTokensExpireIn. Kedua-dua kaedah di atas juga perlu dipanggil dalam kaedah boot AuthServiceProvider: 🎜

    Route::get('/callback', function (Request $request) {
        $http = new GuzzleHttp\Client;    
        $response = $http->post('http://your-app.com/oauth/token', [  
              'form_params' => [      
                    'grant_type' => 'authorization_code',            
                    'client_id' => 'client-id',            
                    'client_secret' => 'client-secret',            
                    'redirect_uri' => 'http://example.com/callback',            
                    'code' => $request->code,        
                   ],    
                ]);    
          return json_decode((string) $response->getBody(), true);
       });

    🎜🎜🎜

    🎜🎜Timpa model lalai🎜🎜Anda boleh melanjutkan model yang digunakan oleh Pasport secara bebas dan mengatasi model lalai melalui model tersuai kelas Pasport: 🎜

    $http = new GuzzleHttp\Client;
    $response = $http->post('http://your-app.com/oauth/token', [ 
       'form_params' => [  
             'grant_type' => 'refresh_token',        
             'refresh_token' => 'the-refresh-token',        
             'client_id' => 'client-id',        
             'client_secret' => 'client-secret',        
             'scope' => '',    
            ],]);
       return json_decode((string) $response->getBody(), true);

    🎜🎜🎜🎜🎜🎜

    Mengeluarkan token akses

    Pembangun yang biasa dengan OAuth2 mesti tahu bahawa bahagian penting OAuth2 ialah kod kebenaran. Apabila menggunakan kod kebenaran, aplikasi klien akan mengubah hala pengguna ke pelayan anda, dan mereka akan meluluskan atau menolak permintaan pelanggan untuk token akses.

    Urus Pelanggan

    Pertama, untuk membina aplikasi yang perlu berinteraksi dengan API aplikasi, pembangun perlu mendaftarkan aplikasi mereka dengan mencipta "klien". Secara amnya, ini termasuk memberikan nama aplikasi pengguna dan URL yang boleh diubah hala oleh aplikasi selepas pengguna meluluskan permintaan kebenaran mereka.

    Perintah pasport:clientpassport:client 命令

    创建客户端最简单的方式是使用 Artisan 命令 passport:client，你可以使用此命令创建自己的客户端，用于测试你的 OAuth2 的功能。在你执行 client 命令时，Passport 会提示你输入有关客户端的信息，最终会给你提供客户端的 ID 和 密钥：

    php artisan passport:client --password

    Redirect URLs

    当有多个重定向 URL 白名单时，可以在 passport:client 命令提示输入 URL 时，使用逗号分隔来指定:

    $http = new GuzzleHttp\Client;
    $response = $http->post('http://your-app.com/oauth/token', [
        'form_params' => [   
             'grant_type' => 'password',        
             'client_id' => 'client-id',        
             'client_secret' => 'client-secret',        
             'username' => 'taylor@laravel.com',        
             'password' => 'my-password',        
             'scope' => '',    
             ],]);
       return json_decode((string) $response->getBody(), true);

    {note} 任何包含逗号的 URL 都必须进行编码。

    JSON API

    考虑到你的用户无法使用 client 命令，Passport 为此提供了可用于创建「客户端」的 JSON API。这样你就不用再花时间编写控制器来创建、更新和删除客户端。

    然而，你仍旧需要基于 Passport 的 JSON API 开发一套前端界面，为你的用户提供管理客户端的面板。下面我们会列出所有用于管理客户端的 API，为了方便起见，我们使用 Axios 来演示对端口发出 HTTP 请求。

    这个 JSON API 由 web 和 auth 两个中间件保护，所以只能从应用程序中调用，不能从外部调用。

    {tip} 如果你不想自己实现整个客户端管理的前端界面，可以使用  前端快速上手 在几分钟内组建一套功能齐全的前端界面。

    GET /oauth/clients

    Cara paling mudah untuk mencipta klien adalah dengan menggunakan perintah Artisan pasport:client, anda boleh menggunakan arahan ini untuk mencipta klien sendiri , digunakan untuk menguji fungsi OAuth2 anda. Apabila anda melaksanakan perintah client, Pasport akan meminta anda untuk mendapatkan maklumat tentang pelanggan, akhirnya memberikan anda ID dan rahsia pelanggan:

    $response = $http->post('http://your-app.com/oauth/token', [
        'form_params' => [   
             'grant_type' => 'password',        
             'client_id' => 'client-id',        
             'client_secret' => 'client-secret',        
             'username' => 'taylor@laravel.com',        
             'password' => 'my-password',        
             'scope' => '*',
            ],
          ]);

    Ubah hala URL

    Apabila terdapat berbilang senarai putih URL ubah hala, anda boleh menentukannya menggunakan pemisahan koma apabila arahan passport:client menggesa untuk URL:🎜

    <?php
        namespace App;
        use Laravel\Passport\HasApiTokens;
        use Illuminate\Notifications\Notifiable;
        use Illuminate\Foundation\Auth\User as Authenticatable;
        class User extends Authenticatable{  
          use HasApiTokens, Notifiable;    
          /**
         * 通过用户名找到对应的用户信息
         *
         * @param  string  $username
         * @return \App\User
         */   
          public function findForPassport($username) 
             {    
                 return $this->where('username', $username)->first(); 
             }
          }

    🎜{note} Mana-mana URL yang mengandungi koma akan Pengekodan diperlukan. 🎜

    🎜🎜JSON API🎜🎜Memandangkan pengguna anda tidak boleh menggunakan arahan klien, Passport menyediakan JSON yang boleh digunakan untuk mencipta API "klien". Dengan cara ini anda tidak perlu lagi menghabiskan masa menulis pengawal untuk membuat, mengemas kini dan memadamkan pelanggan. 🎜🎜Walau bagaimanapun, anda masih perlu membangunkan antara muka hadapan berdasarkan API JSON Pasport untuk menyediakan pengguna anda panel pengurusan pelanggan. Di bawah kami akan menyenaraikan semua API yang digunakan untuk mengurus pelanggan Untuk kemudahan, kami menggunakan Axios🎜 untuk menunjukkan membuat permintaan HTTP ke port. 🎜🎜API JSON ini dilindungi oleh dua perisian tengah: web dan auth, jadi ia hanya boleh dipanggil daripada aplikasi dan tidak boleh dipanggil dari luar. 🎜

    🎜{tip} Jika anda tidak mahu melaksanakan keseluruhan antara muka hadapan pengurusan pelanggan sendiri, anda boleh menggunakan Front-end untuk bermula dengan cepat🎜 untuk membina antara muka hadapan yang berfungsi sepenuhnya dalam beberapa minit . 🎜

    🎜🎜DAPATKAN /oauth/clients🎜🎜Laluan ini akan mengembalikan semua pelanggan pengguna yang disahkan. Kegunaan utama adalah untuk menyenaraikan semua pelanggan pengguna supaya mereka boleh mengedit atau memadamnya: 🎜

    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){
         $this->registerPolicies();    
         Passport::routes();    
         Passport::enableImplicitGrant();
        }

    🎜🎜

    POST /oauth/clients

    Laluan ini digunakan untuk membuat pelanggan baharu. Ia memerlukan dua parameter: nama klien nama dan URL panggil balik pasca kebenaran ubah hala. Selepas meluluskan atau menolak permintaan kebenaran, pengguna dialihkan ke pautan yang disediakan oleh parameter redirect. POST /oauth/clients

    此路由用于创建新客户端。它需要两个参数：客户端的名称 name 和授权后回调的 URL redirect。在批准或拒绝授权请求后，用户会被重定向到 redirect 参数提供的链接。

    当客户端创建后，会返回客户端的 ID 和密钥。客户端可以使用这两个值从你的授权服务请求访问令牌 (Access token) 。该路由会返回新的客户端实例：

    Route::get('/redirect', function () {
        $query = http_build_query([   
             'client_id' => 'client-id',        
             'redirect_uri' => 'http://example.com/callback',        
             'response_type' => 'token',        
             'scope' => '',    
             ]);    
        return redirect('http://your-app.com/oauth/authorize?'.$query);
      });

    PUT /oauth/clients/{client-id}

    此路由用于更新客户端信息。它需要两个参数：客户端的名称 name 和授权后回调的 URL redirect。在批准或拒绝授权请求后，用户会被重定向 redirect 到这个链接。此路由会返回更新后的客户端实例：

    php artisan passport:client --client

    DELETE /oauth/clients/{client-id}

    此路由用于删除客户端 (client)：

    use Laravel\Passport\Http\Middleware\CheckClientCredentials;
    protected $routeMiddleware = [
        'client' => CheckClientCredentials::class,
      ];

    请求令牌

    授权时的重定向

    客户端创建之后，开发者会使用此客户端的 ID 和密钥来请求授权代码，并从应用程序访问令牌。首先，接入应用的用户向你应用程序的 /oauth/authorize 路由发出重定向请求，示例如下：

    Route::get('/orders', function (Request $request) {
        ...
     })->middleware('client');

    {tip} 注意，路由 /oauth/authorize 已经在 Passport::routes 方法中定义。你不需要手动定义此路由。

    批准请求

    接收到授权请求时，Passport 会自动向用户显示一个模版页面，允许用户批准或拒绝授权请求。如果用户批准请求，他们会被重定向回接入的应用程序指定的 redirect_uri。redirect_uri 必须和客户端创建时指定的 redirect 链接完全一致。

    如果你想自定义授权确认页面，可以使用 Artisan 命令 vendor:publish 发布 Passport 的视图。发布后的视图文件存放在 resources/views/vendor/passport

    Apabila pelanggan dibuat, ID dan kunci pelanggan akan dikembalikan. Pelanggan boleh menggunakan dua nilai ini untuk meminta token akses daripada perkhidmatan kebenaran anda. Laluan ini akan mengembalikan contoh pelanggan baharu:

    Route::get('/orders', function (Request $request) {
        ...
    })->middleware('client:check-status,your-scope');

    PUT /oauth/clients/{client-id}

    Laluan ini digunakan untuk mengemas kini maklumat pelanggan. Ia memerlukan dua parameter: nama klien nama dan URL panggil balik pasca kebenaran ubah hala. Selepas meluluskan atau menolak permintaan kebenaran, pengguna akan diubah hala redirect ke pautan ini. Laluan ini mengembalikan contoh klien yang dikemas kini: 🎜

    $guzzle = new GuzzleHttp\Client;
    $response = $guzzle->post('http://your-app.com/oauth/token', [ 
       'form_params' => [ 
              'grant_type' => 'client_credentials',        
              'client_id' => 'client-id',        
              'client_secret' => 'client-secret',        
              'scope' => 'your-scope',    
             ],]);
       return json_decode((string) $response->getBody(), true)['access_token'];

    🎜🎜DELETE /oauth/clients/{client-id}< p>Laluan ini digunakan untuk memadamkan klien: 🎜

    php artisan passport:client --personal

    🎜

    🎜

    Minta token

    🎜🎜Ubah hala semasa kebenaran

    Selepas klien dibuat, pembangun akan menggunakan ID pelanggan ini dan rahsia digunakan untuk meminta kod kebenaran dan token akses daripada aplikasi. Mula-mula, pengguna yang mengakses aplikasi menghantar permintaan ubah hala ke laluan /oauth/authorize aplikasi anda contohnya: 🎜

    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){ 
        $this->registerPolicies();    
        Passport::routes();    
        Passport::personalAccessClientId('client-id');
      }

    {tip} Ambil perhatian bahawa laluan itu. / oauth/authorize telah ditakrifkan dalam kaedah Passport::routes. Anda tidak perlu menentukan laluan ini secara manual. 🎜

    🎜🎜Permintaan kelulusan

    Apabila menerima permintaan kebenaran, Pasport akan memaparkan halaman templat secara automatik kepada pengguna, membenarkan pengguna untuk meluluskan atau menolak permintaan kebenaran. Jika pengguna meluluskan permintaan, mereka akan diubah hala kembali ke redirect_uri yang ditentukan oleh aplikasi mengakses. redirect_uri mestilah sama persis dengan pautan redirect yang dinyatakan semasa klien dibuat. 🎜

    Jika anda ingin menyesuaikan halaman pengesahan kebenaran, anda boleh menggunakan perintah Artisan vendor:publish untuk menerbitkan paparan Pasport. Fail paparan yang diterbitkan disimpan dalam sumber/pandangan/vendor/pasport: 🎜

    $user = App\User::find(1);
    // 创建没有作用域的访问令牌...
    $token = $user->createToken('Token Name')->accessToken;
    // 创建有作用域的访问令牌...
    $token = $user->createToken('My Token', ['place-orders'])->accessToken;

    🎜🎜

    Tukar kod kebenaran untuk mengakses token

    Selepas pengguna meluluskan permintaan kebenaran, dia akan dilencongkan semula ke aplikasi yang diakses. Aplikasi yang mengakses kemudiannya harus meminta token akses daripada aplikasi anda melalui permintaan POST. Permintaan itu hendaklah termasuk kod kebenaran yang dikeluarkan oleh aplikasi apabila pengguna meluluskan permintaan kebenaran. Dalam contoh berikut, kami menggunakan perpustakaan HTTP Guzzle untuk melaksanakan permintaan POST ini: POST 请求向你的应用程序申请访问令牌。请求应该包括当用户批准授权请求时由应用程序发出的授权码。在下面的例子中，我们使用 Guzzle HTTP 库来实现这次 POST 请求：

    axios.get('/oauth/scopes')
        .then(response => {
            console.log(response.data);    
          });

    路由 /oauth/token 返回的 JSON 响应中会包含 access_token 、refresh_token 和 expires_in 属性。expires_in 属性包含访问令牌的有效期（单位：秒）。

    {tip} 像 /oauth/authorize 路由一样，/oauth/token 路由在 Passport::routes 方法中定义了，你没必要手动去定义它。默认情况下，此路由使用 “ThrottleRequests” 中间件的设置进行限流。

    刷新令牌

    如果你的应用程序发放了短期的访问令牌，用户将需要通过在发出访问令牌时提供给他们的刷新令牌来刷新其访问令牌。在下面的例子中，我们使用 Guzzle HTTP 库来刷新令牌：

    axios.get('/oauth/personal-access-tokens')
        .then(response => {
            console.log(response.data);   
          });

    路由 /oauth/token 会返回一个 JSON 响应，其中包含 access_token 、refresh_token 和 expires_in 属性。expires_in 属性包含访问令牌的有效时间（单位：秒）。

    密码授权令牌

    OAuth2 密码授权机制可以让你自己的客户端（如移动应用程序）使用邮箱地址或者用户名和密码获取访问令牌。如此一来你就可以安全地向自己的客户端发出访问令牌，而不需要遍历整个 OAuth2 授权代码重定向流程

    创建密码授权客户端

    在应用程序通过密码授权机制来发布令牌之前，在 passport:client 命令后加上 --password 参数来创建密码授权的客户端。如果你已经运行了 passport:install

    const data = {
        name: 'Token Name',
        scopes: []};
        axios.post('/oauth/personal-access-tokens', data)
            .then(response => {
                console.log(response.data.accessToken);    
            })    
            .catch (response => { 
                   // 列出响应中错误...    
            });

    Laluan /oauth/token Respons JSON yang dikembalikan akan mengandungi access_token< atribut /code>, refresh_token dan expires_in. Atribut expires_in mengandungi tarikh tamat tempoh token akses dalam beberapa saat.

    {tip} Seperti laluan /oauth/authorize, laluan /oauth/token ditakrifkan dalam Pasport::routes kaedah , anda tidak perlu mentakrifkannya secara manual. Secara lalai, laluan ini menggunakan tetapan perisian tengah "ThrottleRequests" untuk pendikit.

    🎜

    Muat semula token

    🎜Jika apl anda A short- Token akses langsung dikeluarkan dan pengguna perlu memuat semula token akses mereka melalui token muat semula yang diberikan kepada mereka apabila token akses dikeluarkan. Dalam contoh berikut, kami menggunakan perpustakaan HTTP Guzzle untuk memuat semula token: 🎜

    axios.delete('/oauth/personal-access-tokens/' + tokenId);

    🎜Laluan /oauth/token akan mengembalikan respons JSON yang mengandungi access_token, refresh_token dan atribut expires_in. Atribut expires_in mengandungi masa tamat tempoh token akses dalam beberapa saat. 🎜🎜🎜🎜

    🎜

    Token Pemberian Kata Laluan

    🎜Mekanisme pemberian kata laluan OAuth2 membenarkan mekanisme pemberian kata laluan Anda sendiri pelanggan (seperti aplikasi mudah alih) memperoleh token akses menggunakan alamat e-mel atau nama pengguna dan kata laluan. Dengan cara ini anda boleh mengeluarkan token akses dengan selamat kepada pelanggan anda sendiri tanpa perlu melalui keseluruhan proses pengalihan kod kebenaran OAuth2🎜🎜🎜🎜< div name="49cdea " data-unique="49cdea">🎜

    Buat klien kebenaran kata laluan

    🎜Sebelum aplikasi mengeluarkan token melalui mekanisme kebenaran kata laluan, dalam pasport:client-- kata laluan parameter selepas kod> arahan untuk mencipta klien yang dibenarkan kata laluan. Jika anda telah menjalankan perintah passport:install, anda tidak perlu menjalankan arahan ini lagi: 🎜

    Route::get('/user', function () {
        //
     })->middleware('auth:api');

    🎜🎜🎜🎜🎜🎜

    Minta token

    Setelah anda mencipta pelanggan yang diberi kata laluan, anda boleh mendapatkan akses dengan membuat permintaan POST ke laluan /oauth/token menggunakan alamat e-mel pengguna dan Token kata laluan. Laluan telah didaftarkan dengan kaedah Passport::routes, jadi tidak perlu mentakrifkannya secara manual. Jika permintaan itu berjaya, anda akan menerima token_akses dan refresh_token dalam respons JSON yang dikembalikan oleh pelayan: /oauth/token 路由发出 POST 请求来获取访问令牌。而该路由已经由 Passport::routes 方法注册，因此不需要手动定义它。如果请求成功，会在服务端返回的 JSON 响应中收到一个 access_token 和 refresh_token：

    $response = $client->request('GET', '/api/user', [
        'headers' => [  
              'Accept' => 'application/json',        
              'Authorization' => 'Bearer '.$accessToken,    
             ],
          ]);

    {tip} 默认情况下，访问令牌是长期有效的。你可以根据需要 配置访问令牌的有效时间 。

    请求所有作用域

    使用密码授权机制时，可以通过请求 scope 参数 * 来授权应用程序支持的所有范围的令牌。如果你的请求中包含 scope 为 * 的参数，令牌实例上的 can 方法会始终返回 true。这种作用域的授权只能分配给使用 password 授权时发出的令牌：

    use Laravel\Passport\Passport;
    Passport::tokensCan([
        'place-orders' => 'Place orders',    
        'check-status' => 'Check order status',
      ]);

    自定义用户名字段

    当使用密码授权时，Passport 默认使用 email 作为「用户名」。但是，你可以通过在模型上定义一个 findForPassport 方法来自定义用户名字段:

    use Laravel\Passport\Passport;Passport::setDefaultScope([
        'check-status',    
        'place-orders',
      ]);

    隐式授权令牌

    隐式授权类似于授权码授权，但是它只将令牌返回给客户端而不交换授权码。这种授权最常用于无法安全存储客户端凭据的 JavaScript 或移动应用程序。通过调用 AuthServiceProvider 中的 enableImplicitGrant 方法来启用这种授权：

    Route::get('/redirect', function () {
        $query = http_build_query([  
              'client_id' => 'client-id',        
              'redirect_uri' => 'http://example.com/callback',        
              'response_type' => 'code',        
              'scope' => 'place-orders check-status',   
            ]);    
     return redirect('http://your-app.com/oauth/authorize?'.$query);});

    调用上面方法开启授权后，开发者可以使用他们的客户端 ID 从应用程序请求访问令牌。接入的应用程序应该向你的应用程序的 /oauth/authorize 路由发出重定向请求，如下所示：

    $token = $user->createToken('My Token', ['place-orders'])->accessToken;

    {tip} 注意，/oauth/authorize 路由已经在 Passport::routes

    'scopes' => \Laravel\Passport\Http\Middleware\CheckScopes::class,
    'scope' => \Laravel\Passport\Http\Middleware\CheckForAnyScope::class,

    {tip} Secara lalai, token akses Berkesan jangka panjang. Anda boleh konfigurasikan masa sah token akses mengikut keperluan

    .

    🎜Meminta semua skop🎜🎜Apabila menggunakan mekanisme kebenaran kata laluan, anda boleh meminta skop oleh Parameter * untuk membenarkan semua julat token yang disokong oleh aplikasi. Jika permintaan anda termasuk parameter dengan skop *, kaedah can pada tika token akan sentiasa mengembalikan true. Keizinan skop ini hanya boleh diberikan kepada token yang dikeluarkan apabila menggunakan kebenaran kata laluan: 🎜

    Route::get('/orders', function () { 
       // Access token has both "check-status" and "place-orders" scopes...
       })->middleware('scopes:check-status,place-orders');

    🎜🎜🎜

    🎜🎜Medan nama pengguna tersuai🎜🎜Apabila menggunakan kebenaran kata laluan, Pasport menggunakan e-mel sebagai "nama pengguna" secara lalai. Walau bagaimanapun, anda boleh menyesuaikan medan nama pengguna dengan mentakrifkan kaedah findForPassport pada model: 🎜

    Route::get('/orders', function () {
        // 访问令牌具有 "check-status" 或 "place-orders" 作用域...
      })->middleware('scope:check-status,place-orders');

    🎜🎜🎜

    🎜

    Token kebenaran tersirat

    🎜Keizinan tersirat adalah serupa dengan kebenaran kod kebenaran, tetapi ia hanya mengembalikan token kepada pelanggan tanpa menukar kod kebenaran. Keizinan ini paling biasa digunakan untuk JavaScript atau aplikasi mudah alih yang tidak dapat menyimpan bukti kelayakan pelanggan dengan selamat. Dayakan keizinan ini dengan memanggil kaedah enableImplicitGrant dalam AuthServiceProvider: 🎜

    use Illuminate\Http\Request;
    Route::get('/orders', function (Request $request) {
        if ($request->user()->tokenCan('place-orders')) { 
               //    
             }
         });

    🎜Selepas memanggil kaedah di atas untuk mendayakan kebenaran, pembangun boleh menggunakan ID klien mereka untuk meminta daripada token akses aplikasi . Aplikasi yang disambungkan harus membuat permintaan ubah hala ke laluan /oauth/authorize aplikasi anda, seperti yang ditunjukkan di bawah: 🎜

    Laravel\Passport\Passport::scopeIds();

    🎜{tip} Nota, /oauth/ The authorize laluan telah ditakrifkan dalam kaedah Passport::routes, jadi tidak perlu mentakrifkan laluan ini secara manual sekali lagi. 🎜🎜🎜🎜🎜🎜🎜🎜

    Token Pemberian Tauliah Pelanggan

    Geran Tauliah Pelanggan sesuai untuk pengesahan mesin ke mesin. Sebagai contoh, anda boleh menggunakan kebenaran ini untuk melaksanakan tugas penyelenggaraan melalui API.

    Sebelum kebenaran kelayakan pelanggan, anda perlu mencipta klien kebenaran kelayakan pelanggan Anda boleh menggunakan parameter --client perintah pasport:client untuk membuat: passport:client 命令的 --client 参数来创建:

    Laravel\Passport\Passport::scopes();

    接下来，要使用这种授权，你首先需要在 app/Http/Kernel.php 的 $routeMiddleware 变量中添加新的中间件：

    Laravel\Passport\Passport::scopesFor(['place-orders', 'check-status']);

    然后，在路由上追加这个中间件：

    Laravel\Passport\Passport::hasScope('place-orders');

    若要将对路由的访问限制在某个作用域内，可在将 client 中间件附加到路由时提供以逗号分隔的所需作用域列表:

    'web' => [ 
       // 其他中间件...
        \Laravel\Passport\Http\Middleware\CreateFreshApiToken::class,
       ],

    获取令牌

    通过向 oauth/token 接口发出请求来获取令牌:

    axios.get('/api/user')
        .then(response => {
            console.log(response.data);    
         });

    个人访问令牌

    有时候，用户要在不经过传统的授权码重定向流程的情况下向自己发出访问令牌。允许用户通过应用程序用户界面对自己发出令牌，有助于用户体验你的 API，或者也可以将其作为一种更简单的发布访问令牌的方式。

    {note} 个人访问令牌是永久有效的，就算使用了 tokensExpireIn 和 refreshTokensExpireIn 方法也不会修改它的生命周期。

    创建个人访问客户端

    在你的应用程序发布个人访问令牌之前，你需要在 passport:client 命令后带上 --personal 参数来创建对应的客户端。如果你已经运行了 passport:install 命令，则无需再运行此命令：

    /**
     * 注册认证 / 授权服务
     *
     * @return void
     */
     public function boot(){
         $this->registerPolicies();    
         Passport::routes();    
         Passport::cookie('custom_name');
       }

    如果你已经创建了个人访问客户端，你可以通过调用 AuthServiceProvider 中的 personalAccessClientId 方法来启用：

    // In your application layout...
    <meta name="csrf-token" content="{{ csrf_token() }}">
    // Laravel's JavaScript scaffolding...
    window.axios.defaults.headers.common = {
        'X-Requested-With': 'XMLHttpRequest',
       };

    管理个人访问令牌

    创建个人访问客户端后，你可以使用 User 模型实例上的 createToken 方法来为给定用户发布令牌。createToken

    /**
     * 应用程序事件监听映射
     *
     * @var array
     */
     protected $listen = [
         'Laravel\Passport\Events\AccessTokenCreated' => [
                 'App\Listeners\RevokeOldTokens', 
                   ],    
          'Laravel\Passport\Events\RefreshTokenCreated' => [ 
                 'App\Listeners\PruneOldTokens',   
                 ],
             ];

    . Seterusnya, untuk menggunakan kebenaran ini, anda perlu menambah middleware baharu dalam pembolehubah $routeMiddleware app/Http/Kernel.php:

    use App\User;
    use Laravel\Passport\Passport;
    public function testServerCreation(){
        Passport::actingAs(  
              factory(User::class)->create(),   
                   ['create-servers']  
                 );    
             $response = $this->post('/api/create-server');    
            $response->assertStatus(201);
         }

    Kemudian, tambah middleware ini ke laluan:

    rrreee

    Untuk mengehadkan akses kepada laluan kepada skop tertentu, sediakan Senarai skop yang diperlukan dipisahkan koma: 🎜rrreee

    🎜

    Dapatkan token

    🎜Dengan membuat permintaan ke antara muka oauth/token Untuk mendapatkan token:🎜rrreee🎜🎜🎜

    🎜🎜Token Akses Peribadi🎜🎜Kadangkala, pengguna mahu Mengeluarkan token akses kepada diri sendiri tanpa melalui proses ubah hala kod kebenaran tradisional. Membenarkan pengguna mengeluarkan token kepada diri mereka sendiri melalui UI aplikasi boleh membantu pengguna mengalami API anda, atau ia boleh digunakan sebagai cara yang lebih mudah untuk mengeluarkan token akses. 🎜

    🎜{note} Token akses peribadi adalah sah selama-lamanya dan kitaran hayatnya tidak akan diubah suai walaupun kaedah tokensExpireIn dan refreshTokensExpireIn digunakan. 🎜

    🎜🎜🎜

    🎜

    Mencipta pelanggan akses peribadi🎜Sebelum aplikasi anda mengeluarkan token akses peribadi, anda perlu mencipta klien yang sepadan dengan parameter --personal selepas perintah passport:client. Jika anda telah menjalankan perintah passport:install, anda tidak perlu menjalankan arahan ini lagi: 🎜rrreee🎜Jika anda telah mencipta klien akses peribadi, anda boleh melakukan ini dengan memanggil AuthServiceProvider Kaedah personalAccessClientId untuk membolehkan: 🎜rrreee🎜🎜🎜

    🎜

    Urus Token Akses Peribadi

    🎜Selepas mencipta klien Akses Peribadi, anda boleh menggunakan kaedah createToken pada contoh model User untuk dikeluarkan token untuk pengguna tertentu. Kaedah createToken menerima nama token sebagai parameter pertamanya dan tatasusunan 🎜scope🎜 pilihan sebagai parameter kedua: 🎜rrreee🎜🎜

    JSON API

    Passport juga mempunyai JSON API untuk mengurus token akses peribadi Anda boleh memasangkannya dengan bahagian hadapan anda sendiri untuk menyediakan pengguna dengan papan pemuka untuk mengurus token akses peribadi. Di bawah kami menerangkan semua antara muka API untuk mengurus token akses peribadi. Untuk kemudahan, kami menggunakan Axios untuk menunjukkan membuat permintaan HTTP ke antara muka API.

    API JSON dilindungi oleh web dan auth middleware, oleh itu, ia hanya boleh dipanggil daripada aplikasi anda sendiri. Ia tidak boleh dipanggil dari sumber luar. web 和 auth 中间件保护；因此，只能从您自己的应用程序中调用它。无法从外部源调用它。

    {tip} 如果你不想实现自己的个人访问令牌管理的前端界面，可以根据  前端快速上手 在几分钟内组建功能齐全的前端界面。

    GET /oauth/scopes

    此路由会返回应用程序中定义的所有 作用域。你可以使用此路由列出用户可能分配给个人访问令牌的范围：

    rrreee

    GET /oauth/personal-access-tokens

    此路由返回认证用户创建的所有个人访问令牌。这主要用于列出所有用户的令牌，以便他们可以编辑或删除它们：

    rrreee

    POST /oauth/personal-access-tokens

    此路由用于创建新的个人访问令牌。它需要两个数据：令牌的 name 和 scpoe：

    rrreee

    DELETE /oauth/personal-access-tokens/{token-id}

    此路由可用于删除个人访问令牌：

    rrreee

    路由保护

    通过中间件

    Passport 包含一个 验证保护机制 可以验证请求中传入的访问令牌。配置 api 的看守器使用 passport 驱动程序后，只需要在需要有效访问令牌的任何路由上指定 auth:api 中间件：

    rrreee

    传递访问令牌

    当调用 Passport 保护下的路由时，接入的 API 应用需要将访问令牌作为 Bearer 令牌放在请求头 Authorization

    {tip} Jika anda tidak mahu melaksanakan antara muka hadapan anda sendiri untuk pengurusan token akses peribadi, anda boleh membina antara muka hadapan yang berfungsi sepenuhnya dalam beberapa minit mengikut Front-end Quick Start

    .

    DAPATKAN /oauth/skop

    Laluan ini akan mengembalikan semua Skop🎜. Anda boleh menggunakan laluan ini untuk menyenaraikan skop yang mungkin diberikan kepada pengguna kepada token akses peribadi: 🎜rrreee

    🎜🎜GET /oauth/personal-access- token< /code>🎜🎜Laluan ini mengembalikan semua token akses peribadi yang dibuat oleh pengguna yang disahkan. Ini digunakan terutamanya untuk menyenaraikan semua token pengguna supaya mereka boleh mengedit atau memadamkannya: 🎜rrreee

    🎜🎜POST /oauth/personal-access- token< /code>🎜🎜Laluan ini digunakan untuk mencipta token akses peribadi baharu. Ia memerlukan dua keping data: nama token dan scpoe: 🎜rrreee

    🎜🎜DELETE /oauth/personal-access-tokens/{token-id}🎜🎜Laluan ini boleh digunakan untuk memadamkan token akses peribadi: 🎜rrreee🎜🎜🎜

    🎜

    Perlindungan Laluan

    🎜🎜🎜

    🎜 < h3>Melalui perisian tengah

    🎜Pasport termasuk mekanisme perlindungan pengesahan yang boleh mengesahkan token akses diluluskan dalam permintaan. Selepas mengkonfigurasi pemerhati api untuk menggunakan pemacu pasport, anda hanya perlu menentukan perisian tengah auth:api pada mana-mana laluan yang memerlukan token akses : 🎜rrreee🎜🎜🎜

    🎜

    Meluluskan token akses

    🎜 Apabila membuat panggilan Apabila menghala di bawah perlindungan Pasport, aplikasi API yang diakses perlu meletakkan token akses sebagai token Pembawa dalam pengepala permintaan Kebenaran. Contohnya, apabila menggunakan perpustakaan HTTP Guzzle: 🎜rrreee🎜🎜🎜🎜🎜🎜

    Skop Token

    Skop membolehkan pelanggan API meminta kebenaran khusus apabila meminta kebenaran akaun. Contohnya, jika anda sedang membina aplikasi e-dagang, tidak semua aplikasi API yang menyambung kepadanya memerlukan keupayaan untuk membuat pesanan. Anda boleh membenarkan aplikasi API yang disambungkan hanya dibenarkan untuk mengakses status penghantaran pesanan. Dalam erti kata lain, skop membenarkan pengguna aplikasi mengehadkan tindakan yang boleh dilakukan oleh aplikasi pihak ketiga.

    Tentukan skop

    Anda boleh menggunakan kaedah Pasport::tokensCan dalam kaedah boot AuthServiceProvider untuk mentakrifkannya Skop API. Kaedah tokensCan menerima tatasusunan yang mengandungi nama skop dan perihalan sebagai parameter. Penerangan skop akan dipaparkan terus kepada pengguna pada halaman pengesahan kebenaran Anda boleh mentakrifkannya sebagai apa sahaja yang anda perlukan: AuthServiceProvider 的 boot 方法中使用 Passport::tokensCan 方法来定义 API 的作用域。tokensCan 方法接受一个包含作用域名称和描述的数组作为参数。作用域描述将会在授权确认页中直接展示给用户，你可以将其定义为任何你需要的内容：

    rrreee

    默认作用域

    如果客户端没有请求任何特定的范围，你可以在 AuthServiceProvider 的 boot 方法中使用 Passport::setDefaultScope 方法来定义默认的作用域。

    rrreee

    给令牌分配作用域

    请求授权码

    使用授权码请求访问令牌时，接入的应用需为 scope 参数指定所需作用域。 scope 参数包含多个作用域时，名称之间使用空格分割：

    rrreee

    分发个人访问令牌

    使用 User 模型的 createToken 方法发放个人访问令牌时，可以将所需作用域的数组作为第二个参数传给此方法：

    rrreee

    检查作用域

    Passport 包含两个中间件，可用于验证传入的请求是否包含访问指定作用域的令牌。 使用之前，需要将下面的中间件添加到 app/Http/Kernel.php 文件的 $routeMiddleware 属性中：

    rrreee

    检查所有作用域

    路由可以使用 scopes 中间件来检查当前请求是否拥有指定的 所有 作用域：

    rrreee

    检查任意作用域

    路由可以使用 scoperrreee

    Skop lalai🎜🎜Jika pelanggan tidak meminta sebarang skop khusus, anda boleh menggunakan dalam kaedah boot AuthServiceProvider Pasport:: setDefaultScope kaedah untuk menentukan skop lalai. 🎜rrreee🎜🎜🎜

    🎜🎜Menetapkan skop kepada token🎜

    🎜

    Minta kod kebenaran

    🎜Apabila menggunakan kod kebenaran untuk meminta token akses, aplikasi yang disambungkan perlu menentukan skop yang diperlukan untuk parameter scope. Apabila parameter scope mengandungi berbilang skop, gunakan ruang untuk memisahkan nama: 🎜rrreee

    🎜

    Edarkan token akses peribadi< /h4 >🎜Apabila menggunakan kaedah createToken model User untuk mengeluarkan token akses peribadi, anda boleh menghantar tatasusunan skop yang diperlukan sebagai parameter kedua kepada kaedah ini: 🎜 rrreee🎜🎜🎜

    🎜🎜Menyemak skop🎜🎜Pasport mengandungi dua middleware yang boleh digunakan untuk mengesahkan permintaan masuk Sama ada untuk memasukkan token untuk mengakses skop yang ditentukan. Sebelum digunakan, anda perlu menambah perisian tengah berikut pada atribut $routeMiddleware bagi fail app/Http/Kernel.php: 🎜rrreee

    🎜

    Semak semua skop

    🎜Laluan boleh menggunakan perisian tengah skop untuk menyemak sama ada permintaan semasa mempunyai skop 🎜semua🎜 yang ditentukan: 🎜rrreee

    🎜

    Semak mana-mana skop

    🎜Laluan boleh menggunakan perisian tengah skop untuk menyemak sama ada permintaan semasa mempunyai 🎜 mana-mana 🎜 Skop: 🎜rrreee🎜🎜

    Semak skop pada contoh token

    Walaupun permintaan yang mengandungi pengesahan token akses telah disahkan oleh aplikasi, anda masih boleh menggunakan tokenCanUser yang dibenarkan pada masa ini instance > Kaedah untuk mengesahkan sama ada token mempunyai skop yang ditentukan: User 实例上的 tokenCan 方法来验证令牌是否拥有指定的作用域：

    rrreee

    附加作用域方法

    scopeIds 方法将返回所有已定义 ID / 名称的数组：

    rrreee

    scopes 方法将返回一个 包含所有已定义作用域数组的 LaravelPassportScope 实例：

    rrreee

    scopesFor 方法将返回与给定 ID / 名称匹配的 LaravelPassportScope 实例数组：

    rrreee

    你可以使用 hasScope 方法确定是否已定义给定作用域：

    rrreee

    使用 JavaScript 接入 API

    在构建 API 时， 如果能通过 JavaScript 应用接入自己的 API 将会给开发过程带来极大的便利。这种 API 开发方法允许你使用自己的应用程序的 API 和别人共享的 API 。你的 Web 应用程序、移动应用程序、第三方应用程序以及可能在各种软件包管理器上发布的任何 SDK 都可能会使用相同的 API 。

    通常，如果要在 JavaScript 应用程序中使用 API ，需要手动向应用程序发送访问令牌，并将其传递给应用程序。但是， Passport 有一个可以处理这个问题的中间件。将 CreateFreshApiToken 中间件添加到 app/Http/Kernel.php 文件中的 web 中间件组就可以了：

    rrreee

    {note} 你应该确保在您的中间件堆栈中 CreateFreshApiToken 中间件之前列出了 EncryptCookies 中间件。

    这个 Passport 中间件将在你所有的对外请求中添加一个 laravel_token cookie 。该 cookie 将包含一个加密后的 JWT ， Passport 将用来验证来自 JavaScript 应用程序的 API 请求。至此，你可以在不明确传递访问令牌的情况下向应用程序的 API 发出请求：

    rrreee

    自定义 Cookie 名称

    如果需要，你可以在 AuthServiceProvider 的 boot 方法中使用 Passport::cookie 方法来自定义 laravel_token cookie 的名称。

    rrreee

    CSRF 保护

    当使用这种授权方法时，默认的 Laravel JavaScript 脚手架会让 Axios 发送 X-CSRF-TOKEN 和 X-Requested-Withrrreee

    Kaedah skop tambahanscopeIds kaedah akan mengembalikan semua Array ID/nama yang ditakrifkan:

    rrreee

    skop Kaedah ini akan mengembalikan contoh LaravelPassportScope yang mengandungi tatasusunan semua skop yang ditakrifkan:

    rrreee🎜scopesFor akan mengembalikan tatasusunan LaravelPassportScope kejadian yang sepadan dengan ID/nama yang diberikan: 🎜rrreee🎜Anda boleh menggunakan kaedah hasScope untuk menentukan sama ada skop yang diberikan ditakrifkan: 🎜rrreee 🎜🎜🎜

    🎜

    Gunakan JavaScript untuk mengakses API

    🎜Membina API, jika anda boleh mengakses API anda sendiri melalui aplikasi JavaScript, ia akan membawa kemudahan besar kepada proses pembangunan. Pendekatan kepada pembangunan API ini membolehkan anda menggunakan API aplikasi anda sendiri dan API kongsi orang lain. Apl web anda, apl mudah alih, apl pihak ketiga dan mana-mana SDK yang mungkin anda terbitkan pada pelbagai pengurus pakej mungkin akan menggunakan API yang sama. 🎜🎜Biasanya, jika anda ingin menggunakan API dalam aplikasi JavaScript, anda perlu menghantar token akses kepada aplikasi secara manual dan menyerahkannya kepada aplikasi. Walau bagaimanapun, Pasport mempunyai perisian tengah yang menangani masalah ini. Cuma tambahkan CreateFreshApiToken middleware pada kumpulan middleware web dalam fail app/Http/Kernel.php: 🎜rrreee

    🎜{note } Anda harus memastikan bahawa perisian tengah EncryptCookies disenaraikan sebelum perisian tengah CreateFreshApiToken dalam tindanan perisian tengah anda. 🎜

    🎜Perisian tengah Pasport ini akan menambahkan kuki laravel_token pada semua permintaan keluar anda. Kuki ini akan mengandungi JWT yang disulitkan yang akan digunakan oleh Pasport untuk mengesahkan permintaan API daripada aplikasi JavaScript. Pada ketika ini, anda boleh membuat permintaan kepada API aplikasi anda tanpa memberikan token akses secara eksplisit: 🎜rrreee

    🎜🎜Nama Kuki Tersuai🎜🎜Jika perlu, Anda boleh menggunakan Kaedah Passport::cookie dalam kaedah boot AuthServiceProvider untuk menyesuaikan nama kuki laravel_token. 🎜rrreee

    🎜🎜Perlindungan CSRF🎜🎜Apabila menggunakan kaedah kebenaran ini, perancah JavaScript Laravel lalai akan menyebabkan Axios menghantar X-CSRF-TOKEN dan pengepala permintaan X-Requested-With. Selain itu, anda mesti memastikan bahawa token CSRF disertakan dalam tag meta HTML: 🎜rrreee🎜🎜🎜🎜🎜🎜

    Acara

    Pasport melancarkan acara apabila token akses dan token muat semula dikeluarkan. Anda boleh menambah pendengar untuk acara ini dalam EventServiceProvider aplikasi anda dan membatalkan atau mengubah suai token lain dalam pendengar: EventServiceProvider 中为这些事件追加监听器，并在监听器中撤销或修改其他令牌：

    rrreee

    测试

    Passport 的 actingAs 方法可以指定当前已认证用户及其作用域。actingAsrrreee

    Test

    🎜Kaedah actingAs Pasport boleh menentukan pengguna yang sedang disahkan dan skopnya. Parameter pertama kaedah actingAs ialah contoh pengguna, dan parameter kedua ialah tatasusunan skop token pengguna: 🎜rrreee🎜Artikel ini pertama kali diterbitkan di tapak web 🎜LearnKu.com🎜. 🎜🎜

    ← Alat Pengurusan Baris Horizon

    Carian teks penuh Pengakap →

    serahkan

    Laman web PHP Cina

    RumahKursusArtikelSoal JawabKamusManualMuat turuncari APPMuat turun