JMSSerializer stand alone - L'annotazione non esiste o non può essere caricata automaticamente

Question

Sto tentando di utilizzare JMSSerializer come libreria autonoma per mappare le risposte JSON da un'API alle mie classi modello e sto riscontrando alcuni problemi.

esecuzione il codice seguente genera un'eccezione:

<?php 
require dirname(__DIR__) . '/vendor/autoload.php'; 

use JMS\Serializer\Annotation AS JMS; 

class Trii { 
    /** 
    * User ID for this session 
    * @JMS\SerializedName("userID") 
    * @JMS\Annotation(getter="getUserId") 
    * @JMS\Type("string") 
    * @var string 
    */ 
    private $userId; 

    public function getUserId() { 
     return $this->userId; 
    } 

    public function setUserId($userId) { 
     $this->userId = $userId; 
    } 
} 

$serializer = \JMS\Serializer\SerializerBuilder::create()->setDebug(true)->build(); 
$object = $serializer->deserialize('{"userID":"Trii"}', 'Trii', 'json'); 
var_dump($object); 
?> 

Ecco l'eccezione

Doctrine\Common\Annotations\AnnotationException: [Semantical Error] The annotation "@JMS\Serializer\Annotation\SerializedName" in property Trii::$userId does not exist, or could not be auto-loaded. 

ho le seguenti librerie installate per il progetto tramite compositore

{ 
    "require": { 
     "jms/serializer": "1.0.*@dev" 
    } 
} 

Is c'è qualcosa di ovvio che mi manca perché non sto usando tutti i soluti di Doctrine 2 sopra?

EDIT: la mia soluzione finale era quello di creare un file di bootstrap con il seguente contenuto:

<?php 
// standard composer install vendor autoload magic 
require dirname(__DIR__) . '/vendor/autoload.php'; 

// Bootstrap the JMS custom annotations for Object to Json mapping 
\Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespace(
    'JMS\Serializer\Annotation', 
    dirname(__DIR__).'/vendor/jms/serializer/src' 
); 
?> 

Answer 1

Ho incontrato lo stesso problema e trovato la tua domanda tramite Google. Purtroppo non avevi ancora ricevuto alcuna risposta, quindi ho dovuto scavare in me stesso. : P

Il fatto è, Doctrine Annotations, che utilizza Annotazioni JMSSerializer, does NOT use normal PHP autoloading.

Come vengono caricate queste annotazioni? Dall'osservazione del codice è possibile indovinare che la mappatura ORM, la convalida dell'asserzione e l'annotazione completa possono essere caricate solo utilizzando i caricatori automatici PHP definiti. Tuttavia, questo non è il caso: per ragioni di gestione degli errori ogni controllo dell'esistenza della classe all'interno di AnnotationReader imposta il secondo parametro $ autoload di class_exists ($ name, $ autoload) su false. Per funzionare perfettamente, AnnotationReader richiede caricatori automatici silenziosi che molti autoloader non lo sono. L'autoloading silenzioso NON fa parte della specifica PSR-0 per l'autoloading.

Questo significa che si deve registrare il file di annotazione (s) da soli:

AnnotationRegistry::registerFile(
    <PROJECT ROOT> . 
    "/vendor/jms/serializer/src/JMS/Serializer/Annotation/SerializedName.php"); 

... o l'intero spazio dei nomi (metodo preferito):

AnnotationRegistry::registerAutoloadNamespace(
    'JMS\Serializer\Annotation', 
    <PROJECT ROOT> . "/vendor/jms/serializer/src"); 

stare attenti con il percorso in registerAutoloadNamespace. Ho provato a registrare l'intero percorso di annotazioni nello stesso modo con registerFile:

<PROJECT ROOT> . "/vendor/jms/serializer/src/JMS/Serializer/Annotation 

ma che fallito miseramente. : D

Spero che questo ti faccia fare un passo avanti. :)

Answer 2

Verificare le lettere maiuscole delle annotazioni. Ho avuto un problema simile durante la distribuzione da un ambiente di sviluppo di Windows su un server Ubuntu causato da un errore di battitura nel caso della mia annotazione. I file di Windows non fanno distinzione tra maiuscole e minuscole, quindi funzionano in questo modo ma falliscono su Linux.

Answer 3

@SirArturio ha la risposta corretta a questa Autoloading puzzle, e volevo solo aggiungere un tocco maggiore chiarezza in risposta a @messified o chiunque altro che lottano per ottenere questo lavoro.Come ha spiegato in modo eloquente, il gestore automatico di PSR-0 nel compositore, o SPL, non lo taglierà per il caricamento di queste annotazioni poiché utilizzano l'autoloading di Doctrine.

Quindi ecco un piccolo esempio completo. Ogni volta che si crea l'oggetto Serializer JMS per iniziare la serializzazione è un buon momento per aggiungere lo spazio dei nomi di annotazione al caricatore automatico di doctrine. Per amor di chiarezza sto assumendo alcun CIO, e gli spazi dei nomi pienamente qualificati (suggerimento di suggerimento, utilizzare l'iniezione di dipendenza):

<?php 
Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespace(
'JMS\Serializer\Annotation', 
$your_app_basepath . "/vendor/jms/serializer/src"); 


$serializer = JMS\Serializer\SerializerBuilder::create()->build(); 
$json_output = $serializer->serialize('MyProject\MyClass', 'json'); 

Poi, nel tuo MyProject \ MyClass:

<?php 
use JMS\Serializer\Annotation as JMS; 

class MyClass{ 

    /** @JMS\Exclude */ 
    private $something_secret; 
} 

E che dovrebbe tagliare, autoloading del file di annotazione appropriato usando doctrine al posto di compositore.

Answer 4

Abbastanza sicuro che questo consente il caricamento automatico silenzioso che è molto più conveniente rispetto alla registrazione dei domini.

AnnotationRegistry::registerLoader('class_exists'); 

Answer 5

Ecco la soluzione

1.Go alla directory php quindi installare compositore php compositore-setup.php 2. Vai al progetto directory sdk esempio

cd/Applications/XAMPP/xamppfiles/htdocs/streetreturn/adn_sdk-php-master

aggiornamento compositore per installare le dipendenze php /Users/zakir/composer.phar aggiornare

* Nota:/Utenti /zakir/composer.phar verrà individuato quando si installa compositore nel passaggio 1