PHP App::singleton方法代码示例

 /**
  * Register the service provider.
  *
  * @return void
  */
 public function register()
 {
     $this->package('leeb/jsonrpc');
     \App::bind('Leeb\\Jsonrpc\\Interfaces\\RequestInterface', function ($app, $data) {
         return new \Leeb\Jsonrpc\Request($data[0]);
     });
     \App::bind('Leeb\\Jsonrpc\\JsonrpcResponse', function ($app, $data) {
         return new \Leeb\Jsonrpc\JsonrpcResponse($data[0], $data[1], $data[2]);
     });
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\JsonrpcResponseBuilderInterface', 'Leeb\\Jsonrpc\\JsonrpcResponseBuilder');
     \App::bind('Leeb\\Jsonrpc\\RoutableRequest', function ($app, $data) {
         $resolver = \App::make('Leeb\\Jsonrpc\\Interfaces\\MethodResolverInterface');
         $response_builder = \App::make('Leeb\\Jsonrpc\\Interfaces\\JsonrpcResponseBuilderInterface');
         return new \Leeb\Jsonrpc\RoutableRequest($resolver, $response_builder, $data[0]);
     });
     \App::bind('Leeb\\Jsonrpc\\JsonrpcError', function ($app, $data) {
         return new \Leeb\Jsonrpc\JsonrpcError($data[0], $data[1], $data[2], $data[3]);
     });
     \App::bind('Leeb\\Jsonrpc\\RoutableNotification', function ($app, $data) {
         $resolver = \App::make('Leeb\\Jsonrpc\\Interfaces\\MethodResolverInterface');
         return new \Leeb\Jsonrpc\RoutableNotification($resolver, $data[0]);
     });
     \App::bind('Leeb\\Jsonrpc\\RoutableBatch', function ($app, $data) {
         return new \Leeb\Jsonrpc\RoutableBatch($data[0]);
     });
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\RouterInterface', 'Leeb\\Jsonrpc\\Router');
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\MethodResolverInterface', 'Leeb\\Jsonrpc\\MethodResolver');
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\JsonrpcConfigurationInterface', 'Leeb\\Jsonrpc\\JsonrpcConfiguration');
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\RequestValidatorInterface', 'Leeb\\Jsonrpc\\RequestValidator');
     \App::singleton('Leeb\\Jsonrpc\\Interfaces\\RawRequestInterpreterInterface', 'Leeb\\Jsonrpc\\RawRequestInterpreter');
 }

 /**
  * Register the GitHub class.
  *
  * @param  App  $app
  * @return null
  */
 protected function registerGithub($app)
 {
     $app->singleton('github', function ($app) {
         $config = $app['config'];
         $factory = $app['github.factory'];
         return new Github($config, $factory);
     });
     $app->alias('github', 'Caffeinated\\Github\\Github');
 }

 public static function setupShortCodes()
 {
     App::singleton('shortCodeEngine', function () {
         $shortCodeEngine = new ShortCodeEngine();
         return $shortCodeEngine;
     });
     $shortCodeEngine = App::make('shortCodeEngine');
     $shortCodes = (require app_path('lib/shortcodes.php'));
     $shortCodeEngine->loadShortCodes($shortCodes);
 }

 /**
  * Register the binding
  *
  * @return void
  */
 public function register()
 {
     \App::singleton('Doctrine\\ORM\\EntityManager', function () {
         $isDevMode = true;
         $paths = array(__DIR__ . '/Infrastructure/Repository/Metadata');
         $config = Setup::createXMLMetadataConfiguration($paths, $isDevMode);
         $conn = array('driver' => 'pdo_mysql', 'host' => 'localhost', 'dbname' => 'laravelddd', 'user' => 'root', 'password' => 'root');
         return \Doctrine\ORM\EntityManager::create($conn, $config);
     });
 }

 private function __construct($classname)
 {
     if ($lastnspos = strripos($classname, '\\')) {
         $namespace = substr($classname, 0, $lastnspos);
         $classname = substr($classname, $lastnspos + 1);
         $this->view['directory'] = $this->view['class'] = strtolower(str_replace('Controller', '', $classname));
         $namespace = explode('\\', $namespace);
         $this->view['app'] = $namespace[0];
         $this->view['module'] = $namespace[1];
     }
     $this->lean = $this->app = App::singleton();
 }

 public function testAppBindSingleton()
 {
     $app = app();
     App::singleton('tmp', function ($app) {
         $var = new stdClass();
         $var->total = 10;
         return $var;
     });
     $cart1 = App::make('tmp');
     $cart2 = App::make('tmp');
     $this->assertEquals(10, $cart1->total);
     $this->assertEquals(10, $cart2->total);
     $this->assertEquals($cart1, $cart2);
 }

 public static function logTrail($input)
 {
     try {
         $currentString = \App::make('logTrail');
     } catch (\Exception $e) {
         \App::singleton('logTrail', 'stdClass');
         $currentString = \App::make('logTrail');
         $currentString->log = [];
     }
     if (is_array($input) || is_string($input)) {
         array_push($currentString->log, $input);
     } else {
         Log::info($input);
     }
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, \Closure $next)
 {
     if ($header = $request->header('Authorization')) {
         $access_token_array = sscanf($header, 'Bearer %s');
         if ($access_token = $access_token_array[0]) {
             try {
                 $token = \Firebase\JWT\JWT::decode($access_token, env('APP_KEY', ''), array('HS512'));
             } catch (\Firebase\JWT\ExpiredException $e) {
                 return ['error' => true, 'code' => 'token_expired', 'message' => ['Token expired']];
             } catch (\Exception $e) {
                 return ['error' => true, 'code' => 'token_invalid', 'message' => ['Token invalid']];
             }
             \App::singleton('JWTToken', 'stdClass');
             $jwttoken = \App::make('JWTToken');
             $jwttoken->token = $token;
         } else {
             return ['error' => true, 'code' => 'token_absent', 'message' => ['Token is missing']];
         }
     } else {
         return ['error' => true, 'code' => 'token_absent', 'message' => ['Token is missing']];
     }
     return $next($request);
 }

            $admin_locale = Config::get('app.admin_default_locale');
        }
    }
}
$language = null;
$admin_language = null;
if (!App::runningInConsole()) {
    $language = \Neonbug\Common\Models\Language::getByLocale($locale);
    if ($language == null) {
        exit('Language not found');
    }
    $admin_language = $admin_locale == $locale ? $language : \Neonbug\Common\Models\Language::getByLocale($admin_locale);
    if ($admin_language == null) {
        exit('Language not found');
    }
}
App::singleton('Language', function () use($language) {
    return $language;
});
App::singleton('AdminLanguage', function () use($admin_language) {
    return $admin_language;
});
App::singleton('LanguageRepository', '\\Neonbug\\Common\\Repositories\\LanguageRepository');
//frontend
Route::group(['middleware' => ['online']], function () use($locale) {
    Route::get('/', 'HomeController@index');
    //special route without locale prefix
    Route::group(['prefix' => $locale], function () {
        Route::get('/', 'HomeController@index');
    });
});

        });
    });
    post('upload/file', 'FileController@uploadFile');
    get('download/{id}', 'FileController@getDownload');
    Route::resource('project', 'ProjectController');
    Route::resource('clients', 'ClientController');
    Route::resource('role', 'RoleController');
});
App::bind('App\\Services\\Interfaces\\SendMailInterface', 'App\\Services\\SESSendMail');
/* Routes for desktop and mobile apps */
Route::group(['prefix' => 'rest'], function () {
    post('get-timeentries-by-uid', 'RestController@getTimeEntryByUid');
    post('auth', 'RestController@login');
    get('projects', 'RestController@getProjectList');
    get('tags', 'RestController@getTags');
    post('timesheet/save', 'RestController@save');
    post('timesheet/delete', 'RestController@deleteTimeEntry');
    post('timesheet/sync-timesheets', 'RestController@syncTimesheets');
});
/************************************  OAUTH  ***********************************************/
/* Routes for oauth */
post('oauth/token', 'Auth\\OAuthController@getOAuthToken');
//oauth singleton object
App::singleton('oauth2', function () {
    $storage = new OAuth2\Storage\Pdo(array('dsn' => 'mysql:dbname=' . env('DB_DATABASE') . ';host=' . env('DB_HOST'), 'username' => env('DB_USERNAME'), 'password' => env('DB_PASSWORD')));
    $server = new OAuth2\Server($storage, array('access_lifetime' => env('ACCESS_TOKEN_LIFETIME')));
    $server->addGrantType(new OAuth2\GrantType\ClientCredentials($storage));
    $server->addGrantType(new App\Http\Controllers\Auth\DesktopAppGrantType($storage));
    $server->addGrantType(new OAuth2\GrantType\RefreshToken($storage, ['always_issue_new_refresh_token' => true]));
    return $server;
});

|
*/
App::down(function () {
    return Response::make("Be right back!", 503);
});
/*
|--------------------------------------------------------------------------
| Require The Filters File
|--------------------------------------------------------------------------
|
| Next we will load the filters file for the application. This gives us
| a nice separate location to store our route and application filter
| definitions instead of putting them all in the main routes file.
|
*/
App::singleton('bugsnag', function () {
    $bugsnag = new Bugsnag_Client(Config::get('app.bugsnag_api_key'));
    $bugsnag->setReleaseStage(App::environment());
    return $bugsnag;
});
App::error(function ($exception) {
    App::make('bugsnag')->notifyException($exception, null, "error");
});
App::fatal(function ($exception) {
    App::make('bugsnag')->notifyException($exception, null, "error");
});
App::make('bugsnag')->setUser(['email' => Auth::check() ? Auth::user()->email : 'Guest user']);
App::make('bugsnag')->setBeforeNotifyFunction(function ($error) {
    $error->setMetaData(["user" => ["username" => Auth::check() ? Auth::user()->username : 'Guest user'], "metrics" => ["Metric 1" => "Some data here"]]);
});
require app_path() . '/filters.php';

| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the controller to call when that URI is requested.
|
*/
class Mailer
{
}
class RegisterUsers
{
    protected $mailer;
    public function __construct(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }
    public function setMailer(Mailer $mailer)
    {
        $this->mailer = $mailer;
    }
}
App::bind('foo', function () {
    return new RegisterUsers(new Mailer());
});
App::singleton('bar', function () {
    return new RegisterUsers(new Mailer());
});
$one = app('bar');
$two = app('bar');
var_dump($one, $two);
Route::get('/', function (RegisterUsers $sth) {
    return view('welcome');
});

<?php

/*
|--------------------------------------------------------------------------
| Application & Route Filters
|--------------------------------------------------------------------------
|
| Below you will find the "before" and "after" events for the application
| which may be used to do any work before or after a request into your
| application. Here you may also register your custom route filters.
|
*/
App::before(function ($request) {
    App::singleton('customURL', function () {
        //$customURL = 'http://kalugdanresort.com/public/';
        $customURL = '/';
        return $customURL;
    });
    // If you use this line of code then it'll be available in any view
    // as $site_settings but you may also use app('site_settings') as well
    View::share('customURL', app('customURL'));
});
App::after(function ($request, $response) {
    //
});
/*
|--------------------------------------------------------------------------
| Authentication Filters
|--------------------------------------------------------------------------
|
| The following filters are used to verify that the user of the current

 /**
  * Register bindings in the container.
  *
  * @return void
  */
 public function register()
 {
     \App::singleton('actingModel', function () {
         return new \App\Facades\ActingModel();
     });
 }

/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It's a breeze. Simply tell Laravel the URIs it should respond to
| and give it the controller to call when that URI is requested.
|
*/
App::singleton('oauth2', function () {
    $storage = new OAuth2\Storage\Pdo(array('dsn' => 'mysql:dbname=insantani;host=localhost', 'username' => 'root', 'password' => ''));
    $server = new OAuth2\Server($storage);
    $server->addGrantType(new OAuth2\GrantType\ClientCredentials($storage));
    $server->addGrantType(new OAuth2\GrantType\UserCredentials($storage));
    $server->addGrantType(new OAuth2\GrantType\RefreshToken($storage));
    $server->setScopeUtil(new OAuth2\Scope(array('supported_scopes' => array('read', 'write'))));
    return $server;
});
Route::get('/', function () {
    return view('welcome');
});
Route::get('api/products', ['uses' => 'ProductController@products', 'middleware' => 'products']);
Route::get('api/products/{id}', array('uses' => 'ProductController@productDetail', 'middleware' => 'products'))->where('id', '[0-9]+');
Route::get('api/products/{id}/picture', array('uses' => 'ProductController@showPicture', 'middleware' => 'products'))->where('id', '[0-9]+');
Route::get('api/feed', ['uses' => 'ArticleController@articles', 'middleware' => 'articles']);
Route::get('api/search/product/{query}', array('uses' => 'SearchController@searchProduct', 'middleware' => 'products'))->where('query', '.+');
Route::get('api/search/tag/{query}', array('uses' => 'SearchController@searchTags', 'middleware' => 'articles'))->where('query', '.+');
Route::get('api/feed/article/{id}', array('uses' => 'ArticleController@articleDetail', 'middleware' => 'articles'))->where('id', '[0-9]+');
Route::get('api/feed/article/{id}/picture', array('uses' => 'ArticleController@showPicture', 'middleware' => 'articles'))->where('id', '[0-9]+');